diff --git a/20220926/hello-01-O.s b/20220926/hello-01-O.s
deleted file mode 100644
index cb01acba7d1f0e09cf72a12a32af03fc5c685059..0000000000000000000000000000000000000000
--- a/20220926/hello-01-O.s
+++ /dev/null
@@ -1,24 +0,0 @@
- .file "hello-01.c"
- .text
- .section .rodata.str1.1,"aMS",@progbits,1
-.LC0:
- .string "Hello, world!"
- .text
- .globl main
- .type main, @function
-main:
-.LFB11:
- .cfi_startproc
- subq $8, %rsp
- .cfi_def_cfa_offset 16
- leaq .LC0(%rip), %rdi
- call puts@PLT
- movl $0, %eax
- addq $8, %rsp
- .cfi_def_cfa_offset 8
- ret
- .cfi_endproc
-.LFE11:
- .size main, .-main
- .ident "GCC: (Debian 8.3.0-6) 8.3.0"
- .section .note.GNU-stack,"",@progbits
diff --git a/20220926/hello-01.c b/20220926/hello-01.c
deleted file mode 100644
index b19d80e9bd0bd7c5ed8f54b20c6a50d9166f03ac..0000000000000000000000000000000000000000
--- a/20220926/hello-01.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Hello, world!\n");
- return 0;
-}
diff --git a/20220926/hello-01.s b/20220926/hello-01.s
deleted file mode 100644
index b147da2a77ec8409c9906775295072971eb48f9a..0000000000000000000000000000000000000000
--- a/20220926/hello-01.s
+++ /dev/null
@@ -1,27 +0,0 @@
- .file "hello-01.c"
- .text
- .section .rodata
-.LC0:
- .string "Hello, world!"
- .text
- .globl main
- .type main, @function
-main:
-.LFB0:
- .cfi_startproc ; .cfi_startproc
- pushq %rbp ; subq $8, %rsp
- .cfi_def_cfa_offset 16 ; .cfi_def_cfa_offset 16
- .cfi_offset 6, -16 ; leaq .LC0(%rip), %rdi
- movq %rsp, %rbp ; call puts@PLT
- .cfi_def_cfa_register 6 ; movl $0, %eax
- leaq .LC0(%rip), %rdi ; addq $8, %rsp
- call puts@PLT ; .cfi_def_cfa_offset 8
- movl $0, %eax ; ret
- popq %rbp ; .cfi_endproc
- .cfi_def_cfa 7, 8
- ret
- .cfi_endproc
-.LFE0:
- .size main, .-main
- .ident "GCC: (Debian 8.3.0-6) 8.3.0"
- .section .note.GNU-stack,"",@progbits
diff --git a/20220926/hello-02.c b/20220926/hello-02.c
deleted file mode 100644
index 2dbbad99d102df43d00779483f789f03274353ca..0000000000000000000000000000000000000000
--- a/20220926/hello-02.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Hello, world!");
- return 0;
-}
diff --git a/20220926/hello-03.c b/20220926/hello-03.c
deleted file mode 100644
index ae37ad290203e4e490e3e2fac5a8080f7dfa0364..0000000000000000000000000000000000000000
--- a/20220926/hello-03.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Die Antwort lautet: ");
- printf (42);
- printf ("\n");
- return 0;
-}
diff --git a/20220926/hello-04.c b/20220926/hello-04.c
deleted file mode 100644
index 6a9b1daa3162c4b25d0a9eeaa93910c4625d1234..0000000000000000000000000000000000000000
--- a/20220926/hello-04.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Die Antwort lautet: ");
- printf ("42");
- printf ("\n");
- return 0;
-}
diff --git a/20220926/hello-05.c b/20220926/hello-05.c
deleted file mode 100644
index 8df53c4c95e8c3ae959324a1b7fa4f058aafc7ef..0000000000000000000000000000000000000000
--- a/20220926/hello-05.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Die Antwort lautet: %d\n", 42);
- return 0;
-}
diff --git a/20220926/hello-06.c b/20220926/hello-06.c
deleted file mode 100644
index c6946c2a4faf6b6bbd6a0e9148f15fe58cf76367..0000000000000000000000000000000000000000
--- a/20220926/hello-06.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int answer = 42;
- printf ("Die Antwort lautet: %d\n", answer);
- return 0;
-}
diff --git a/20220926/hello-gtk.c b/20220926/hello-gtk.c
deleted file mode 100644
index 016867d41e42de57390a21653de467c061e5ded0..0000000000000000000000000000000000000000
--- a/20220926/hello-gtk.c
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <gtk/gtk.h>
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
- gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
- GtkWidget *label = gtk_label_new ("Hello, world!");
- gtk_container_add (GTK_CONTAINER (vbox), label);
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
- gtk_widget_show (button);
- gtk_widget_show (label);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
-}
diff --git a/20220926/hello.c b/20220926/hello.c
deleted file mode 100644
index b19d80e9bd0bd7c5ed8f54b20c6a50d9166f03ac..0000000000000000000000000000000000000000
--- a/20220926/hello.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Hello, world!\n");
- return 0;
-}
diff --git a/20220926/hp-uebung-20220926.pdf b/20220926/hp-uebung-20220926.pdf
deleted file mode 100644
index 849ca3df582a3b8847019670eb96192886fb2a11..0000000000000000000000000000000000000000
Binary files a/20220926/hp-uebung-20220926.pdf and /dev/null differ
diff --git a/20220926/hp-uebung-20220926.tex b/20220926/hp-uebung-20220926.tex
deleted file mode 100644
index 15b74e5a4d3725a3de57bdd72ecbc58834d826d3..0000000000000000000000000000000000000000
--- a/20220926/hp-uebung-20220926.tex
+++ /dev/null
@@ -1,93 +0,0 @@
-% hp-uebung-20220926.pdf - Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Hello-World-Programme, Schaltjahr ermitteln, Maximum berechnen
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\thispagestyle{empty}
-
-\begin{document}
-
- \thispagestyle{empty}
-
- \section*{Hardwarenahe Programmierung\\
- Übungsaufgaben -- 26.\ September 2022}
-
- \exercise{Hello, world!}
-
- Unter \url{https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/20220926}
- können Sie
- \href{https://gitlab.cvh-server.de/pgerwinski/hp/raw/2021ws/20211004/hp-uebung-20220926.pdf}%
- {diesen Übungszettel als PDF-Datei}
- herunterladen sowie die folgenden Beispielprogramme:
- \begin{enumerate}[\quad(a)]
- \item \gitfile{hp}{2022ws/20220926}{hello.c}
- \item \gitfile{hp}{2022ws/20220926}{hello-gtk.c}
- \end{enumerate}
- Bringen Sie diese Programme auf Ihrem eigenen Rechner
- und/oder auf einem Rechner der Hochschule
- unter einem Betriebssystem Ihrer Wahl zum Laufen.
-
- \file{hello.c} ist das klassische "`Hello, world!"'-Programm;
- \file{hello-gtk} erzeugt ein Fenster mit einem Button zum Schließen.
- (Wie diese Programme im einzelnen funktionieren,
- wird im Laufe der Lehrveranstaltung erklärt werden.
- In dieser Übung geht es nur darum,
- sich mit dem Compilieren von C-Programmen vertraut zu machen.)
-
- \textbf{Hinweis 0:} Diese PDF-Datei enthält Links zu den jeweiligen Dateien.
- Durch Anklicken können Sie diese direkt herunterladen.
-
- \textbf{Hinweis 1:} Für (b) benötigen Sie die Bibliothek GTK+.
- Diese finden Sie -- einschließlich Dokumentation -- als freie Software im Internet.
-
- \textbf{Hinweis 2:} Unter Unix mit \lstinline[style=cmd]{gcc}
- funktioniert das Compilieren und Starten der Programme folgendermaßen:
- \begin{lstlisting}[style=cmd]
- gcc -Wall -O hello.c -o hello
- ./hello
- gcc -Wall -O $(pkg-config --cflags gtk+-3.0) hello-gtk.c \
- $(pkg-config --libs gtk+-3.0) -o hello-gtk
- ./hello-gtk
- \end{lstlisting}
-
- \exercise{Schaltjahr ermitteln}
-
- Schreiben Sie ein Programm in einer beliebigen Programmiersprache
- (z.\,B.\ C, Java, Python, Shell-Skript),
- das eine Jahreszahl erfragt und ausgibt, ob es sich um ein Schaltjahr handelt.
- \begin{itemize}
- \item Wenn die Jahreszahl durch 4 teilbar ist, ist das Jahr zunächst einmal ein Schaltjahr.
- \item Ausnahme: Wenn die Jahreszahl durch 100 teilbar ist, ist das Jahr kein Schaltjahr.
- \item Ausnahme von der Ausnahme: Wenn die Jahreszahl durch 400 teilbar ist,\\
- ist das Jahr doch wieder ein Schaltjahr.
- \end{itemize}
-
- \exercise{Maximum berechnen}
-
- Schreiben Sie ein Programm in einer beliebigen Programmiersprache,
- das 5 Zahlen erfragt und anschließend die größte dieser Zahlen ausgibt.
-
-\end{document}
diff --git a/20220926/if-01.c b/20220926/if-01.c
deleted file mode 100644
index a7eb40b2a3e446de27bdf2ba0a54d70cedeea941..0000000000000000000000000000000000000000
--- a/20220926/if-01.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 9;
- int b = 2;
- if (b != 0)
- printf ("%d\n", a / b);
- return 0;
-}
diff --git a/20220926/if-02.c b/20220926/if-02.c
deleted file mode 100644
index ebc8469b845706113cceb4a382c1e1b84edebc9c..0000000000000000000000000000000000000000
--- a/20220926/if-02.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 9;
- int b = 2;
- if (b != 0)
- printf ("%d\n", a % b);
- return 0;
-}
diff --git a/20220926/if-03.c b/20220926/if-03.c
deleted file mode 100644
index a5c87d8a502ca4c09924759da0dd8f93add008d0..0000000000000000000000000000000000000000
--- a/20220926/if-03.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 9;
- int b = 2;
- if (b)
- printf ("%d\n", a / b);
- return 0;
-}
diff --git a/20220926/if-04.c b/20220926/if-04.c
deleted file mode 100644
index 1d22ec8c394d2e0fbb48f4bf81156f1e06a19e2c..0000000000000000000000000000000000000000
--- a/20220926/if-04.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 9;
- int b = 0;
- if (b)
- printf ("%d\n", a / b);
- else
- printf ("Bitte nicht durch 0 dividieren.\n");
- return 0;
-}
diff --git a/20220926/if-05.c b/20220926/if-05.c
deleted file mode 100644
index 4b00da885ad6205a2d542434bbc0e62a15a2e344..0000000000000000000000000000000000000000
--- a/20220926/if-05.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 9;
- int b = 0;
- if (b)
- printf ("%d\n", a / b);
- else
- printf ("Bitte nicht durch 0 dividieren.\n");
- printf ("Das tut man nicht.\n");
- return 0;
-}
diff --git a/20220926/if-06.c b/20220926/if-06.c
deleted file mode 100644
index 38d4ff547eba41a550f31688f595d8588d12c056..0000000000000000000000000000000000000000
--- a/20220926/if-06.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 9;
- int b = 2;
- if (b)
- printf ("%d\n", a / b);
- else
- printf ("Bitte nicht durch 0 dividieren.\n");
- printf ("Das tut man nicht.\n");
- return 0;
-}
diff --git a/20220926/if-07.c b/20220926/if-07.c
deleted file mode 100644
index 61e765c74f893e99639ee2d5203e912837132ac5..0000000000000000000000000000000000000000
--- a/20220926/if-07.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 9;
- int b = 2;
- if (b)
- printf ("%d\n", a / b);
- else
- {
- printf ("Bitte nicht durch 0 dividieren.\n");
- printf ("Das tut man nicht.\n");
- }
- return 0;
-}
diff --git a/20220926/if-08.c b/20220926/if-08.c
deleted file mode 100644
index 98cc3f3575dc64ca04faa0b8c06a06cd85911439..0000000000000000000000000000000000000000
--- a/20220926/if-08.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 9;
- int b = 2;
- if (b) {
- printf ("%d\n", a / b);
- } else {
- printf ("Bitte nicht durch 0 dividieren.\n");
- printf ("Das tut man nicht.\n");
- }
- return 0;
-}
diff --git a/20220926/if-09.c b/20220926/if-09.c
deleted file mode 100644
index a46f9c5ce258de2bc3a861a990de2b418fc8304c..0000000000000000000000000000000000000000
--- a/20220926/if-09.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 9;
- int b = 2;
- if (b) {
- printf ("%d\n", a / b);
- } else {
- printf ("Bitte nicht durch 0 dividieren.\n");
- printf ("Das tut man nicht.\n");
-}
- return 0;
- }
diff --git a/20220926/if-10.c b/20220926/if-10.c
deleted file mode 100644
index 29f1ca7fa398dfe736fcd6b0320c3535c4f67039..0000000000000000000000000000000000000000
--- a/20220926/if-10.c
+++ /dev/null
@@ -1,4 +0,0 @@
-#include <stdio.h>
-int main (void) { int a = 9; int b = 2; if (b) { printf ("%d\n", a / b); }
-else { printf ("Bitte nicht durch 0 dividieren.\n"); printf ("Das tut man nicht.\n");
-} return 0; }
diff --git a/20220926/if-11.c b/20220926/if-11.c
deleted file mode 100644
index 115016e9207c760d3e7605c9bfc9336a0595785c..0000000000000000000000000000000000000000
--- a/20220926/if-11.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 9;
- int b = 2;
- if (b)
- {
- printf ("%d\n", a / b);
- }
- else
- {
- printf ("Bitte nicht durch 0 dividieren.\n");
- printf ("Das tut man nicht.\n");
- }
- return 0;
-}
diff --git a/20220926/if-12.c b/20220926/if-12.c
deleted file mode 100644
index e291f4225be4d4d444e6c1895a2839041c39119d..0000000000000000000000000000000000000000
--- a/20220926/if-12.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("%d\n", 1 > 0);
- return 0;
-}
diff --git a/20220926/if-13.c b/20220926/if-13.c
deleted file mode 100644
index d615f4821814b5cbc6a15d925310e9c0b5083a93..0000000000000000000000000000000000000000
--- a/20220926/if-13.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 1 > 0;
- printf ("%d\n", a);
- return 0;
-}
diff --git a/20220926/input-01.c b/20220926/input-01.c
deleted file mode 100644
index 5ca4c8c63cf313591a5a57e18c915329a3c71162..0000000000000000000000000000000000000000
--- a/20220926/input-01.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- double a;
- printf ("Bitte eine Zahl eingeben: ");
- scanf ("%lf", &a);
- printf ("Ihre Antwort war: %lf\n", a);
- return 0;
-}
diff --git a/20220926/input-02.c b/20220926/input-02.c
deleted file mode 100644
index 3c8912a1210787f322016cd6b611a3dd1bcaced3..0000000000000000000000000000000000000000
--- a/20220926/input-02.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- double a;
- printf ("Bitte eine Zahl eingeben: ");
- scanf ("%lf", a);
- printf ("Ihre Antwort war: %lf\n", a);
- return 0;
-}
diff --git a/20220926/input-03.c b/20220926/input-03.c
deleted file mode 100644
index cf2a21d8fccc2150610486374efa0d8c0606240d..0000000000000000000000000000000000000000
--- a/20220926/input-03.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- double a;
- printf ("Bitte eine Zahl eingeben: ");
- scanf ("%lf", &a);
- a = 2 * a;
- printf ("Das Doppelte ist: %lf\n", a);
- return 0;
-}
diff --git a/20220926/input-04.c b/20220926/input-04.c
deleted file mode 100644
index b8c58a39a39f78c4417b98f5a4bad118280de434..0000000000000000000000000000000000000000
--- a/20220926/input-04.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- double a = 3.14;
- printf ("Das Doppelte von %lf ist: %lf\n", a, 2 * a);
- return 0;
-}
diff --git a/20220926/input-05.c b/20220926/input-05.c
deleted file mode 100644
index b6b01519b4b48c2448e88280ca79d02a789c8dd6..0000000000000000000000000000000000000000
--- a/20220926/input-05.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- double a;
- a = 3.14;
- printf ("Das Doppelte von %lf ist: %lf\n", a, 2 * a);
- return 0;
-}
diff --git a/20220926/side-effects-01.c b/20220926/side-effects-01.c
deleted file mode 100644
index 61c4abb82e369b17b5acc83107b9baa598f371d2..0000000000000000000000000000000000000000
--- a/20220926/side-effects-01.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Hello, world!\n");
- "Hello, world!\n";
- return 0;
-}
diff --git a/20220926/side-effects-02.c b/20220926/side-effects-02.c
deleted file mode 100644
index 275a28e55e4568ff0e7f135bfaae8de819d224f7..0000000000000000000000000000000000000000
--- a/20220926/side-effects-02.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Hello, world!\n");
- 42;
- return 0;
-}
diff --git a/20220926/side-effects-03.c b/20220926/side-effects-03.c
deleted file mode 100644
index 41bf3a1f90ea07ada508c6dc4fe2b6f7afed0a9b..0000000000000000000000000000000000000000
--- a/20220926/side-effects-03.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = printf ("Hello, world!\n");
- printf ("a = %d\n", a);
- return 0;
-}
diff --git a/20220926/side-effects-04.c b/20220926/side-effects-04.c
deleted file mode 100644
index a0154b80d373b2e3789ecbf849eac931e28d1a13..0000000000000000000000000000000000000000
--- a/20220926/side-effects-04.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 3;
- printf ("-a = %d\n", -a);
- return 0;
-}
diff --git a/20220926/side-effects-05.c b/20220926/side-effects-05.c
deleted file mode 100644
index 05d6e19e9cc6107dd0d092f428c89987e179bcf4..0000000000000000000000000000000000000000
--- a/20220926/side-effects-05.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 3;
- int b = 7;
- printf ("a + b = %d\n", a + b);
- return 0;
-}
diff --git a/20220926/side-effects-06.c b/20220926/side-effects-06.c
deleted file mode 100644
index d18e48f9870275341c3d00de9fe92db735aa3a64..0000000000000000000000000000000000000000
--- a/20220926/side-effects-06.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 3;
- int b = 7;
- printf ("a += b = %d\n", a += b);
- return 0;
-}
diff --git a/20220926/side-effects-07.c b/20220926/side-effects-07.c
deleted file mode 100644
index 62d6041a140ac96e1d77452bd79dd4f3389e6d4d..0000000000000000000000000000000000000000
--- a/20220926/side-effects-07.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 3;
- int b = 7;
- printf ("a += b = %d\n", a += b);
- printf ("a = %d\n", a);
- return 0;
-}
diff --git a/20220926/side-effects-08.c b/20220926/side-effects-08.c
deleted file mode 100644
index 69eea137842d66df11f7b2053984b733a3e69c61..0000000000000000000000000000000000000000
--- a/20220926/side-effects-08.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 3;
- int b = 7;
- printf ("a + b = %d\n", a + b);
- printf ("a = %d\n", a);
- return 0;
-}
diff --git a/20220926/side-effects-09.c b/20220926/side-effects-09.c
deleted file mode 100644
index 070e7d71afd2cff9dedf86d8b754588fe20b8362..0000000000000000000000000000000000000000
--- a/20220926/side-effects-09.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int pi = 3,14;
- printf ("pi = %d\n", pi);
- return 0;
-}
diff --git a/20220926/side-effects-10.c b/20220926/side-effects-10.c
deleted file mode 100644
index 51fef72c094324dabe42b212d0fc0a9d79284789..0000000000000000000000000000000000000000
--- a/20220926/side-effects-10.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int pi;
- pi = 3,14;
- printf ("pi = %d\n", pi);
- return 0;
-}
diff --git a/20220926/side-effects-11.c b/20220926/side-effects-11.c
deleted file mode 100644
index 3faa6221bb149da7b17fad7b68905fcba26e6131..0000000000000000000000000000000000000000
--- a/20220926/side-effects-11.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int pi;
- pi = (3,14);
- printf ("pi = %d\n", pi);
- return 0;
-}
diff --git a/20220926/side-effects-12.c b/20220926/side-effects-12.c
deleted file mode 100644
index af3ea2bb093bb7f2478a12965713a3cfc7dabab2..0000000000000000000000000000000000000000
--- a/20220926/side-effects-12.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int pi;
- pi = 3.14;
- printf ("pi = %d\n", pi);
- return 0;
-}
diff --git a/20220926/side-effects-13.c b/20220926/side-effects-13.c
deleted file mode 100644
index 3706b07714088ee94340dc1141e3633baecb098f..0000000000000000000000000000000000000000
--- a/20220926/side-effects-13.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int i = 3;
- i++;
- printf ("i = %d\n", i);
- return 0;
-}
diff --git a/20220926/side-effects-14.c b/20220926/side-effects-14.c
deleted file mode 100644
index eaf2ea37bb48a3f9fec536ca4a9d2d838007cee9..0000000000000000000000000000000000000000
--- a/20220926/side-effects-14.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int i = 3;
- printf ("i = %d\n", i++);
- return 0;
-}
diff --git a/20220926/side-effects-15.c b/20220926/side-effects-15.c
deleted file mode 100644
index a417fabb96ea00231138b219536d2c0593b0a25e..0000000000000000000000000000000000000000
--- a/20220926/side-effects-15.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int i = 3;
- printf ("i = %d\n", i++);
- printf ("i = %d\n", i++);
- return 0;
-}
diff --git a/20220926/side-effects-16.c b/20220926/side-effects-16.c
deleted file mode 100644
index d5c8f724f2d8766385aef983f06d142435e31018..0000000000000000000000000000000000000000
--- a/20220926/side-effects-16.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int i = 3;
- printf ("i = %d\n", ++i);
- printf ("i = %d\n", ++i);
- return 0;
-}
diff --git a/20220926/while-01.c b/20220926/while-01.c
deleted file mode 100644
index 84912102488878cd3ad2ee11cf84551de8403fc1..0000000000000000000000000000000000000000
--- a/20220926/while-01.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a;
- a = 1;
- while (a <= 10)
- {
- printf ("%d\n", a);
- a = a + 1;
- }
- return 0;
-}
diff --git a/20220926/while-02.c b/20220926/while-02.c
deleted file mode 100644
index ad1323b373fdb5ea197fc9f53b8c0a388b6e6c19..0000000000000000000000000000000000000000
--- a/20220926/while-02.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a;
- for (a = 1; a <= 10; a = a + 1)
- printf ("%d\n", a);
- return 0;
-}
diff --git a/20220926/while-03.c b/20220926/while-03.c
deleted file mode 100644
index d3fc45ff1ca0b85e01282a7c2bf473c85f071862..0000000000000000000000000000000000000000
--- a/20220926/while-03.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a;
- a = 1;
- do
- {
- printf ("%d\n", a);
- a = a + 1;
- }
- while (a <= 10);
- return 0;
-}
diff --git a/20220926/while-04.c b/20220926/while-04.c
deleted file mode 100644
index 0fda44ad08fa963bc6229f32329e11d9f79109b2..0000000000000000000000000000000000000000
--- a/20220926/while-04.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a;
- for (a = 1; a > 10; a = a + 1)
- printf ("%d\n", a);
- return 0;
-}
diff --git a/20220926/while-05.c b/20220926/while-05.c
deleted file mode 100644
index ab32889936d61b2fdaec641cf8ea453c4ca27711..0000000000000000000000000000000000000000
--- a/20220926/while-05.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 1;
- while (a <= 10)
- printf ("%d\n", a++);
- return 0;
-}
diff --git a/20220926/while-06.c b/20220926/while-06.c
deleted file mode 100644
index eb77790700657077a683f33d339f42f26982a1b2..0000000000000000000000000000000000000000
--- a/20220926/while-06.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- for (int a = 1; a <= 10; printf ("%d\n", a++));
- return 0;
-}
diff --git a/20220926/while-07.c b/20220926/while-07.c
deleted file mode 100644
index e39422e7523a6d72641954db79ffbc460ebb8708..0000000000000000000000000000000000000000
--- a/20220926/while-07.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 1;
- while (1)
- {
- if (a > 10)
- break;
- printf ("%d\n", a);
- a++;
- }
- return 0;
-}
diff --git a/20220926/while-08.c b/20220926/while-08.c
deleted file mode 100644
index ea5d22f70221add949ee0ee09acf5726afa29c06..0000000000000000000000000000000000000000
--- a/20220926/while-08.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 1;
- while (1)
- {
- if (a > 10)
- {
- printf ("Eintrag gefunden: %d\n", a);
- if (a > 42)
- printf ("Eintrag ist größer als 42.\n");
- break;
- }
- printf ("%d\n", a);
- a++;
- }
- return 0;
-}
diff --git a/20220926/while-09.c b/20220926/while-09.c
deleted file mode 100644
index 8b7d3fe155b64db30c2a90993ce8a83a205d1292..0000000000000000000000000000000000000000
--- a/20220926/while-09.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 1;
- while (a <= 10)
- {
- printf ("%d\n", a);
- a++;
- }
- if (a > 10)
- {
- printf ("Eintrag gefunden: %d\n", a);
- if (a > 42)
- printf ("Eintrag ist größer als 42.\n");
- }
- return 0;
-}
diff --git a/20220926/while-10.c b/20220926/while-10.c
deleted file mode 100644
index 490c4b3bcd52cb615eb2296ea1fcb39659abcdfa..0000000000000000000000000000000000000000
--- a/20220926/while-10.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 1;
- loop:
- if (a > 10)
- goto endloop;
- printf ("%d\n", a++);
- goto loop;
- endloop:
- return 0;
-}
diff --git a/20220926/while-11.c b/20220926/while-11.c
deleted file mode 100644
index 5c1ece5438affbf59b22e7cd24e3fee6fb57f3f6..0000000000000000000000000000000000000000
--- a/20220926/while-11.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 1;
- loop:
- if (a > 10)
- goto endloop;
- printf ("%d\n", a++);
- goto loop;
- int i = 7;
- endloop:
- printf ("i = %d\n", i);
- return 0;
-}
diff --git a/20221006/hp-2022ws-p1.pdf b/20221006/hp-2022ws-p1.pdf
deleted file mode 100644
index 891ed5f47d0a862ae3e81fbcb986aaadd5fced4a..0000000000000000000000000000000000000000
Binary files a/20221006/hp-2022ws-p1.pdf and /dev/null differ
diff --git a/20221006/hp-2022ws-p1.tex b/20221006/hp-2022ws-p1.tex
deleted file mode 100644
index bf2129cb96f751d7ee5543ca12e028ec3b5d923f..0000000000000000000000000000000000000000
--- a/20221006/hp-2022ws-p1.tex
+++ /dev/null
@@ -1,204 +0,0 @@
-% hp-2022ws-p1.pdf - Labor Notes on Low-Level Programming
-% Copyright (C) 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Versuch 1: RSA-Verschlüsselung
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-\usepackage{multicol}
-\usepackage{sfmath}
-
-\sloppy
-\pagestyle{empty}
-\addtolength{\textheight}{1cm}
-\newcommand{\sep}{~$\cdot$~}
-\newcommand{\mylicense}{CC BY-SA (Version 4.0) oder GNU GPL (Version 3 oder höher)}
-
-\begin{document}
-
- \makebox(0,0.005)[tl]{\includegraphics[scale=0.72]{logo-hochschule-bochum-cvh-text-v2.pdf}}\hfill
- \makebox(0,0)[tr]{\includegraphics[scale=0.5]{logo-hochschule-bochum.pdf}}
- \par\bigskip\bigskip
- \begin{center}
- \Large\textbf{Praktikumsversuch 1: RSA-Verschlüsselung}
- \par\medskip
- \normalsize Hardwarenahe Programmierung\sep
- Wintersemester 2022/23\sep
- Prof.~Dr.~Peter Gerwinski
- \end{center}
-
- Aufgabe: Schreiben Sie ein Programm, das
- die Verschlüsselung nach Rivest, Shamir und Adleman (RSA)
- sowie die Schwierigkeiten beim Brechen ("`Knacken"') der
- Verschlüsselung demonstriert.
-
- \begin{multicols}{2}
-
- Schreiben Sie ein C-Programm (oder mehrere),
- das folgendes durchführt:
-
- \begin{itemize}
- \item
- \textbf{Schlüsselerzeugung}
-
- Bestimmen Sie drei verschiedene Primzahlen $p$, $q$ und $e$, wobei $e$
- kleiner als $(\kern0.5pt p-1)\cdot(q-1)$ und teilerfremd zu $(\kern0.5pt p-1)\cdot(q-1)$ sei.
- (Dies ist z.\,B.\ der Fall, wenn $e$ größer als $p$ und $q$ ist.)
-
- Berechnen Sie $N = p \cdot q$
- sowie eine natürliche Zahl $d$ mit der Eigenschaft:
- \begin{displaymath}
- (e \cdot d) \,\%\, \bigl((\kern0.5pt p-1)\cdot(q-1)\bigr) = 1
- \end{displaymath}
- ("`$x \,\%\, y\/$"' wird "`x modulo y"' gesprochen und steht
- für den Rest, der bei Division von $x$ durch $y$ verbleibt.)
-
- $N$ und $e$ sind der \newterm{öffentliche Schlüssel}. \\
- $p$, $q$ und $d$ sind der \newterm{geheime Schlüssel}.
-
- \item
- \textbf{Verschlüsselung}
-
- Wählen Sie eine geheime Botschaft $m$ eine Zahl kleiner als $N$,
- die Sie verschlüsseln wollen.
-
- $m$ muß teilerfremd zu $N$ sein.
- (Dies ist der Fall, wenn $m$ weder durch $p$ noch durch $q$ teilbar ist.)
-
- Schreiben Sie ein Programm, das aus $m$ die verschlüsselte
- Nachricht $c$ berechnet:
- \begin{displaymath}
- c = m^e ~\%\, N
- \end{displaymath}
-
- \textbf{Hinweis:}
- \begin{displaymath}
- m^e ~\%\, N
- = \underbrace{(m \cdot m \cdot \dots \cdot m)}_{\mbox{$e$ Faktoren}} \,\%\, N
- \hspace*{2cm}
- \end{displaymath}
- \vspace*{-\medskipamount}
- \begin{displaymath}
- = \underbrace{\Bigl(\dots\bigl((m \cdot m) \,\%\, N \cdot m\bigr) \,\%\, N \cdot \dots \cdot m\Bigr) \,\%\, N}_{\mbox{$e$ Faktoren}}
- \end{displaymath}
-
- Dies bedeutet: Multiplizieren Sie die Zahl $m$ $e$-mal mit sich selbst,
- wobei Sie \emph{nach jeder Multiplikation\/} modulo $N$ rechnen.
-
- \item
- \textbf{Entschlüsselung}
-
- Rekonstruieren Sie aus der verschlüsselten Botschaft $c$
- wieder die geheime Botschaft $m$:
- \begin{displaymath}
- m = c^d ~\%\, N
- \end{displaymath}
-
- \item
- \textbf{Verschlüsselung brechen}
-
- Rekonstruieren Sie aus der verschlüsselten Botschaft $c$
- wieder die geheime Botschaft $m$,
- \emph{ohne\/} den geheimen Schlüssel zu kennen,
- d.\,h.\ Sie kennen nur $N$ und $e$, nicht jedoch $p$, $q$ und $d$.
-
- \textbf{Hinweis:}
- Sie können z.\,B.\ versuchen, $N$ in seine Primfaktoren zu zerlegen.
- Auf diese Weise können Sie zunächst $p$ und $q$ berechnen und danach $d$.
-
- \item
- \textbf{Rechenzeit vergleichen}
-
- Vergleichen Sie nun
- die für das Brechen der Verschlüsselung benötigte Rechenzeit
- mit der Zeit, die das reguläre Ver- und Entschlüsseln dauert.
- (Auf diesem Schwierigkeitsunterschied
- beruht die Sicherheit der RSA-Verschlüsselung.)
-
- \textbf{Hinweis 1:}
-% Wenn Sie ein Programm per Kommandozeile mit \lstinline[style=cmd]{time ./programm} starten,
-% wird Ihnen angezeigt, wieviel Rechenzeit das Programm benötigt hat.
-% Die drei angezeigten Werte stehen hierbei für die
-% tatsächlich verstrichene Gesamtzeit (\lstinline[style=terminal]{real}),
-% für die mit Rechnen verbrachte Zeit (\lstinline[style=terminal]{user})
-% und für die mit Systemaufrufen (z.\,B.\ Ein- und Ausgabe)
-% verbrachte Zeit (\lstinline[style=terminal]{sys}).
- Ein einfacher Weg, die von Ihrem Programm benötigte Rechenzeit zu messen,
- ist die Verwendung der Funktion \lstinline{clock()}.
- Diese gibt zurück, wieviel Rechenzeit seit Programmstart aufgewendet wurde.
- Der Typ dieses Rückgabewerts ist ein ganzzahliger Typ, \lstinline{clock_t},
- mit dem man rechnen und den man mit \lstinline{%ld} ausgeben kann.
- Pro Sekunde wächst der Zähler um \lstinline{CLOCKS_PER_SEC} Einheiten.
- Typischerweise hat \lstinline{CLOCKS_PER_SEC} den Wert \lstinline{1000000}
- oder \lstinline{1000}, die Zeiteinheit ist also eine Mikrosekunde
- bzw.\ eine Millisekunde.
-
- \textbf{Hinweis 2:}
- Die mit der o.\,a.\ Methode meßbaren Zeiten sind eigentlich zu ungenau,
- um damit die sehr kurzen Rechenzeiten erfassen zu können --
- etwa so, als wollten Sie mit einem Lineal mit Millimetereinteilung
- die Dicke eines Blatts Papier messen. Beides ist jedoch möglich.
-
-% \item
-% Die \textbf{Abgabe} erfolgt auf einem zur Verfügung gestellten USB-Stick.
-% Legen Sie dort ein Verzeichnis gemäß Ihrem Namen an,
-% wie er in Ihrer Hochschul-E-Mail-Adresse auftaucht
-% (z.\,B.\ \file{hans-joerg.mueller-mustermann}
-% und speichern Sie darin Ihre \emph{Quelltexte}
-% mit den Lösungen der Praktikumsaufgabe
-% (und insbesondere \emph{nicht} die ausführbaren Dateien).
-% Vermerken Sie bitte außerdem die folgenden Angaben
-% entweder als Kommentar im Quelltext oder in einer separaten Textdatei:
-% Name in korrekter Schreibweise, Matrikel-Nummer,
-% Studiengang (MI/MP/TI) und Studienmodell (KIA/KIS/GS).
-
- \end{itemize}
-
- \end{multicols}
-
- \vspace*{-\bigskipamount}
-
- \strut\hfill\emph{Viel Erfolg!}
-
- \vfill
-
- \begingroup
-
- \small
-
- \setlength{\leftskip}{3cm}
-
- Stand: 4.\ Oktober 2022
-
-% Soweit nicht anders angegeben:\\
- Copyright \copyright\ 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022\quad Peter Gerwinski\\
- Lizenz: \mylicense
-
- Sie können diese Praktikumsunterlagen einschließlich \LaTeX-Quelltext
-%% und Beispielprogramme\\
- herunterladen unter:\\
- \url{https://gitlab.cvh-server.de/pgerwinski/hp}
-
- \endgroup
-
-\end{document}
diff --git a/20221006/logo-hochschule-bochum-cvh-text-v2.pdf b/20221006/logo-hochschule-bochum-cvh-text-v2.pdf
deleted file mode 120000
index 4aa99b8f81061aca6dcaf43eed2d9efef40555f8..0000000000000000000000000000000000000000
--- a/20221006/logo-hochschule-bochum-cvh-text-v2.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
diff --git a/20221006/logo-hochschule-bochum.pdf b/20221006/logo-hochschule-bochum.pdf
deleted file mode 120000
index b6b9491e370e499c9276918182cdb82cb311bcd1..0000000000000000000000000000000000000000
--- a/20221006/logo-hochschule-bochum.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20221006/pgscript.sty b/20221006/pgscript.sty
deleted file mode 120000
index 95c888478c99ea7fda0fd11ccf669ae91be7178b..0000000000000000000000000000000000000000
--- a/20221006/pgscript.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgscript.sty
\ No newline at end of file
diff --git a/20221010/arrays-01.c b/20221010/arrays-01.c
deleted file mode 100644
index 35cf856c63942234116544ac721ff0a47d797b09..0000000000000000000000000000000000000000
--- a/20221010/arrays-01.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int prime[5] = { 2, 3, 5, 7, 11 };
- int *p = prime;
- for (int i = 0; i < 5; i++)
- printf ("%d\n", *(p + i));
- return 0;
-}
diff --git a/20221010/arrays-02.c b/20221010/arrays-02.c
deleted file mode 100644
index d206e6c3296fe7f7e48febd10893a5be65fca67a..0000000000000000000000000000000000000000
--- a/20221010/arrays-02.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int prime[5] = { 2, 3, 5, 7, 11 };
- int *p = prime;
- for (int i = 0; i < 5; i++)
- printf ("%d\n", p[i]);
- return 0;
-}
diff --git a/20221010/arrays-03.c b/20221010/arrays-03.c
deleted file mode 100644
index 83a03a4fe9425d684db38f0219cd9e9e19b405ba..0000000000000000000000000000000000000000
--- a/20221010/arrays-03.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int prime[5] = { 2, 3, 5, 7, 11 };
- for (int i = 0; i < 5; i++)
- printf ("%d\n", prime[i]);
- return 0;
-}
diff --git a/20221010/arrays-04.c b/20221010/arrays-04.c
deleted file mode 100644
index 2015ffc6cd5057daaa755294ab4af602559eefa4..0000000000000000000000000000000000000000
--- a/20221010/arrays-04.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int prime[5] = { 2, 3, 5, 7, 11 };
- for (int *p = prime; p < prime + 5; p++)
- printf ("%d\n", *p);
- return 0;
-}
diff --git a/20221010/arrays-05.c b/20221010/arrays-05.c
deleted file mode 100644
index a24238adf6daadf18acfa27e1da7881802c7ed75..0000000000000000000000000000000000000000
--- a/20221010/arrays-05.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int prime[5] = { 2, 3, 5, 7, 11 };
- for (int *p = prime; p <= prime + 5; p++)
- printf ("%d\n", *p);
- return 0;
-}
diff --git a/20221010/arrays-06.c b/20221010/arrays-06.c
deleted file mode 100644
index 82ab32dfc4fc73c3a700a6e88a50202029934ca1..0000000000000000000000000000000000000000
--- a/20221010/arrays-06.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int prime[5] = { 2, 3, 5, 7, 11 };
- for (int i = 0; i <= 5; i++)
- printf ("%d\n", prime[i]);
- return 0;
-}
diff --git a/20221010/arrays-07.c b/20221010/arrays-07.c
deleted file mode 100644
index dcf32170d4658f2eafdf436809e9a9aa0e56379b..0000000000000000000000000000000000000000
--- a/20221010/arrays-07.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int prime[6] = { 2, 3, 5, 7, 11, 0 };
- for (int *p = prime; *p; p++)
- printf ("%d\n", *p);
- return 0;
-}
diff --git a/20221010/arrays-08.c b/20221010/arrays-08.c
deleted file mode 100644
index 3437adea44f78176745a1d1b6be31c9cb4a63dfc..0000000000000000000000000000000000000000
--- a/20221010/arrays-08.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int prime[] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 0 };
- for (int *p = prime; *p; p++)
- printf ("%d\n", *p);
- return 0;
-}
diff --git a/20221010/arrays-09.c b/20221010/arrays-09.c
deleted file mode 100644
index 0bd5cbdc7de1ff9a37a649772bab6bb0b99666b4..0000000000000000000000000000000000000000
--- a/20221010/arrays-09.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int prime[15] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 0 };
- for (int *p = prime; *p; p++)
- printf ("%d\n", *p);
- prime[9] = 29;
- prime[10] = 0;
- for (int *p = prime; *p; p++)
- printf ("%d\n", *p);
- return 0;
-}
diff --git a/20221010/aufgabe-4.c b/20221010/aufgabe-4.c
deleted file mode 100644
index b8b3de796fbef94bd4a86f944e1269b97e97982b..0000000000000000000000000000000000000000
--- a/20221010/aufgabe-4.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- for (int i = 10; i = 0; i - 1)
- printf ("%d\n", i);
- return 0;
-}
diff --git a/20221010/functions-01.c b/20221010/functions-01.c
deleted file mode 100644
index e1adaf78b6f48b158980dccbb9f5fe378a4c89d5..0000000000000000000000000000000000000000
--- a/20221010/functions-01.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-
-void hello ()
-{
- printf ("Hello, world!\n");
-}
-
-int main ()
-{
- hello ();
- return 0;
-}
diff --git a/20221010/functions-02.c b/20221010/functions-02.c
deleted file mode 100644
index 16f2559f5d08a624c26270963e371dd3c6e03219..0000000000000000000000000000000000000000
--- a/20221010/functions-02.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-
-void hello ()
-{
- printf ("Hello, world!\n");
-}
-
-int main ()
-{
- hello ("Hallo, Welt!\n");
- return 0;
-}
diff --git a/20221010/functions-03.c b/20221010/functions-03.c
deleted file mode 100644
index 53b28487f1c20f717520b2469a1aeb4906eba6d6..0000000000000000000000000000000000000000
--- a/20221010/functions-03.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-
-void hello (void)
-{
- printf ("Hello, world!\n");
-}
-
-int main (void)
-{
- hello ("Hallo, Welt!\n");
- return 0;
-}
diff --git a/20221010/functions-04.c b/20221010/functions-04.c
deleted file mode 100644
index b1c31984589edfe971ddf8c24357338314706237..0000000000000000000000000000000000000000
--- a/20221010/functions-04.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-void philosophy (a)
- int a;
-{
- printf ("The answer is: %d.\n", a);
-}
-
-int main (void)
-{
- philosophy (137);
- return 0;
-}
diff --git a/20221010/functions-05.c b/20221010/functions-05.c
deleted file mode 100644
index d9ef21add0b8698a83e7684392480742d822bf36..0000000000000000000000000000000000000000
--- a/20221010/functions-05.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-void philosophy (a)
- int a;
-{
- printf ("The answer is: %d.\n", a);
-}
-
-int main (void)
-{
- philosophy ("Hello, world!\n");
- return 0;
-}
diff --git a/20221010/functions-05.txt b/20221010/functions-05.txt
deleted file mode 100644
index 8a6213744eefbe1e1b60e91521b55ff3863f9063..0000000000000000000000000000000000000000
--- a/20221010/functions-05.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <stdio.h>
-
-void philosophy (a)
- int a;
-{
- printf ("The answer is: %d.\n", a);
-}
-
-int main (void)
-{
- philosophy ("Hello, world!\n");
- return 0;
-}
-cassini/home/peter/bo/2022ws/hp/20221010> gcc -Wall -O functions-05.c -o functions-05
-cassini/home/peter/bo/2022ws/hp/20221010> ./functions-05
-The answer is: -1434640360.
-cassini/home/peter/bo/2022ws/hp/20221010> ./functions-05
-The answer is: -402571240.
-cassini/home/peter/bo/2022ws/hp/20221010> ./functions-05
-The answer is: 588369944.
-cassini/home/peter/bo/2022ws/hp/20221010> ./functions-05
-The answer is: 97824792.
-cassini/home/peter/bo/2022ws/hp/20221010>
diff --git a/20221010/functions-06.c b/20221010/functions-06.c
deleted file mode 100644
index 6d849e0dc18e8c2e37bedaa7a2628800581fffce..0000000000000000000000000000000000000000
--- a/20221010/functions-06.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-
-void philosophy (int a)
-{
- printf ("The answer is: %d.\n", a);
-}
-
-int main (void)
-{
- philosophy ("Hello, world!\n");
- return 0;
-}
diff --git a/20221010/functions-07.c b/20221010/functions-07.c
deleted file mode 100644
index d44829bf9a4659c294eaec84db8395fe834962ed..0000000000000000000000000000000000000000
--- a/20221010/functions-07.c
+++ /dev/null
@@ -1,24 +0,0 @@
-#include <stdio.h>
-
-int a, b = 3;
-
-void foo (void)
-{
- b++;
- static int a = 5;
- int b = 7;
- printf ("foo(): " "a = %d, b = %d\n", a, b);
- a++;
-}
-
-int main (void)
-{
- printf ("main(): " "a = %d, b = %d\n", a, b);
- return 0;
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
- a = b = 12;
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
-}
diff --git a/20221010/functions-08.c b/20221010/functions-08.c
deleted file mode 100644
index 48446d7ff20fc63e8ed827e5db0fed48e51e4315..0000000000000000000000000000000000000000
--- a/20221010/functions-08.c
+++ /dev/null
@@ -1,25 +0,0 @@
-#include <stdio.h>
-
-int a;
-int b = 3;
-
-void foo (void)
-{
- b++;
- static int a = 5;
- int b = 7;
- printf ("foo(): " "a = %d, b = %d\n", a, b);
- a++;
-}
-
-int main (void)
-{
- printf ("main(): " "a = %d, b = %d\n", a, b);
- return 0;
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
- a = b = 12;
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
-}
diff --git a/20221010/functions-09.c b/20221010/functions-09.c
deleted file mode 100644
index 77b42dfdd943a2a5fd266f7782434fe1b5f3b5ab..0000000000000000000000000000000000000000
--- a/20221010/functions-09.c
+++ /dev/null
@@ -1,25 +0,0 @@
-#include <stdio.h>
-
-int a = 0;
-int b = 3;
-
-void foo (void)
-{
- b++;
- static int a = 5;
- int b = 7;
- printf ("foo(): " "a = %d, b = %d\n", a, b);
- a++;
-}
-
-int main (void)
-{
- printf ("main(): " "a = %d, b = %d\n", a, b);
- return 0;
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
- a = b = 12;
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
-}
diff --git a/20221010/functions-10.c b/20221010/functions-10.c
deleted file mode 100644
index f132d2e86b139f742568178b2eaad1364e9b09b8..0000000000000000000000000000000000000000
--- a/20221010/functions-10.c
+++ /dev/null
@@ -1,25 +0,0 @@
-#include <stdio.h>
-
-int a = 0;
-int b = 3;
-
-void foo (void)
-{
- b++;
- static int a = 5;
- int b = 7;
- printf ("foo(): " "a = %d, b = %d\n", a, b);
- a++;
-}
-
-int main (void)
-{
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- return 0;
- printf ("main(): " "a = %d, b = %d\n", a, b);
- a = b = 12;
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
-}
diff --git a/20221010/functions-11.c b/20221010/functions-11.c
deleted file mode 100644
index b42cee93f5be7620a55bb685796ae30a122883ed..0000000000000000000000000000000000000000
--- a/20221010/functions-11.c
+++ /dev/null
@@ -1,25 +0,0 @@
-#include <stdio.h>
-
-int a = 0;
-int b = 3;
-
-void foo (void)
-{
- b++;
- static int a = 5;
- int b = 7;
- printf ("foo(): " "a = %d, b = %d\n", a, b);
- a++;
-}
-
-int main (void)
-{
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
- return 0;
- a = b = 12;
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
-}
diff --git a/20221010/functions-12.c b/20221010/functions-12.c
deleted file mode 100644
index 3e707373990ea2e59dd1a529eca5ef8adfd2daa0..0000000000000000000000000000000000000000
--- a/20221010/functions-12.c
+++ /dev/null
@@ -1,25 +0,0 @@
-#include <stdio.h>
-
-int a = 0;
-int b = 3;
-
-void foo (void)
-{
- b++;
- static int a = 5;
- int b = 7;
- printf ("foo(): " "a = %d, b = %d\n", a, b);
- a++;
-}
-
-int main (void)
-{
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
- a = b = 12;
- printf ("main(): " "a = %d, b = %d\n", a, b);
- return 0;
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
-}
diff --git a/20221010/functions-13.c b/20221010/functions-13.c
deleted file mode 100644
index 5ec0af58c608791fa2e1ca5f93668003219b8199..0000000000000000000000000000000000000000
--- a/20221010/functions-13.c
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <stdio.h>
-
-int a = 0;
-int b = 3;
-
-void foo (void)
-{
- b++;
- static int a = 5;
- int b = 7;
- printf ("foo(): " "a = %d, b = %d\n", a, b);
- a++;
-}
-
-int main (void)
-{
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
- b = 12;
- a = b;
- printf ("main(): " "a = %d, b = %d\n", a, b);
- return 0;
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
-}
diff --git a/20221010/functions-14.c b/20221010/functions-14.c
deleted file mode 100644
index 6ea1d0da07e6f8479b0f0dc6cbabc1fde99e5a5d..0000000000000000000000000000000000000000
--- a/20221010/functions-14.c
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <stdio.h>
-
-int a = 0;
-int b = 3;
-
-void foo (void)
-{
- b++;
- static int a = 5;
- int b = 7;
- printf ("foo(): " "a = %d, b = %d\n", a, b);
- a++;
-}
-
-int main (void)
-{
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
- b = 12;
- a = b;
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- return 0;
- printf ("main(): " "a = %d, b = %d\n", a, b);
-}
diff --git a/20221010/functions-15.c b/20221010/functions-15.c
deleted file mode 100644
index 6b60de937312f89db3402a5a744ac810a5b8590d..0000000000000000000000000000000000000000
--- a/20221010/functions-15.c
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <stdio.h>
-
-int a = 0;
-int b = 3;
-
-void foo (void)
-{
- b++;
- int a = 5;
- int b = 7;
- printf ("foo(): " "a = %d, b = %d\n", a, b);
- a++;
-}
-
-int main (void)
-{
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
- b = 12;
- a = b;
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- return 0;
- printf ("main(): " "a = %d, b = %d\n", a, b);
-}
diff --git a/20221010/functions-16.c b/20221010/functions-16.c
deleted file mode 100644
index ffa82861602224ce227bfbbbc802dea3a8f20fab..0000000000000000000000000000000000000000
--- a/20221010/functions-16.c
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <stdio.h>
-
-int a = 0;
-int b = 3;
-
-void foo (void)
-{
- b++;
- static int a = 5;
- int b = 7;
- printf ("foo(): " "a = %d, b = %d\n", a, b);
- a++;
-}
-
-int main (void)
-{
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
- b = 12;
- a = b;
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
- return 0;
-}
diff --git a/20221010/functions-17.c b/20221010/functions-17.c
deleted file mode 100644
index a123a3acade411d6a0f01879de3a10e1b537aa12..0000000000000000000000000000000000000000
--- a/20221010/functions-17.c
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <stdio.h>
-
-int a = 0;
-int b = 3;
-
-void foo (void)
-{
- b++;
- static int a = 5;
- static int b = 7;
- printf ("foo(): " "a = %d, b = %d\n", a, b);
- a++;
-}
-
-int main (void)
-{
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
- b = 12;
- a = b;
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
- return 0;
-}
diff --git a/20221010/functions-18.c b/20221010/functions-18.c
deleted file mode 100644
index 4b1034683b7129fdc619c1b67b037fa8cbad8357..0000000000000000000000000000000000000000
--- a/20221010/functions-18.c
+++ /dev/null
@@ -1,27 +0,0 @@
-#include <stdio.h>
-
-int a = 0;
-int b = 3;
-
-void foo (void)
-{
- b++;
- static int a = 5;
- static int b = 7;
- printf ("foo(): " "a = %d, b = %d\n", a, b);
- a++;
- b++;
-}
-
-int main (void)
-{
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
- b = 12;
- a = b;
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
- return 0;
-}
diff --git a/20221010/functions-19.c b/20221010/functions-19.c
deleted file mode 100644
index 37610ed19254f2086900a71d5ac8cbf69a5c37c4..0000000000000000000000000000000000000000
--- a/20221010/functions-19.c
+++ /dev/null
@@ -1,27 +0,0 @@
-#include <stdio.h>
-
-int a = 0;
-int b = 3;
-
-void foo (void)
-{
- b++;
- static int a = 5;
- int b = 7;
- printf ("foo(): " "a = %d, b = %d\n", a, b);
- a++;
- b++;
-}
-
-int main (void)
-{
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
- b = 12;
- a = b;
- printf ("main(): " "a = %d, b = %d\n", a, b);
- foo ();
- printf ("main(): " "a = %d, b = %d\n", a, b);
- return 0;
-}
diff --git a/20221010/gitlab.png b/20221010/gitlab.png
deleted file mode 100644
index 5724da8b8338534857e5e845f1f1a9b67f0fab1a..0000000000000000000000000000000000000000
Binary files a/20221010/gitlab.png and /dev/null differ
diff --git a/20221010/hp-20221010-fig1.pdf b/20221010/hp-20221010-fig1.pdf
deleted file mode 100644
index 2e878f1026f04f8363df3339f30f5cb936734baf..0000000000000000000000000000000000000000
Binary files a/20221010/hp-20221010-fig1.pdf and /dev/null differ
diff --git a/20221010/hp-20221010-fig1.tex b/20221010/hp-20221010-fig1.tex
deleted file mode 100644
index 9993254ede0128398967c2a56ca2898533e2b861..0000000000000000000000000000000000000000
--- a/20221010/hp-20221010-fig1.tex
+++ /dev/null
@@ -1,60 +0,0 @@
-\documentclass{article}
-\input tmp.inputs
-\pagestyle{empty}
-\begin{document}
- \psscalebox{0.79}{%
- \begin{pspicture}(-5,0)(12,12)
- \small
- \psset{unit=0.5cm}
- \psline[arrows=<->](-1,0)(-1,22)
- \rput(-1.3,0){\makebox(0,0)[br]{\textbf{gegenständlich}}}
- \rput(-1.3,22){\makebox(0,0)[tr]{\textbf{abstrakt}}}
- \rput(-1.3,2){\makebox(0,0)[r]{Elektromagnetismus, Halbleiter}}
- \rput(-1.3,4){\makebox(0,0)[r]{Elektronische Bauelemente}}
- \rput(-1.3,6){\makebox(0,0)[r]{Logik-Schaltkreise}}
- \rput(-1.3,8){\makebox(0,0)[r]{Prozessoren}}
- \rput(-1.3,9){\makebox(0,0)[r]{Maschinensprache}}
- \rput(-1.3,10){\makebox(0,0)[r]{Assembler}}
- \rput(-1.3,11){\makebox(0,0)[r]{Ein-/Ausgabe}}
- \rput(-1.3,12.35){\makebox(0,0)[r]{\textbf{hardwarenahe Programmierung} (z.\,B.\ in C)}}
- \rput(-1.3,14){\makebox(0,0)[r]{\shortstack[r]{abstrahierende Programmierung\\(z.\,B.\ in C++, Java)}}}
-% \rput(-1.3,15){\makebox(0,0)[r]{Programmierung}}
- \rput(-1.3,16){\makebox(0,0)[r]{Algorithmen, Datenstrukturen, Software-Entwurf}}
- \rput(-1.3,17){\makebox(0,0)[r]{Requirements Engineering}}
- \rput(-1.3,18){\makebox(0,0)[r]{formale Sprachen, Berechenbarkeit}}
- \rput(-1.3,19){\makebox(0,0)[r]{mathematische Strukturen}}
- \rput(-1.3,20){\makebox(0,0)[r]{mathematische Beweise}}
- \rput(2.1,0.5){\makebox(0,0)[l]{Physik}}
- \rput(4.1,4){\makebox(0,0)[l]{Elektrotechnik}}
- \rput(6.1,8){\makebox(0,0)[l]{Rechnertechnik}}
- \rput(8.1,12.35){\makebox(0,0)[l]{angewandte Informatik}}
- \rput(10.1,16){\makebox(0,0)[l]{\shortstack[l]{Softwaretechnik und\\theoretische Informatik}}}
- \rput(12.1,21){\makebox(0,0)[l]{Mathematik}}
- \psset{linewidth=0.001,linestyle=none,fillstyle=gradient,gradmidpoint=1.0,gradlines=1000}
- \definecolor{RGBwhite}{rgb}{1.0,1.0,1.0}
- \definecolor{RGBblue}{rgb}{0.0,0.0,1.0}
- \definecolor{RGBred}{rgb}{1.0,0.0,0.0}
- \definecolor{RGBgreen}{rgb}{0.0,1.0,0.0}
- \definecolor{RGByellow}{rgb}{1.0,1.0,0.0}
- \definecolor{RGBorange}{rgb}{1.0,0.7,0.0}
- \definecolor{RGBgrey}{rgb}{0.7,0.7,0.7}
- \rput(0,2){\psframe[gradbegin=RGBwhite,gradend=RGBblue](2,2)}
- \rput(0,0){\psframe[fillstyle=solid,fillcolor=RGBblue](2,2.01)}
- \rput(2,6){\psframe[gradbegin=RGBwhite,gradend=RGBred](2,2)}
- \rput(2,2){\psframe[gradbegin=RGBred,gradend=RGBwhite](2,2)}
- \rput(2,3.99){\psframe[fillstyle=solid,fillcolor=RGBred](2,2.02)}
- \rput(4,10){\psframe[gradbegin=RGBwhite,gradend=RGBgreen](2,2)}
- \rput(4,6){\psframe[gradbegin=RGBgreen,gradend=RGBwhite](2,2)}
- \rput(4,7.99){\psframe[fillstyle=solid,fillcolor=RGBgreen](2,2.02)}
- \rput(6,14){\psframe[gradbegin=RGBwhite,gradend=RGByellow](2,2)}
- \rput(6,10){\psframe[gradbegin=RGByellow,gradend=RGBwhite](2,2)}
- \rput(6,11.99){\psframe[fillstyle=solid,fillcolor=RGByellow](2,2.02)}
- \rput(8,18){\psframe[gradbegin=RGBwhite,gradend=RGBorange](2,2)}
- \rput(8,14){\psframe[gradbegin=RGBorange,gradend=RGBwhite](2,2)}
- \rput(8,15.99){\psframe[fillstyle=solid,fillcolor=RGBorange](2,2.02)}
- \rput(10,18){\psframe[gradbegin=RGBgrey,gradend=RGBwhite](2,2)}
- \rput(10,19.99){\psframe[fillstyle=solid,fillcolor=RGBgrey](2,2.01)}
- \end{pspicture}
- }
-
-\end{document}
diff --git a/20221010/hp-20221010.pdf b/20221010/hp-20221010.pdf
deleted file mode 100644
index bf79bfec030b97fe2b8e3e320c272701ac0b3d0a..0000000000000000000000000000000000000000
Binary files a/20221010/hp-20221010.pdf and /dev/null differ
diff --git a/20221010/hp-20221010.tex b/20221010/hp-20221010.tex
deleted file mode 100644
index 313aa41741cee49dcc6bf002baedd6e321d18497..0000000000000000000000000000000000000000
--- a/20221010/hp-20221010.tex
+++ /dev/null
@@ -1,1582 +0,0 @@
-% hp-20221010.pdf - Lecture Slides on Low-Level Programming
-% Copyright (C) 2012, 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Funktionen, Zeiger, Arrays und Strings
-
-\documentclass[10pt,t]{beamer}
-
-\usepackage{pgslides}
-\usepackage{pdftricks}
-\usepackage{tikz}
-
-\begin{psinputs}
- \usepackage[utf8]{inputenc}
- \usepackage[german]{babel}
- \usepackage[T1]{fontenc}
- \usepackage{helvet}
- \renewcommand*\familydefault{\sfdefault}
- \usepackage{pstricks,pst-grad}
-\end{psinputs}
-
-\newcommand{\redurl}[1]{\href{#1}{\color{red}\nolinkurl{#1}}}
-
-\title{Hardwarenahe Programmierung}
-\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
-\date{10.\ Oktober 2022}
-
-\begin{document}
-
-\maketitleframe
-
-\sectionnonumber{Vorab: Online-Werkzeuge}
-
-\begin{frame}
-
- \showsectionnonumber
- \begin{itemize}
- \item
- Diese Veranstaltung findet \textbf{in Präsenz} statt.\\
- Wir versuchen aber, auch eine Online-Teilnahme zu ermöglichen.
- \medskip
- \item
- \textbf{Mumble}: Seminarraum 2\\
- Fragen: Mikrofon einschalten oder über den Chat\\
- Umfragen: über den Chat -- \textbf{auch während der Präsenz-Veranstaltung}
- \smallskip
- \item
- \textbf{VNC}: Kanal 6, Passwort: \lstinline[style=cmd]{testcvh}\\
- Eigenen Bildschirm freigeben: VNC-Software oder Web-Interface \emph{yesVNC}\\
- Eigenes Kamerabild übertragen: Web-Interface \emph{CVH-Camera}
- \smallskip
- \item
- Allgemeine Informationen:
- \url{https://www.cvh-server.de/online-werkzeuge/}
- \smallskip
- \item
- Notfall-Schnellzugang: \url{https://www.cvh-server.de/virtuelle-raeume/}\\
- Seminarraum 2, VNC-Passwort: \lstinline[style=cmd]{testcvh}
- \smallskip
- \item
- Bei Problemen: bitte notieren:\\
- Art des Problems, genaue Uhrzeit, eigener Internet-Zugang
- \bigskip
- \item
- GitLab: \url{https://gitlab.cvh-server.de/pgerwinski/hp}
- \end{itemize}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \vspace{-0.6cm}
- \begin{pdfpic}
- \psscalebox{0.79}{%
- \begin{pspicture}(-5,0)(12,12)
- \small
- \psset{unit=0.5cm}
- \psline[arrows=<->](-1,0)(-1,22)
- \rput(-1.3,0){\makebox(0,0)[br]{\textbf{gegenständlich}}}
- \rput(-1.3,22){\makebox(0,0)[tr]{\textbf{abstrakt}}}
- \rput(-1.3,2){\makebox(0,0)[r]{Elektromagnetismus, Halbleiter}}
- \rput(-1.3,4){\makebox(0,0)[r]{Elektronische Bauelemente}}
- \rput(-1.3,6){\makebox(0,0)[r]{Logik-Schaltkreise}}
- \rput(-1.3,8){\makebox(0,0)[r]{Prozessoren}}
- \rput(-1.3,9){\makebox(0,0)[r]{Maschinensprache}}
- \rput(-1.3,10){\makebox(0,0)[r]{Assembler}}
- \rput(-1.3,11){\makebox(0,0)[r]{Ein-/Ausgabe}}
- \rput(-1.3,12.35){\makebox(0,0)[r]{\textbf{hardwarenahe Programmierung} (z.\,B.\ in C)}}
- \rput(-1.3,14){\makebox(0,0)[r]{\shortstack[r]{abstrahierende Programmierung\\(z.\,B.\ in C++, Java)}}}
-% \rput(-1.3,15){\makebox(0,0)[r]{Programmierung}}
- \rput(-1.3,16){\makebox(0,0)[r]{Algorithmen, Datenstrukturen, Software-Entwurf}}
- \rput(-1.3,17){\makebox(0,0)[r]{Requirements Engineering}}
- \rput(-1.3,18){\makebox(0,0)[r]{formale Sprachen, Berechenbarkeit}}
- \rput(-1.3,19){\makebox(0,0)[r]{mathematische Strukturen}}
- \rput(-1.3,20){\makebox(0,0)[r]{mathematische Beweise}}
- \rput(2.1,0.5){\makebox(0,0)[l]{Physik}}
- \rput(4.1,4){\makebox(0,0)[l]{Elektrotechnik}}
- \rput(6.1,8){\makebox(0,0)[l]{Rechnertechnik}}
- \rput(8.1,12.35){\makebox(0,0)[l]{angewandte Informatik}}
- \rput(10.1,16){\makebox(0,0)[l]{\shortstack[l]{Softwaretechnik und\\theoretische Informatik}}}
- \rput(12.1,21){\makebox(0,0)[l]{Mathematik}}
- \psset{linewidth=0.001,linestyle=none,fillstyle=gradient,gradmidpoint=1.0,gradlines=1000}
- \definecolor{RGBwhite}{rgb}{1.0,1.0,1.0}
- \definecolor{RGBblue}{rgb}{0.0,0.0,1.0}
- \definecolor{RGBred}{rgb}{1.0,0.0,0.0}
- \definecolor{RGBgreen}{rgb}{0.0,1.0,0.0}
- \definecolor{RGByellow}{rgb}{1.0,1.0,0.0}
- \definecolor{RGBorange}{rgb}{1.0,0.7,0.0}
- \definecolor{RGBgrey}{rgb}{0.7,0.7,0.7}
- \rput(0,2){\psframe[gradbegin=RGBwhite,gradend=RGBblue](2,2)}
- \rput(0,0){\psframe[fillstyle=solid,fillcolor=RGBblue](2,2.01)}
- \rput(2,6){\psframe[gradbegin=RGBwhite,gradend=RGBred](2,2)}
- \rput(2,2){\psframe[gradbegin=RGBred,gradend=RGBwhite](2,2)}
- \rput(2,3.99){\psframe[fillstyle=solid,fillcolor=RGBred](2,2.02)}
- \rput(4,10){\psframe[gradbegin=RGBwhite,gradend=RGBgreen](2,2)}
- \rput(4,6){\psframe[gradbegin=RGBgreen,gradend=RGBwhite](2,2)}
- \rput(4,7.99){\psframe[fillstyle=solid,fillcolor=RGBgreen](2,2.02)}
- \rput(6,14){\psframe[gradbegin=RGBwhite,gradend=RGByellow](2,2)}
- \rput(6,10){\psframe[gradbegin=RGByellow,gradend=RGBwhite](2,2)}
- \rput(6,11.99){\psframe[fillstyle=solid,fillcolor=RGByellow](2,2.02)}
- \rput(8,18){\psframe[gradbegin=RGBwhite,gradend=RGBorange](2,2)}
- \rput(8,14){\psframe[gradbegin=RGBorange,gradend=RGBwhite](2,2)}
- \rput(8,15.99){\psframe[fillstyle=solid,fillcolor=RGBorange](2,2.02)}
- \rput(10,18){\psframe[gradbegin=RGBgrey,gradend=RGBwhite](2,2)}
- \rput(10,19.99){\psframe[fillstyle=solid,fillcolor=RGBgrey](2,2.01)}
- \end{pspicture}
- }
- \end{pdfpic}
-
-\end{frame}
-
-\sectionnonumber{Hardwarenahe Programmierung}
-\subsectionnonumber{Programmierung in C}
-
-\begin{frame}
-
- \showsectionnonumber
-
- Man kann Computer vollständig beherrschen.
-
-% \begin{onlyenv}<1>
-%
-% \vspace*{2cm}
-%
-% {\Large\color{structure}\textbf{Rechnertechnik}}
-%
-% \bigskip
-%
-% Man kann vollständig verstehen, wie Computer funktionieren.
-%
-% \vspace*{-3cm}
-%
-% \end{onlyenv}
-
-% \pause
-
- \bigskip
- \bigskip
-
- \showsubsectionnonumber
-
- \vspace{-\medskipamount}
-
- \begin{itemize}
-% \item
-% kleinster gemeinsamer Nenner für viele Plattformen\\
-% \pause
-% \begin{picture}(0,1)
-% \color{red}
-% \put(7.2,0.6){\vector(0,1){0.4}}
-% \put(7.2,0.5){\makebox(0,0)[t]{\color{black}Hardware und/oder Betriebssystem}}
-% \end{picture}
-% \pause
-% \medskip
- \item
- Hardware direkt ansprechen und effizient einsetzen
- \medskip
- \item
- \dots\ bis hin zu komplexen Software-Projekten
- \medskip
- \item
- Programmierkenntnisse werden nicht vorausgesetzt,\\
- aber schnelles Tempo
- \end{itemize}
-
-\end{frame}
-
-\iffalse
-
-\subsectionnonumber{Programmierung in C und C++}
-
-\begin{frame}
-
- \showsectionnonumber
-
- Man kann Computer vollständig beherrschen.
-
- \bigskip
-
- \showsubsectionnonumber
-
- Etabliertes Profi-Werkzeug
- \begin{itemize}
- \item
- kleinster gemeinsamer Nenner für viele Plattformen\\
- \begin{picture}(0,1)
- \color{red}
- \put(7.2,0.6){\vector(0,1){0.4}}
- \put(7.2,0.5){\makebox(0,0)[t]{\color{black}Hardware und/oder Betriebssystem}}
- \end{picture}
- \medskip
- \item
- Programmierkenntnisse werden nicht vorausgesetzt,\\
- aber schnelles Tempo
- \bigskip
- \item
- Hardware direkt ansprechen und effizient einsetzen
- \bigskip
- \item
- \dots\ bis hin zu komplexen Software-Projekten
- \end{itemize}
-
-\end{frame}
-
-\fi
-
-\subsectionnonumber{Was ist C?}
-
-\begin{frame}
-
- \showsectionnonumber
- \showsubsectionnonumber
-
- Etabliertes Profi-Werkzeug
- \begin{itemize}
- \item
- kleinster gemeinsamer Nenner für viele Plattformen
-% \pause
- \begin{picture}(0,0)
- \color{red}
- \put(-1.0,-0.8){\vector(0,1){0.7}}
- \put(-1.0,-0.9){\makebox(0,0)[t]{\color{black}Hardware und/oder Betriebssystem}}
- \end{picture}
-% \pause
- \item
- leistungsfähig, aber gefährlich
- \end{itemize}
-
-% \pause
- \medskip
- "`High-Level-Assembler"'
- \begin{itemize}
-% \pause
- \item
- kein "`Fallschirm"'
-% \pause
- \item
- kompakte Schreibweise
- \end{itemize}
-
-% \pause
- \medskip
- Unix-Hintergrund
- \begin{itemize}
-% \pause
- \item
- Baukastenprinzip
-% \pause
- \item
- konsequente Regeln
-% \pause
- \item
- kein "`Fallschirm"'
- \end{itemize}
-
-\end{frame}
-
-\sectionnonumber{Zu dieser Lehrveranstaltung}
-
-\begin{frame}
-
- \showsectionnonumber
-
- \begin{itemize}
- \item
- \textbf{Lehrmaterialien:}%
- \hfill\makebox(0,0)[r]{\includegraphics[width=3.5cm]{gitlab.png}}\\
- \url{https://gitlab.cvh-server.de/pgerwinski/hp}
- \item
- \textbf{Klausur:}
-
- Zeit: 150 Minuten
-
- Zulässige Hilfsmittel:
- \begin{itemize}
- \item Schreibgerät
- \item beliebige Unterlagen in Papierform und/oder auf Datenträgern
- \item elektronische Rechner (Notebook, Taschenrechner o.\,ä.)
- \item \emph{kein\/} Internet-Zugang
- \end{itemize}
- \item
- \textbf{Übungen}\\
- sind mit der Vorlesung integriert.
- \item
- Das \textbf{Praktikum}\\
- findet jede Woche statt.\\
- Diese Woche: vorbereitende Maßnahmen,\\
- Kennenlernen der verwendeten Werkzeuge
- \end{itemize}
-
-\end{frame}
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \begin{itemize}
- \color{medgreen}
- \item[1.1] Was ist hardwarenahe Programmierung?
- \item[1.2] Programmierung in C
- \item[1.3] Zu dieser Lehrveranstaltung
- \end{itemize}
- \item[\textbf{2}] \textbf{Einführung in C}
- \begin{itemize}
- \color{medgreen}
- \item[2.1] Hello, world!
- \item[2.2] Programme compilieren und ausführen
- \item[2.3] Elementare Aus- und Eingabe
- \item[2.4] Elementares Rechnen
- \item[2.5] Verzweigungen
- \item[2.6] Schleifen
- \item[2.7] Strukturierte Programmierung
- \item[2.8] Seiteneffekte
- \color{red}
- \item[2.9] Funktionen
- \item[\dots]
-% \item[2.10] Zeiger
-% \item[2.11] Arrays und Strings
-% \item[2.12] Strukturen
-% \item[\dots]
- \end{itemize}
- \color{gray}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \vspace*{-\smallskipamount}
- \item[\textbf{\dots}]
-% \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
-% \item[\textbf{5}] \textbf{Algorithmen}
-% \item[\textbf{6}] \textbf{Ergänzungen und Ausblicke}
- \end{itemize}
-
-\end{frame}
-
-\section{Einführung}
-\section{Einführung in C}
-\subsection{Hello, world!}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- Text ausgeben
-
- \bigskip
-
- \begin{lstlisting}
- #include <stdio.h>
-
- int main (void)
- {
- printf ("Hello, world!\n");
- return 0;
- }
- \end{lstlisting}
-% \pause
- \begin{picture}(0,0)
- \color{red}
- \put(5.0,1.5){\makebox(0,0)[bl]{printf = "`print formatted"'}}
-% \pause
- \put(4.0,0.4){\makebox(0,0)[br]{\tikz{\draw[-latex](0.0,0.0)--(-0.3,0.7);}}}
- \put(4.0,0.3){\makebox(0,0)[t]{\textbackslash n: Zeilenschaltung}}
- \end{picture}
-
-\end{frame}
-
-\subsection{Programme compilieren und ausführen}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{onlyenv}<1-3>
- \begin{lstlisting}[style=terminal,gobble=6]
- $ ¡gcc hello-1.c -o hello-1¿
- $ ¡./hello-1¿
- Hello, world!
- $
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<4->
- \begin{lstlisting}[style=terminal,gobble=6]
- $ ¡gcc -Wall -O hello-1.c -o hello-1¿
- $ ¡./hello-1¿
- Hello, world!
- $
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<2>
- \bigskip
- Hier: Kommandozeilen-Interface (CLI)
- \begin{itemize}
- \item
- Der C-Compiler (hier: \lstinline[style=cmd]{gcc})
- muß installiert sein und sich im \lstinline[style=terminal]{PATH} befinden.
- \item
- Der Quelltext (hier: \file{hello-1.c})
- muß sich im aktuellen Verzeichnis befinden.
- \item
- aktuelles Verzeichnis herausfinden: \lstinline[style=cmd]{pwd}
- \item
- aktuelles Verzeichnis wechseln: \lstinline[style=cmd]{cd foobar}, \lstinline[style=cmd]{cd ..}
- \item
- Inhalt des aktuellen Verzeichnisses ausgeben: \lstinline[style=cmd]{ls}, \lstinline[style=cmd]{ls -l}
- \item
- Ausführen des Programms (\file{hello-1}) im aktuellen Verzeichnis (\file{.}):\\
- \lstinline[style=cmd]{./hello-1}
- \end{itemize}
-
- Alternative: Integrierte Entwicklungsumgebung (IDE)\\
- mit graphischer Benutzeroberfläche (GUI)
- \begin{itemize}
- \item
- Das können Sie bereits.
- \end{itemize}
- \vspace*{-1cm}
- \end{onlyenv}
- \begin{onlyenv}<3>
- \bigskip
- GNU Compiler Collection (GCC) für verschiedene Plattformen:
- \begin{itemize}
- \item
- GNU/Linux: \file{gcc}
- \item
- Apple Mac OS: \file{Xcode}
- \item
- Microsoft Windows: \file{Cygwin}\\
- oder \file{MinGW} mit \file{MSYS}\\
- oder \file{WSL} mit darin installiertem \file{GNU/Linux}
- \medskip
- \item
- außerdem: Texteditor\\
- \file{vi}(\file{m}), \file{nano},
- \file{Emacs}, \file{Notepad++}, \dots\\
- (Microsoft Notepad ist \emph{nicht} geeignet!)
- \end{itemize}
- \end{onlyenv}
- \begin{onlyenv}<1>
- \begin{picture}(0,0)
- \color{red}
- \put(4.0,0.5){\tikz{\draw[-latex](0.0,0.0)--(-2.0,1.0);}}
- \put(4.0,0.3){\makebox(0,0)[tl]{\begin{minipage}[t]{8cm}
- \begin{tabular}{ll}
- \lstinline[style=cmd]{-o hello-1}
- & Name für Ausgabe-Datei ("`output"') \\
- & unter Unix: ohne Endung \\
- & unter MS-Windows: Endung \lstinline[style=cmd]{.exe}
- \end{tabular}
- \end{minipage}}}
- \end{picture}
- \end{onlyenv}
- \begin{onlyenv}<4->
- \begin{picture}(0,0)
- \color{red}
- \put(3.0,0.5){\tikz{\draw[-latex](0.0,0.0)--(-3.0,1.0);}}
- \put(4.0,0.3){\makebox(0,0)[tl]{\begin{minipage}[t]{6cm}
- \begin{tabular}{ll}
- \lstinline[style=cmd]{-Wall} & alle Warnungen einschalten\\
- \lstinline[style=cmd]{-O} & optimieren\\
- \lstinline[style=cmd]{-O3} & maximal optimieren\\
- \lstinline[style=cmd]{-Os} & Codegröße optimieren\\[\smallskipamount]
- \dots & gcc hat \emph{sehr viele\/} Optionen.
- \end{tabular}
- \end{minipage}}}
- \end{picture}
- \end{onlyenv}
-
-\end{frame}
-
-\subsection{Elementare Aus- und Eingabe}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Wert ausgeben
-
- \bigskip
-
- \begin{lstlisting}
- #include <stdio.h>
-
- int main (void)
- {
- printf ("Die Antwort lautet: ");
- printf (42);
- printf ("\n");
- return 0;
- }
- \end{lstlisting}
-% \pause
- \medskip
- \textarrow\ Absturz
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Wert ausgeben
-
- \bigskip
-
- \begin{lstlisting}
- #include <stdio.h>
-
- int main (void)
- {
- printf ("Die Antwort lautet: %d\n", 42);
- return 0;
- }
- \end{lstlisting}
- \begin{picture}(0,0)
- \color{red}
- \put(5.3,0.65){\tikz{\draw[-latex](0.0,0.0)--(-0.5,0.5);}}
- \put(5.9,0.35){\begin{minipage}[t]{6.5cm}
- Formatspezifikation "`d"': "`dezimal"'%\pause
- \\[\smallskipamount]
- Weitere Formatspezifikationen:\\
- siehe Dokumentation (z.\,B.\ man 3 printf),\\
- Internet-Recherche oder Literatur
- \end{minipage}}
- \end{picture}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Wert einlesen
-
- \bigskip
-
- \begin{lstlisting}
- #include <stdio.h>
-
- int main (void)
- {
- double a;
- printf ("Bitte eine Zahl eingeben: ");
- scanf ("%lf", &a);
- printf ("Ihre Antwort war: %lf\n", a);
- return 0;
- }
- \end{lstlisting}
- \begin{picture}(0,0)
- \color{red}
- \put(3.4,1.8){\tikz{\draw[-latex](0.0,0.0)--(-3.5,0);}}
- \put(7.0,1.9){\begin{minipage}[t]{5cm}
- Formatspezifikation "`lf"':\\
- "`long floating-point"'\\[\smallskipamount]
- Das "`\&"' nicht vergessen!
- \end{minipage}}
- \end{picture}
-
-\end{frame}
-
-\subsection{Elementares Rechnen}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Wert an Variable zuweisen
-
- \bigskip
-
- \begin{lstlisting}
- #include <stdio.h>
-
- int main (void)
- {
- int a;
- printf ("Bitte eine Zahl eingeben: ");
- scanf ("%d", &a);
- a = 2 * a;
- printf ("Das Doppelte ist: %d\n", a);
- return 0;
- }
- \end{lstlisting}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Variable bei Deklaration initialisieren
-
- \bigskip
-
- \begin{lstlisting}
- int a = 42;
- a = 137;
- \end{lstlisting}
-
- \bigskip
-
- \textbf{Achtung:} Initialisierung $\ne$ Zuweisung
-
- \smallskip
-
- Die beiden Gleichzeitszeichen haben\\
- \emph{subtil unterschiedliche\/} Bedeutungen!
-
-\end{frame}
-
-\subsection{Verzweigungen}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{minipage}[t]{6cm}
- \lstinline{if}-Verzweigung
-
- \bigskip
-
- \begin{lstlisting}[gobble=6]
- if (b != 0)
- printf ("%d\n", a / b);
- \end{lstlisting}
- \end{minipage}%\pause
- \begin{minipage}[t]{6cm}
- \textbf{Wahrheitswerte} in C: \textbf{numerisch}\\[\medskipamount]
- 0 steht für \emph{falsch (false)},\\
- $\ne 0$ steht für \emph{wahr (true)}.
-
- \bigskip
-
- \begin{lstlisting}[gobble=6]
- if (b)
- printf ("%d\n", a / b);
- \end{lstlisting}
- \end{minipage}
-
-\end{frame}
-
-\subsection{Schleifen}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{minipage}[t]{6cm}
- \lstinline{while}-Schleife
- \bigskip
- \begin{lstlisting}[gobble=6]
- a = 1;
- while (a <= 10)
- {
- printf ("%d\n", a);
- a = a + 1;
- }
- \end{lstlisting}
- \end{minipage}%\pause
- \begin{minipage}[t]{6cm}
- \lstinline{for}-Schleife
- \bigskip
- \begin{lstlisting}[gobble=6]
- for (a = 1; a <= 10; a = a + 1)
- printf ("%d\n", a);
- \end{lstlisting}
- \vspace{1.5cm}
-% \pause
- \lstinline{do}-\lstinline{while}-Schleife
- \bigskip
- \begin{lstlisting}[gobble=6]
- a = 1;
- do
- {
- printf ("%d\n", a);
- a = a + 1;
- }
- while (a <= 10);
- \end{lstlisting}
- \end{minipage}
-
-\end{frame}
-
-\subsection{Strukturierte Programmierung}
-
-\begin{frame}[fragile]
-
- \visible<1->{\showsubsection}
-
- \begin{minipage}[t]{6cm}
- \begin{onlyenv}<1->
- \begin{lstlisting}[gobble=8]
- ¡i = 0;
- while (1)
- {
- if (i >= 10)
- break;
- printf ("%d\n", i++);
- }¿
- \end{lstlisting}
- \end{onlyenv}
- \strut
- \bigskip
- \begin{onlyenv}<1->
- \begin{lstlisting}[gobble=8]
- ¡i = 0;
- loop:
- if (i >= 10)
- goto endloop;
- printf ("%d\n", i++);
- goto loop;
- endloop:¿
- \end{lstlisting}
- \end{onlyenv}
- \end{minipage}
- \begin{minipage}[t]{6cm}
- \vspace{-\bigskipamount}
- \begin{lstlisting}
- ¡int i;
- \end{lstlisting}
- \bigskip
- \begin{lstlisting}
- ¡i = 0;
- while (i < 10)
- {
- printf ("%d\n", i);
- i++;
- }¿
- \end{lstlisting}
- \bigskip
- \begin{lstlisting}
- ¡for (i = 0; i < 10; i++)
- printf ("%d\n", i);¿
- \end{lstlisting}
- \bigskip
- \begin{lstlisting}
- ¡i = 0;
- while (i < 10)
- printf ("%d\n", i++);¿
- \end{lstlisting}
- \bigskip
- \begin{lstlisting}
- ¡for (i = 0; i < 10; printf ("%d\n", i++));¿
- \end{lstlisting}
- \end{minipage}%
- \begin{onlyenv}<1->
- \begin{picture}(0,0)
- \put(-1.9,-3.0){\mbox{\color{medgreen}gut}}
- \put(-1.9,-5.2){\begin{minipage}{5cm}
- \color{orange}
- nur, wenn\\
- Sie wissen,\\
- was Sie tun
- \end{minipage}}
-
- \put(-10,-0.5){\mbox{\color{red}fragwürdig}}
- \put(-9.3,-4.2){\begin{minipage}[t]{5cm}
- \color{red}
- sehr fragwürdig\\[\smallskipamount]
- \footnotesize(siehe z.\,B.:\\
- http://xkcd.com/292/)
- \end{minipage}}
- \end{picture}
- \end{onlyenv}
- \vspace*{-1cm}
-
-\end{frame}
-
-\subsection{Seiteneffekte}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{lstlisting}
- #include <stdio.h>
-
- int main (void)
- {
- printf ("Hello, world!\n");
- "Hello, world!\n";
- return 0;
- }
- \end{lstlisting}
-% \pause
- \begin{picture}(0,0)
- \color{red}
- \put(3.1,1.35){\tikz{\draw[-latex](0.0,0.0)--(-0.8,0);}}
- \put(4.0,1.35){\makebox(0,0)[l]{Ausdruck als Anweisung: Wert wird ignoriert}}
- \pause
- \put(3.55,1.40){\tikz{\draw[-latex](0.0,0.0)--(-0.4,0.2);}}
- \end{picture}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{lstlisting}
- #include <stdio.h>
-
- int main (void)
- {
- int a = printf ("Hello, world!\n");
- printf ("%d\n", a);
- return 0;
- }
- \end{lstlisting}
-% \pause
- \bigskip
- \begin{lstlisting}[style=terminal]
- $ ¡gcc -Wall -O side-effects-1.c -o side-effects-1¿
- $ ¡./side-effects-1¿
- Hello, world!
- 14
- $
- \end{lstlisting}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{lstlisting}
- #include <stdio.h>
-
- int main (void)
- {
- int a = printf ("Hello, world!\n");
- printf ("%d\n", a);
- return 0;
- }
- \end{lstlisting}
- \begin{itemize}
- \item
- \lstinline{printf()} ist eine Funktion.
-% \pause
- \item
- "`Haupteffekt"': Wert zurückliefern\\
- (hier: Anzahl der ausgegebenen Zeichen)
-% \pause
- \item
- \newterm{Seiteneffekt\/}: Ausgabe
- \end{itemize}
-
-\end{frame}
-
-\addtocounter{subsection}{-1}
-\subsection{Seiteneffekte \protect\color{gray}bei Operatoren}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{minipage}[t]{6cm}
- Unäre Operatoren:
- \begin{itemize}
- \item
- Negation: \lstinline{-foo}
- \item
- {\only<1->{\color{red}}Funktionsaufruf}: \lstinline{foo ()}
- \item
- {\only<1->{\color{red}}Post-Inkrement}: \lstinline{foo++}
- \item
- {\only<1->{\color{red}}Post-Dekrement}: \lstinline{foo--}
- \item
- {\only<1->{\color{red}}Prä-Inkrement}: \lstinline{++foo}
- \item
- {\only<1->{\color{red}}Prä-Dekrement}: \lstinline{--foo}
- \end{itemize}
- \medskip
- Binäre Operatoren:
- \begin{itemize}
- \item
- Rechnen: \lstinline{+ - * / %}
- \item
- Vergleich: \lstinline{== != < > <= >=}
- \item
- {\only<1->{\color{red}}Zuweisung}: \lstinline{= += -= *= /= %=}
- \item
- Ignorieren: \lstinline{,}\quad \lstinline{a, b}: berechne \lstinline{a}, ignoriere es, nimm stattdessen \lstinline{b}
- \end{itemize}
-% \pause
- \medskip
- {\color{red}rot = mit Seiteneffekt}
- \end{minipage}
-% \pause
- \begin{minipage}[t]{6cm}
- \vspace{-\bigskipamount}
- \begin{lstlisting}
- ¡int i;¿
- \end{lstlisting}
- \bigskip
- \begin{lstlisting}
- ¡i = 0;
- while (i < 10)
- {
- printf ("%d\n", i);
- i++;
- }¿
- \end{lstlisting}
- \bigskip
-% \pause
- \begin{lstlisting}
- ¡for (i = 0; i < 10; i++)
- printf ("%d\n", i);¿
- \end{lstlisting}
- \bigskip
-% \pause
- \begin{lstlisting}
- ¡i = 0;
- while (i < 10)
- printf ("%d\n", i++);¿
- \end{lstlisting}
- \bigskip
-% \pause
- \begin{lstlisting}
- ¡for (i = 0; i < 10; printf ("%d\n", i++));¿
- \end{lstlisting}
- \end{minipage}
- \vspace*{-1cm}
-
-\end{frame}
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \begin{itemize}
- \color{medgreen}
- \item[2.1] Hello, world!
- \item[2.2] Programme compilieren und ausführen
- \item[2.3] Elementare Aus- und Eingabe
- \item[2.4] Elementares Rechnen
- \item[2.5] Verzweigungen
- \item[2.6] Schleifen
- \item[2.7] Strukturierte Programmierung
- \item[2.8] Seiteneffekte
- \color{red}
- \item[2.9] Funktionen
- \item[2.10] Zeiger
- \item[2.11] Arrays und Strings
- \color{black}
- \item[2.12] Strukturen
- \item[\dots]
- \end{itemize}
- \color{gray}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \vspace*{-\smallskipamount}
- \item[\textbf{\dots}]
-% \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
-% \item[\textbf{5}] \textbf{Algorithmen}
-% \item[\textbf{6}] \textbf{Ergänzungen und Ausblicke}
- \end{itemize}
- \vspace*{-1cm}
-
-\end{frame}
-
-\subsection{Funktionen}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{minipage}[t]{6.5cm}
- \vspace{-\medskipamount}
- \begin{lstlisting}[gobble=6]
- ¡#include <stdio.h>
-
- int answer (void)
- {
- return 42;
- }
-
- void foo (void)
- {
- printf ("%d\n", answer ());
- }
-
- int main (void)
- {
- foo ();
- return 0;
- }¿
- \end{lstlisting}
- \vspace*{-1cm}
- \end{minipage}%
- \begin{minipage}[t]{6cm}
- \begin{itemize}
- \pause
- \item
- Funktionsdeklaration:\\[\smallskipamount]
- Typ Name ( Parameterliste )\\
- \{\\
- \quad Anweisungen\\
- \}
- \end{itemize}
- \end{minipage}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{minipage}[t]{6.5cm}
- \vspace{-\medskipamount}
- \begin{lstlisting}[gobble=6]
- ¡#include <stdio.h>
-
- void add_verbose (int a, int b)
- {
- printf ("%d + %d = %d\n", a, b, a + b);
- }
-
- int main (void)
- {
- add_verbose (3, 7);
- return 0;
- }¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{6cm}
- \begin{itemize}
- \item
- Funktionsdeklaration:\\[\smallskipamount]
- Typ Name ( Parameterliste )\\
- \{\\
- \quad Anweisungen\\
- \}
- \pause
- \bigskip
- \item
- Der Datentyp \lstinline{void}\\
- steht für "`nichts"'\\
- und \alt<3->{muß}{kann} ignoriert werden.
- \end{itemize}
- \end{minipage}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{minipage}{6cm}
- \begin{lstlisting}[gobble=6]
- ¡#include <stdio.h>
-
- int a, b = 3;
-
- void foo (void)
- {
- b++;
- static int a = 5;
- int b = 7;
- printf ("foo(): "
- "a = %d, b = %d\n",
- a, b);
- a++;
- }¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}{6cm}
- \vspace{-1cm}
- \begin{lstlisting}[gobble=6]
- ¡int main (void)
- {
- printf ("main(): "
- "a = %d, b = %d\n",
- a, b);
- foo ();
- printf ("main(): "
- "a = %d, b = %d\n",
- a, b);
- a = b = 12;
- printf ("main(): "
- "a = %d, b = %d\n",
- a, b);
- foo ();
- printf ("main(): "
- "a = %d, b = %d\n",
- a, b);
- return 0;
- }¿
- \end{lstlisting}
- \end{minipage}
-
-\end{frame}
-
-\subsection{Zeiger}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{lstlisting}
- #include <stdio.h>
-
- void calc_answer (int *a)
- {
- *a = 42;
- }
-
- int main (void)
- {
- int answer;
- calc_answer (&answer);
- printf ("The answer is %d.\n", answer);
- return 0;
- }
- \end{lstlisting}
-
- \pause
- \vspace{-5cm}\hspace{5cm}%
- \begin{minipage}{7cm}
- \begin{itemize}
- \item
- \lstinline{*a} ist eine \lstinline{int}.
- \pause
- \item
- unärer Operator \lstinline{*}:\\
- Pointer-Dererefenzierung
- \pause
- \arrowitem
- \lstinline{a} ist ein Zeiger (Pointer) auf eine \lstinline{int}.
- \pause
- \bigskip
- \item
- unärer Operator \lstinline{&}: Adresse
- \end{itemize}
- \end{minipage}
-\end{frame}
-
-\subsection{Arrays und Strings}
-
-\begin{frame}[fragile]
- \showsubsection
-
- Ein Zeiger zeigt auf eine Variable\only<2->{ und deren Nachbarn}.
-
-% \bigskip
- \pause
- \pause
-
- \begin{onlyenv}<1-8>
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- int prime[5] = { 2, 3, 5, 7, 11 };
- int *p = prime;
- for (int i = 0; i < 5; i++)
- printf ("%d\n", *(p + i));
- return 0;
- }
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<9>
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- int prime[5] = { 2, 3, 5, 7, 11 };
- int *p = prime;
- for (int i = 0; i < 5; i++)
- printf ("%d\n", p[i]);
- return 0;
- }
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<10>
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- int prime[5] = { 2, 3, 5, 7, 11 };
- for (int i = 0; i < 5; i++)
- printf ("%d\n", prime[i]);
- return 0;
- }
- ¡ ¿
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<11>
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- int prime[5] = { 2, 3, 5, 7, 11 };
- for (int *p = prime;
- p < prime + 5; p++)
- printf ("%d\n", *p);
- return 0;
- }
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<12>
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- int prime[6] = { 2, 3, 5, 7, 11, 0 };
- for (int *p = prime; *p; p++)
- printf ("%d\n", *p);
- return 0;
- }
- ¡ ¿
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<13->
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- int prime[] = { 2, 3, 5, 7, 11, 0 };
- for (int *p = prime; *p; p++)
- printf ("%d\n", *p);
- return 0;
- }
- ¡ ¿
- \end{lstlisting}
- \end{onlyenv}
-
- \pause
- \vspace{-3.05cm}\hspace{5.5cm}%
- \begin{minipage}{6.5cm}
- \begin{itemize}
- \item
- \lstinline{prime} ist \alt<5->{ein Array}{eine Ansammlung} von\\fünf ganzen Zahlen.
- \pause
- \pause
- \item
- \only<6-9>{\begin{picture}(0,0)
- \color{red}
- \put(-1.6,0.1){\tikz{\draw[-latex](0.0,0.0)--(-1,0);}}
- \end{picture}}%
- \lstinline{prime} ist ein Zeiger auf eine \lstinline{int}.
- \pause
- \item
- \lstinline{p + i} ist ein Zeiger\\
- auf den \lstinline{i}-ten Nachbarn von \lstinline{*p}.
- \pause
- \item
- \lstinline{*(p + i)} ist der \lstinline{i}-te Nachbar von \lstinline{*p}.
- \pause
- \item
- Andere Schreibweise:\\
- \lstinline{p[i]} statt \lstinline{*(p + i)}
- \pause
- \pause
- \item
- Zeiger-Arithmetik:\\
- \lstinline{p++} rückt den Zeiger \lstinline{p}\\
- um eine \lstinline{int} weiter.
- \pause
- \pause
- \item
- Array ohne \only<14->{explizite }Längenangabe:\\
- Compiler zählt selbst
- \vspace*{-1cm}
- \pause
- \begin{picture}(0,0)
- \put(-5.2,1.0){\makebox(0,0)[br]{\color{red}\bf\shortstack{Die Länge des Arrays\\ist \emph{nicht\/} veränderlich!}}}
- \end{picture}
- \end{itemize}
- \end{minipage}
-\end{frame}
-
-% \begin{frame}[fragile]
-% \showsubsection
-%
-% \begin{lstlisting}
-% #include <stdio.h>
-%
-% int main (void)
-% {
-% char hello_world[] = "Hello, world!\n";
-% int i = 0;
-% while (hello_world[i] != 0)
-% printf ("%d", hello_world[i++]);
-% return 0;
-% }
-% \end{lstlisting}
-% \end{frame}
-
-% \begin{frame}[fragile]
-% \showsubsection
-%
-% \begin{lstlisting}
-% #include <stdio.h>
-%
-% int main (void)
-% {
-% char hello_world[] = "Hello, world!\n";
-% int i = 0;
-% while (hello_world[i])
-% printf ("%d", hello_world[i++]);
-% return 0;
-% }
-% \end{lstlisting}
-% \end{frame}
-
-% \begin{frame}[fragile]
-% \showsubsection
-%
-% \begin{lstlisting}
-% #include <stdio.h>
-%
-% int main (void)
-% {
-% char hello_world[] = "Hello, world!\n";
-% char *p = hello_world;
-% while (*p)
-% printf ("%c", *p++);
-% return 0;
-% }
-% \end{lstlisting}
-% \end{frame}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{onlyenv}<1-6>
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- char hello[] = "Hello, world!\n";
- for (char *p = hello; *p; p++)
- printf ("%d", *p);
- return 0;
- }
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<7>
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- char hello[] = "Hello, world!\n";
- for (char *p = hello; *p; p++)
- printf ("%c", *p);
- return 0;
- }
- \end{lstlisting}
- \end{onlyenv}
-% \begin{onlyenv}<8>
-% \begin{lstlisting}[gobble=6]
-% #include <stdio.h>
-%
-% int main (void)
-% {
-% char hello[] = "Hello, world!\n";
-% printf ("%s", hello);
-% return 0;
-% }
-% ¡ ¿
-% \end{lstlisting}
-% \end{onlyenv}
-% \begin{onlyenv}<9>
-% \begin{lstlisting}[gobble=6]
-% #include <stdio.h>
-%
-% int main (void)
-% {
-% char *hello = "Hello, world!\n";
-% printf ("%s", hello);
-% return 0;
-% }
-% ¡ ¿
-% \end{lstlisting}
-% \end{onlyenv}
-% \begin{onlyenv}<10>
-% \begin{lstlisting}[gobble=6]
-% #include <stdio.h>
-%
-% int main (void)
-% {
-% char *hello = "Hello, world!\n";
-% while (*hello)
-% printf ("%c", *hello++);
-% return 0;
-% }
-% \end{lstlisting}
-% \end{onlyenv}
-
- \vspace{-1.7cm}\hfill
- \begin{minipage}{6.8cm}
- \begin{itemize}
- \pause[2]
- \item
- Ein \lstinline{char} ist eine kleinere \lstinline{int}.
- \pause
- \item
- Ein "`String"' in C ist ein Array von \lstinline{char}s\only<4->{,\\
- also ein Zeiger auf \lstinline{char}s}\only<5->{\\
- also ein Zeiger auf (kleinere) Integer}.
- \pause
- \pause
- \pause
- \item
- Der letzte \lstinline{char} muß 0 sein.\\
- Er kennzeichnet das Ende des Strings.
- \pause
- \item
- Die Formatspezifikation\\
- entscheidet über die Ausgabe:\\[\smallskipamount]
- \begin{tabular}{ll}
- \lstinline|%d|\hspace*{0.5em}dezimal
- & \lstinline|%c|\hspace*{0.5em}Zeichen\\
- \lstinline|%x|\hspace*{0.5em}hexadezimal
-% \pause
-% & \lstinline|%s|\hspace*{0.5em}String
- \end{tabular}
- \vspace*{-1cm}
- \end{itemize}
- \end{minipage}
-\end{frame}
-
-\addtocounter{subsection}{-1}
-\subsection{Arrays und Strings \protect\color{gray}und Zeichen}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \emph{"`Alles ist Zahl."'\/} -- Schule der Pythagoreer, 6.\ Jh.\ v.\,Chr.
-
- \medskip
-
- \begin{center}
- \renewcommand{\arraystretch}{1.5}
- \begin{tabular}{r}
- \lstinline|"Hello"|\\
- \lstinline|'H'|\\
- \lstinline|'a' + 4|
- \end{tabular}
- \renewcommand{\arraystretch}{1.0}
- \begin{tabular}{c}
- ist nur eine andere\\
- Schreibweise für
- \end{tabular}
- \renewcommand{\arraystretch}{1.5}
- \begin{tabular}{l}
- \lstinline|{ 72, 101, 108, 108, 111, 0 }|\\
- \lstinline|72|\\
- \lstinline|'e'|
- \end{tabular}
- \renewcommand{\arraystretch}{1.0}
- \end{center}
-
- \begin{itemize}
- \item
- Welchen Zahlenwert hat \lstinline{'*'} im Zeichensatz?
-
- \smallskip
-
- \begin{lstlisting}[gobble=8]
- printf ("%d\n", '*');
- \end{lstlisting}
-
- \smallskip
-
- (normalerweise: ASCII)
- \medskip
- \item
- Ist \lstinline{char ch} ein Großbuchstabe?
-
- \smallskip
-
- \begin{lstlisting}[gobble=8]
- if (ch >= 'A' && ch <= 'Z')
- ...
- \end{lstlisting}
- \medskip
- \item
- Groß- in Kleinbuchstaben umwandeln
-
- \smallskip
-
- \begin{lstlisting}[gobble=8]
- ch += 'a' - 'A';
- \end{lstlisting}
- \end{itemize}
-\end{frame}
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \begin{itemize}
- \item[2.1] Hello, world!
- \item[2.2] Programme compilieren und ausführen
- \item[2.3] Elementare Aus- und Eingabe
- \item[2.4] Elementares Rechnen
- \item[2.5] Verzweigungen
- \item[2.6] Schleifen
- \item[2.7] Strukturierte Programmierung
- \item[2.8] Seiteneffekte
- \color{medgreen}
- \item[2.9] Funktionen
- \item[2.10] Zeiger
- \item[2.11] Arrays und Strings
- \color{red}
- \item[2.12] Strukturen
- \item[\dots]
- \end{itemize}
- \color{gray}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \vspace*{-\smallskipamount}
- \item[\textbf{\dots}]
-% \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
-% \item[\textbf{5}] \textbf{Algorithmen}
-% \item[\textbf{6}] \textbf{Ergänzungen und Ausblicke}
- \end{itemize}
- \vspace*{-1cm}
-
-\end{frame}
-
-\end{document}
diff --git a/20221010/hp-musterloesung-20221010.pdf b/20221010/hp-musterloesung-20221010.pdf
deleted file mode 100644
index 702cba8bda0bb7341f4963f472a7f677ffc05ccc..0000000000000000000000000000000000000000
Binary files a/20221010/hp-musterloesung-20221010.pdf and /dev/null differ
diff --git a/20221010/hp-musterloesung-20221010.tex b/20221010/hp-musterloesung-20221010.tex
deleted file mode 100644
index 0e03af9727dbc70e4e939df693623e54c2beab1c..0000000000000000000000000000000000000000
--- a/20221010/hp-musterloesung-20221010.tex
+++ /dev/null
@@ -1,375 +0,0 @@
-% hp-musterloesung-20221010.pdf - Solutions to the Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Schaltjahr ermitteln, Multiplikationstabelle, Fibonacci-Zahlen, fehlerhaftes Programm
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\begin{document}
-
- \section*{Hardwarenahe Programmierung\\
- Musterlösung zu den Übungsaufgaben -- 10.\ Oktober 2022}
-
- \exercise{Schaltjahr ermitteln}
-
- Schreiben Sie ein C-Programm, das eine Jahreszahl erfragt
- und ausgibt, ob es sich um ein Schaltjahr handelt.
- \begin{itemize}
- \item Wenn die Jahreszahl durch 4 teilbar ist, ist das Jahr zunächst einmal ein Schaltjahr.
- \item Ausnahme: Wenn die Jahreszahl durch 100 teilbar ist, ist das Jahr kein Schaltjahr.
- \item Ausnahme von der Ausnahme: Wenn die Jahreszahl durch 400 teilbar ist,\\
- ist das Jahr doch wieder ein Schaltjahr.
- \end{itemize}
-
- \solution
-
- Am einfachsten ist es, die Aufgabenstellung in geschachtelte
- \lstinline{if}-Verzweigungen zu übersetzen.
- Im folgenden finden Sie eine Funktion \lstinline{is_leap_year()},
- der man das Jahr übergibt und die für Schaltjahre \lstinline{1}
- zurückgibt und für Nicht-Schaltjahre \lstinline{0}.
- \begin{lstlisting}
- #include <stdio.h>
-
- int is_leap_year (int year)
- {
- int leap_year = 0;
- if (year % 4 == 0)
- {
- leap_year = 1;
- if (year % 100 == 0)
- {
- leap_year = 0;
- if (year % 400 == 0)
- leap_year = 1;
- }
- }
- return leap_year;
- }
- \end{lstlisting}
- (In C steht \lstinline{0} für den Wahrheitswert "`falsch"'
- und jeder Wert ungleich \lstinline{0} für den Wahrheitswert "`wahr'";
- die Zeile \lstinline{leap_year = 0} steht daher wörtlich und
- selbsterklärend für "`ist kein Schaltjahr"'.)
-
- Unter Verwendung von \lstinline{else} läßt sich dies verkürzen zu:
- \begin{lstlisting}
- #include <stdio.h>
-
- int is_leap_year (int year)
- {
- if (year % 4 == 0)
- {
- if (year % 100 == 0)
- {
- if (year % 400 == 0)
- return 1;
- else
- return 0;
- }
- else
- return 1;
- }
- else
- return 0;
- }
- \end{lstlisting}
-
- Eine andere Möglichkeit ist es, die Schaltjahr-Bedingung in eine
- Kette von "`und"'- und "`oder"'-Verknüpfungen
- (C-Operatoren \lstinline{&&} und \lstinline{||}) zu übersetzen:
- \begin{lstlisting}
- int is_leap_year (int year)
- {
- if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
- return 1;
- else
- return 0;
- }
- \end{lstlisting}
- Dies ist zwar kürzer, aber nicht unbedingt übersichtlicher.
- Der erzeugte Code ist übrigens \emph{nicht\/} kürzer und/oder
- effizienter als bei der Verwendung mehrerer
- \lstinline{if}-Verzweigungen.
- Wir empfehlen, daß Sie immer so programmieren,
- daß Sie selbst den maximalen Überblick über Ihr Programm behalten.
-
- \goodbreak
-
- Ein Hauptprogramm, das die o.\,a.\ Funktion aufruft,
- könnte dann wie folgt aussehen:
- \begin{lstlisting}
- int main (void)
- {
- int year;
- printf ("Bitte geben Sie eine Jahreszahl ein: ");
- scanf ("%d", &year);
- if (is_leap_year (year))
- printf ("Das Jahr %d ist ein Schaltjahr.\n", year);
- else
- printf ("Das Jahr %d ist kein Schaltjahr.\n", year);
- return 0;
- }
- \end{lstlisting}
- In den Dateien \gitfile{hp}{2022ws/20221010}{loesung-1-1.c} bis \gitfile{hp}{2022ws/20221010}{loesung-1-3.c}
- finden Sie lauffähige Programme, die die o.\,a.\ Funktionen aufrufen.
- Beachten Sie, daß die Funktion \emph{vor\/} dem Hauptprogramm
- deklariert werden muß, damit das Hauptprogramm sie kennt.
- (Es gibt Tricks, mit denen es auch anders geht,
- aber was hätten wir in diesem Zusammenhang davon?)
-
- In \gitfile{hp}{2022ws/20221010}{loesung-1-4.c} und \gitfile{hp}{2022ws/20221010}{loesung-1-5.c}
- findet die Schaltjahr-Prüfung direkt im Hauptprogramm statt.
- Dies ist ebenfalls eine richtige Lösung der Aufgabe,
- schränkt aber die Wiederverwertbarkeit des Codes ein.
-
- Die Datei \gitfile{hp}{2022ws/20221010}{loesung-1-4.c} enthält darüberhinaus Codeverdopplungen,
- nämlich mehrere identische \lstinline{printf()}-Auf"-rufe
- an unterschiedlichen Stellen.
- Dies ist schlechter Programmierstil ("`Cut-and-paste-Programmierung"').
-
- Die besten Lösungen sind \gitfile{hp}{2022ws/20221010}{loesung-1-2.c}
- und \gitfile{hp}{2022ws/20221010}{loesung-1-3.c}.
-
- \goodbreak
-
- Zum Testen:\vspace*{-\medskipamount}
- \begin{itemize}\itemsep0pt
- \item 1900 ist kein Schaltjahr.
- \item 1902 ist kein Schaltjahr.
- \item 1904 ist ein Schaltjahr.
- \item 1996 ist ein Schaltjahr.
- \item 1998 ist kein Schaltjahr.
- \item 2000 ist ein Schaltjahr.
- \item 2002 ist kein Schaltjahr.
- \item 2004 ist ein Schaltjahr.
- \item 2019 ist kein Schaltjahr.
- \item 2020 ist ein Schaltjahr.
- \item 2021 ist kein Schaltjahr.
- \item 2022 ist kein Schaltjahr.
- \end{itemize}
-
- \goodbreak
-
- Hier noch ein Hinweis für Unix-Shell-Experten:
- \begin{lstlisting}[style=cmd]
- for y in 1 2 3 4 5; do
- clear
- for x in 1900 1902 1904 1996 1998 2000 2002 2004 2019 2020 2021 2022; do
- echo $x | ./loesung-1-$y
- done
- sleep 2s
- done
- \end{lstlisting}
-
- \exercise{Multiplikationstabelle}
-
- Geben Sie mit Hilfe einer Schleife ein "`Einmaleins"' aus.\\
- Dabei sollen die Faktoren und Ergebnisse rechtsbündig untereinander stehen:
- \begin{lstlisting}[style=terminal]
- 1 * 7 = 7
- 2 * 7 = 14
- ...
- 10 * 7 = 70
- \end{lstlisting}
- Hinweis: Verwenden Sie Formatspezifikationen wie z.\,B.\ \lstinline{%3d}\\
- (siehe dazu die Dokumentation zu \lstinline{printf()},
- z.\,B.\ \,\lstinline[style=cmd]{man 3 printf}\,)
-
- \solution
-
- Drei verschiedene richtige Lösungen finden Sie in den Dateien
- \gitfile{hp}{2022ws/20221010}{loesung-2-1.c}, \gitfile{hp}{2022ws/20221010}{loesung-2-2.c} und \gitfile{hp}{2022ws/20221010}{loesung-2-3.c}.
- (Zum Compilieren von \gitfile{hp}{2022ws/20221010}{loesung-2-2.c} und \gitfile{hp}{2022ws/20221010}{loesung-2-3.c}
- ist mindestens der C99-Standard erforderlich; bitte nötigenfalls
- in \file{gcc} die Option \lstinline[style=cmd]{-std=c99} mit angeben.)
-
- Die Lösung in \gitfile{hp}{2022ws/20221010}{loesung-2-3.c} ist zwar richtig,
- aber unnötig kompliziert und daher nicht empfohlen.
-
- Eine \textbf{falsche} Lösung finden Sie in der Datei \gitfile{hp}{2022ws/20221010}{loesung-2-f4.c}:
- In der Ausgabe dieses Programms stehen die Faktoren und Ergebnisse
- nicht rechtsbündig untereinander.
-
- \exercise{Fibonacci-Zahlen}
-
- Die Folge der Fibonacci-Zahlen ist definiert durch:
- \begin{quote}
- 1.\ Zahl: 0\\
- 2.\ Zahl: 1\\
- nächste Zahl = Summe der beiden vorherigen
- \end{quote}
- Schreiben Sie ein Programm, das die ersten 50 Fibonacci-Zahlen ausgibt.
-
- Falls Ihnen dabei irgendwelche Besonderheiten auffallen
- und/oder Sie irgendwelche besondere Maßnahmen treffen,
- dokumentieren Sie diese.
-
- (Wem dies zu einfach ist, kann auch gerne
- die ersten 100 Fibonacci-Zahlen ausgeben.)
-
- \solution
-
- Zwei verschiedene richtige Lösungen finden Sie in den Dateien
- \gitfile{hp}{2022ws/20221010}{loesung-3-1.c} und \gitfile{hp}{2022ws/20221010}{loesung-3-2.c}.
-
- Die Lösung in \gitfile{hp}{2022ws/20221010}{loesung-3-2.c}
- speichert alle berechneten Zahlen in einem Array,
- die in \gitfile{hp}{2022ws/20221010}{loesung-3-1.c} hingegen
- speichert immer nur maximal drei Zahlen gleichzeitig.
- Sofern nicht alle berechneten Zahlen später noch benötigt werden,
- ist daher \gitfile{hp}{2022ws/20221010}{loesung-3-1.c} zu bevorzugen.
-
- Wichtig in \gitfile{hp}{2022ws/20221010}{loesung-3-1.c} ist, daß \lstinline{f0 + f1} berechnet wird,
- \emph{bevor\/} \lstinline{f0} oder \lstinline{f1} ein neuer Wert zugewiesen wird.
- Dies ist nur möglich, weil das Programm
- eine zusätzliche Variable (hier: \lstinline{f2}) verwendet.
-
- \goodbreak
-
- Eine "`Besonderheit"' besteht darin, daß das Ergebnis
- ab der Fibonacci-Zahl Nr.~47 \textbf{falsch} ist:
- \begin{lstlisting}[style=terminal]
- f[45] = 1134903170
- f[46] = 1836311903
- f[47] = -1323752223
- f[48] = 512559680
- f[49] = -811192543
- \end{lstlisting}
- Die Summe zweier positiver Zahlen darf keine negative Zahl sein.
-
- (Mit der Dokumentation dieser Beobachtung
- ist die Aufgabenstellung bereits erfüllt.)
-
- Der Grund für diese fehlerhafte Rechnung
- ist die begrenzte Rechengenauigkeit unserer Rechner,
- in diesem Fall ein sogenannter \newterm{Integer-Überlauf}.
- Details dazu sind Gegenstand von Kapitel~5 der Lehrveranstaltung.
-
- Eine "`besondere Maßnahme"' besteht darin,
- anstelle des "`normalen"' Ganzzahl-Datentyps \lstinline{int}
- "`lange"' ganze Zahlen (\lstinline{long int}) zu verwenden --
- siehe \gitfile{hp}{2022ws/20221010}{loesung-3-3.c}.
- Damit nicht nur die Rechnung, sondern auch die Ausgabe funktioniert,
- muß die Formatspezifikation in \lstinline{printf()}
- von \lstinline{%d} zu \lstinline{%ld} angepaßt werden --
- siehe \gitfile{hp}{2022ws/20221010}{loesung-3-4.c}.
- (Anstelle von \lstinline{long int} verwendet man üblicherweise
- abkürzend \lstinline{long} -- siehe \gitfile{hp}{2022ws/20221010}{loesung-3-5.c}.)
-
- Wenn die genaue Rechengenauigkeit wichtig ist, sind die Definitionen
- der Datentypen \lstinline{int} und \lstinline{long} zu unpräzise.
- Für derartige Fälle gibt es spezielle Datentypen,
- z.\,B.\ \lstinline{uint64_t} für vorzeichenlose 64-Bit-Ganzzahlen.
- Für die Ausgabe derartiger Datentypen sind spezielle Formatspezifikationen
- erforderlich. Die Beispiel-Lösungen \gitfile{hp}{2022ws/20221010}{loesung-3-5.c}
- und \gitfile{hp}{2022ws/20221010}{loesung-3-6.c} funktionieren zwar,
- zeigen aber \emph{noch nicht\/} die bestmögliche Lösung.
-
- \textbf{Achtung:} Die Verwendung von Fließkommazahlen
- für ganzzahlige Berechnungen wie bei den Fibonacci-Zahlen
- ist \textbf{nicht} zielführend!
- Die in \gitfile{hp}{2022ws/20221010}{loesung-3-7f.c}
- bis \gitfile{hp}{2022ws/20221010}{loesung-3-12f.c} vorgestellte "`Lösung"'
- ist \textbf{falsch}.
-
- \bigskip
-
- \exercise{Fehlerhaftes Programm}
-
- \begin{minipage}[t]{0.65\textwidth}
- Wir betrachten das nebenstehende C-Programm
- (Datei: \gitfile{hp}{2022ws/20221010}{aufgabe-4.c}).
- \begin{itemize}
- \item[(a)]
- Was bewirkt dieses Programm? Begründen Sie Ihre Antwort.
-
- Schreiben Sie Ihre Begründung so auf,
- daß man sie auch dann versteht,
- wenn man gerade nicht die Möglichkeit hat,
- bei Ihnen persönlich nachzufragen
- (z.\,B.\ weil man gerade eine Klausur korrigiert).
-
- Die Schwierigkeit dieser Aufgabe besteht
- nicht allein darin, die Problematik zu verstehen,
- sondern auch darin, dieses Verständnis für andere aufzuschreiben.
- \item[(b)]
- Ändern Sie das Programm so um,
- daß es einen "`Countdown"' von 10 bis 0 ausgibt.
- \end{itemize}
- \end{minipage}\hfill
- \begin{minipage}[t]{0.3\textwidth}
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- for (int i = 10; i = 0; i - 1)
- printf ("%d\n", i);
- return 0;
- }
- \end{lstlisting}
- \end{minipage}
-
- \solution
-
- \begin{itemize}
- \item[(a)]
- \textbf{Was bewirkt dieses Programm? Begründen Sie Ihre Antwort.}
-
- Dieses Programm bewirkt nichts.
- Die \lstinline{for}-Schleife wird nicht ausgeführt.
-
- Begründung: Die \lstinline{for}-Bedingung ist eine Zuweisung
- des Werts \lstinline{0} an die Variable \lstinline{i}.
- Neben dem Seiteneffekt der Zuweisung liefert der Ausdruck
- einen Wert zurück, nämlich den zugewiesenen Wert
- \lstinline{0}. Dieser wird von \lstinline{for} als eine
- Bedingung mit dem konstanten Wert "`falsch"' interpretiert.
-
- (Hinweis: Ohne diese Begründung ist die Aufgabe nur zu einem
- kleinen Teil gelöst.)
-
- Darüberhinaus ist die Zähl-Anwendung unwirksam: Sie berechnet
- den Wert \lstinline{i - 1} und vergißt ihn wieder, ohne ihn
- einer Variablen (z.\,B.\ \lstinline{i}) zuzuweisen.
-
- \goodbreak
- \item[(b)]
- \textbf{Ändern Sie das Programm so, daß es einen "`Countdown"' von 10 bis 0 ausgibt.}
-
- Datei \gitfile{hp}{2022ws/20221010}{loesung-4.c}:
- \begin{lstlisting}[gobble=8]
- #include <stdio.h>
-
- int main (void)
- {
- for (int i = 10; i >= 0; i--)
- printf ("%d\n", i);
- return 0;
- }
- \end{lstlisting}
- \end{itemize}
-
-\end{document}
diff --git a/20221010/hp-uebung-20221010.pdf b/20221010/hp-uebung-20221010.pdf
deleted file mode 100644
index cbaa3880ee4a1c3e3e24807f501ee07d22c63bf3..0000000000000000000000000000000000000000
Binary files a/20221010/hp-uebung-20221010.pdf and /dev/null differ
diff --git a/20221010/hp-uebung-20221010.tex b/20221010/hp-uebung-20221010.tex
deleted file mode 100644
index ab3dca92ebc752ea7e3eb336e666d38d745cf3d9..0000000000000000000000000000000000000000
--- a/20221010/hp-uebung-20221010.tex
+++ /dev/null
@@ -1,114 +0,0 @@
-% hp-uebung-20221010.pdf - Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Schaltjahr ermitteln, Multiplikationstabelle, Fibonacci-Zahlen, fehlerhaftes Programm
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\begin{document}
-
- \thispagestyle{empty}
-
- \section*{Hardwarenahe Programmierung\\
- Übungsaufgaben -- 10.\ Oktober 2022}
-
- \exercise{Schaltjahr ermitteln}
-
- Schreiben Sie ein C-Programm, das eine Jahreszahl erfragt
- und ausgibt, ob es sich um ein Schaltjahr handelt.
- \begin{itemize}
- \item Wenn die Jahreszahl durch 4 teilbar ist, ist das Jahr zunächst einmal ein Schaltjahr.
- \item Ausnahme: Wenn die Jahreszahl durch 100 teilbar ist, ist das Jahr kein Schaltjahr.
- \item Ausnahme von der Ausnahme: Wenn die Jahreszahl durch 400 teilbar ist,\\
- ist das Jahr doch wieder ein Schaltjahr.
- \end{itemize}
-
- \exercise{Multiplikationstabelle}
-
- Geben Sie mit Hilfe einer Schleife ein "`Einmaleins"' aus.\\
- Dabei sollen die Faktoren und Ergebnisse rechtsbündig untereinander stehen:
- \begin{lstlisting}[style=terminal]
- 1 * 7 = 7
- 2 * 7 = 14
- ...
- 10 * 7 = 70
- \end{lstlisting}
- \textbf{Hinweis:} Verwenden Sie Formatspezifikationen wie z.\,B.\ \lstinline{%3d}\\
- (siehe dazu die Dokumentation zu \lstinline{printf()},
- z.\,B.\ \,\lstinline[style=cmd]{man 3 printf}\,)
-
- \exercise{Fibonacci-Zahlen}
-
- Die Folge der Fibonacci-Zahlen ist definiert durch:
- \begin{quote}
- 1.\ Zahl: 0\\
- 2.\ Zahl: 1\\
- nächste Zahl = Summe der beiden vorherigen
- \end{quote}
- Schreiben Sie ein Programm, das die ersten 50 Fibonacci-Zahlen ausgibt.
-
- Falls Ihnen dabei irgendwelche Besonderheiten auffallen
- und/oder Sie irgendwelche besondere Maßnahmen treffen,
- dokumentieren Sie diese.
-
- (Wem dies zu einfach ist, kann auch gerne
- die ersten 100 Fibonacci-Zahlen ausgeben.)
-
- \exercise{Fehlerhaftes Programm}
-
- \begin{minipage}[t]{0.65\textwidth}
- Wir betrachten das nebenstehende C-Programm
- (Datei: \gitfile{hp}{2022ws/20221010}{aufgabe-4.c}).
- \begin{itemize}
- \item[(a)]
- Was bewirkt dieses Programm? Begründen Sie Ihre Antwort.
-
- Schreiben Sie Ihre Begründung so auf,
- daß man sie auch dann versteht,
- wenn man gerade nicht die Möglichkeit hat,
- bei Ihnen persönlich nachzufragen
- (z.\,B.\ weil man gerade eine Klausur korrigiert).
-
- Die Schwierigkeit dieser Aufgabe besteht
- nicht allein darin, die Problematik zu verstehen,
- sondern auch darin, dieses Verständnis für andere aufzuschreiben.
- \item[(b)]
- Ändern Sie das Programm so um,
- daß es einen "`Countdown"' von 10 bis 0 ausgibt.
- \end{itemize}
- \end{minipage}\hfill
- \begin{minipage}[t]{0.3\textwidth}
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- for (int i = 10; i = 0; i - 1)
- printf ("%d\n", i);
- return 0;
- }
- \end{lstlisting}
- \end{minipage}
-
-\end{document}
diff --git a/20221010/if-14.c b/20221010/if-14.c
deleted file mode 100644
index 5223dbd7e5a29bc624505c1f492aaedd6ef1e174..0000000000000000000000000000000000000000
--- a/20221010/if-14.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 42;
- if (a = 0)
- printf ("a ist gleich 0.\n");
- else
- printf ("a ist ungleich 0, nämlich %d.\n", a);
- return 0;
-}
diff --git a/20221010/if-15.c b/20221010/if-15.c
deleted file mode 100644
index c11ce599bf9a0b77f19f65007455398c84f8a7e4..0000000000000000000000000000000000000000
--- a/20221010/if-15.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 42;
- if ((a = 0) != 0)
- printf ("a ist gleich 0.\n");
- else
- printf ("a ist ungleich 0, nämlich %d.\n", a);
- return 0;
-}
diff --git a/20221010/if-16.c b/20221010/if-16.c
deleted file mode 100644
index eb9a1b0201bef2c3ac8a1356c32a020f3dbb2648..0000000000000000000000000000000000000000
--- a/20221010/if-16.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 42;
- if (a == 0)
- printf ("a ist gleich 0.\n");
- else
- printf ("a ist ungleich 0, nämlich %d.\n", a);
- return 0;
-}
diff --git a/20221010/if-17.c b/20221010/if-17.c
deleted file mode 100644
index ed40dafb79e72bd97b7e447a23ad1bc75358e668..0000000000000000000000000000000000000000
--- a/20221010/if-17.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 42;
- if (a += 0)
- printf ("a ist gleich 0.\n");
- else
- printf ("a ist ungleich 0, nämlich %d.\n", a);
- return 0;
-}
diff --git a/20221010/if-18.c b/20221010/if-18.c
deleted file mode 100644
index 6084990ba45dcbf61c4f5d916ade9fe449e6dae7..0000000000000000000000000000000000000000
--- a/20221010/if-18.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 42;
- if (a += 0)
- printf ("a += 0 ist ungleich 0, nämlich %d.\n", a);
- else
- printf ("a += 0 ist gleich 0.\n");
- return 0;
-}
diff --git a/20221010/loesung-1-1.c b/20221010/loesung-1-1.c
deleted file mode 100644
index ea41b8ea35bf871389c8be15779a58c293c81049..0000000000000000000000000000000000000000
--- a/20221010/loesung-1-1.c
+++ /dev/null
@@ -1,29 +0,0 @@
-#include <stdio.h>
-
-int is_leap_year (int year)
-{
- int leap_year = 0;
- if (year % 4 == 0)
- {
- leap_year = 1;
- if (year % 100 == 0)
- {
- leap_year = 0;
- if (year % 400 == 0)
- leap_year = 1;
- }
- }
- return leap_year;
-}
-
-int main (void)
-{
- int year;
- printf ("Bitte geben Sie eine Jahreszahl ein: ");
- scanf ("%d", &year);
- if (is_leap_year (year))
- printf ("Das Jahr %d ist ein Schaltjahr.\n", year);
- else
- printf ("Das Jahr %d ist kein Schaltjahr.\n", year);
- return 0;
-}
diff --git a/20221010/loesung-1-2.c b/20221010/loesung-1-2.c
deleted file mode 100644
index d9e4df8a36238875e0b46398b21f93e7f4f98792..0000000000000000000000000000000000000000
--- a/20221010/loesung-1-2.c
+++ /dev/null
@@ -1,31 +0,0 @@
-#include <stdio.h>
-
-int is_leap_year (int year)
-{
- if (year % 4 == 0)
- {
- if (year % 100 == 0)
- {
- if (year % 400 == 0)
- return 1;
- else
- return 0;
- }
- else
- return 1;
- }
- else
- return 0;
-}
-
-int main (void)
-{
- int year;
- printf ("Bitte geben Sie eine Jahreszahl ein: ");
- scanf ("%d", &year);
- if (is_leap_year (year))
- printf ("Das Jahr %d ist ein Schaltjahr.\n", year);
- else
- printf ("Das Jahr %d ist kein Schaltjahr.\n", year);
- return 0;
-}
diff --git a/20221010/loesung-1-3.c b/20221010/loesung-1-3.c
deleted file mode 100644
index 97051b3bb5e6620ff771d6b3f5949687130abea8..0000000000000000000000000000000000000000
--- a/20221010/loesung-1-3.c
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <stdio.h>
-
-int is_leap_year (int year)
-{
- if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
- return 1;
- else
- return 0;
-}
-
-int main (void)
-{
- int year;
- printf ("Bitte geben Sie eine Jahreszahl ein: ");
- scanf ("%d", &year);
- if (is_leap_year (year))
- printf ("Das Jahr %d ist ein Schaltjahr.\n", year);
- else
- printf ("Das Jahr %d ist kein Schaltjahr.\n", year);
- return 0;
-}
diff --git a/20221010/loesung-1-4.c b/20221010/loesung-1-4.c
deleted file mode 100644
index 3a0d218e6c03f326ad73bad55ad3e29ea882eb2d..0000000000000000000000000000000000000000
--- a/20221010/loesung-1-4.c
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int year;
- printf ("Bitte geben Sie eine Jahreszahl ein: ");
- scanf ("%d", &year);
- if (year % 4 == 0)
- {
- if (year % 100 == 0)
- {
- if (year % 400 == 0)
- printf ("Das Jahr %d ist ein Schaltjahr.\n", year);
- else
- printf ("Das Jahr %d ist kein Schaltjahr.\n", year);
- }
- else
- printf ("Das Jahr %d ist ein Schaltjahr.\n", year);
- }
- else
- printf ("Das Jahr %d ist kein Schaltjahr.\n", year);
- return 0;
-}
diff --git a/20221010/loesung-1-5.c b/20221010/loesung-1-5.c
deleted file mode 100644
index 999d9f2030e29f1c961b12d647d2e82592b637bf..0000000000000000000000000000000000000000
--- a/20221010/loesung-1-5.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int year;
- printf ("Bitte geben Sie eine Jahreszahl ein: ");
- scanf ("%d", &year);
- if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
- printf ("Das Jahr %d ist ein Schaltjahr.\n", year);
- else
- printf ("Das Jahr %d ist kein Schaltjahr.\n", year);
- return 0;
-}
diff --git a/20221010/loesung-2-1.c b/20221010/loesung-2-1.c
deleted file mode 100644
index 5ec9dd3caf6639d22bf770ef4b6bb779a3d7c714..0000000000000000000000000000000000000000
--- a/20221010/loesung-2-1.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 1;
- int b = 7;
- while (a <= 10)
- {
- printf ("%2d * %d = %2d\n", a, b, a * b);
- a++;
- }
- return 0;
-}
diff --git a/20221010/loesung-2-1a.c b/20221010/loesung-2-1a.c
deleted file mode 100644
index 8acad25cdce91f7f1dec5e2d8607a08f709cff2a..0000000000000000000000000000000000000000
--- a/20221010/loesung-2-1a.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 1;
- int b = 7;
- while (a <= 10)
- {
- printf ("%*d * %d = %*d\n", a, 2, b, a * b, 2);
- a++;
- }
- return 0;
-}
diff --git a/20221010/loesung-2-1b.c b/20221010/loesung-2-1b.c
deleted file mode 100644
index b739818db5ea8ecb13a18a1700bce9d9d4f85140..0000000000000000000000000000000000000000
--- a/20221010/loesung-2-1b.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 1;
- int b = 7;
- while (a <= 10)
- {
- printf ("%*d * %d = %*d\n", 2, a, b, 2, a * b);
- a++;
- }
- return 0;
-}
diff --git a/20221010/loesung-2-1c.c b/20221010/loesung-2-1c.c
deleted file mode 100644
index f09dc57abf6efa82ab7918590126e721e1c7dd4d..0000000000000000000000000000000000000000
--- a/20221010/loesung-2-1c.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 1;
- int b = 7;
- char format[42];
- sprintf (format, "%%%dd * %%d = %%%dd\n", 2, 2);
- printf ("format = %s\n", format);
- while (a <= 10)
- {
- printf (format, a, b, a * b);
- a++;
- }
- return 0;
-}
diff --git a/20221010/loesung-2-1d.c b/20221010/loesung-2-1d.c
deleted file mode 100644
index 8d4aa51b4ad32fd32bb2a62e31255f089bd3991e..0000000000000000000000000000000000000000
--- a/20221010/loesung-2-1d.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 1;
- int b = 7;
- char format[42];
- snprintf (format, 42, "%%%dd * %%d = %%%dd\n", 2, 2);
- format[41] = 0;
- printf ("format = %s\n", format);
- while (a <= 10)
- {
- printf (format, a, b, a * b);
- a++;
- }
- return 0;
-}
diff --git a/20221010/loesung-2-2.c b/20221010/loesung-2-2.c
deleted file mode 100644
index 8f9319ee596a52f38531a2cefb376b54e7ec3ec0..0000000000000000000000000000000000000000
--- a/20221010/loesung-2-2.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int x = 7;
- for (int i = 1; i <= 10; i++)
- printf ("%2d *%2d =%3d\n", i, x, i * x);
- return 0;
-}
diff --git a/20221010/loesung-2-3.c b/20221010/loesung-2-3.c
deleted file mode 100644
index 71fca2538b991397ac5f046a33ff0f9130b2980f..0000000000000000000000000000000000000000
--- a/20221010/loesung-2-3.c
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int x = 7;
- for (int i = 1; i <= 10; i++)
- {
- if (i >= 10)
- printf ("%d", i);
- else
- printf (" %d", i);
- printf (" * %d = ", x);
- int y = i * x;
- if (y >= 10)
- printf ("%d", y);
- else
- printf (" %d", y);
- printf ("\n");
- }
- return 0;
-}
diff --git a/20221010/loesung-2-f4.c b/20221010/loesung-2-f4.c
deleted file mode 100644
index 8520d438f654856a74c22ffd01b9c5815741efbc..0000000000000000000000000000000000000000
--- a/20221010/loesung-2-f4.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int x = 7;
- for (int i = 1; i <= 10; i++)
- printf ("%d * %d = %d\n", i, x, i * x);
- return 0;
-}
diff --git a/20221010/loesung-3-1.c b/20221010/loesung-3-1.c
deleted file mode 100644
index ec5f4d9f93985577246eefccdd0f6003403795ab..0000000000000000000000000000000000000000
--- a/20221010/loesung-3-1.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int f0 = 0;
- int f1 = 1;
- for (int i = 0; i < 50; i++)
- {
- printf ("f[%d] = %d\n", i, f0);
- int f2 = f0 + f1;
- f0 = f1;
- f1 = f2;
- }
- return 0;
-}
diff --git a/20221010/loesung-3-10f.c b/20221010/loesung-3-10f.c
deleted file mode 100644
index 7bb464e8490084edbe8f388e1e6cf2bfd0b5c4be..0000000000000000000000000000000000000000
--- a/20221010/loesung-3-10f.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- long double f0 = 0;
- long double f1 = 1;
- for (int i = 0; i < 200; i++)
- {
- printf ("f[%d] = %.0Lf\n", i, f0);
- long double f2 = f0 + f1;
- f0 = f1;
- f1 = f2;
- }
- return 0;
-}
diff --git a/20221010/loesung-3-11f.c b/20221010/loesung-3-11f.c
deleted file mode 100644
index def1256c1aaa78d07234bf73be485077e5e68270..0000000000000000000000000000000000000000
--- a/20221010/loesung-3-11f.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- long double f0 = 0;
- long double f1 = 1;
- for (int i = 0; i < 200; i++)
- {
- printf ("f[%d] = %30.0Lf\n", i, f0);
- long double f2 = f0 + f1;
- f0 = f1;
- f1 = f2;
- }
- return 0;
-}
diff --git a/20221010/loesung-3-12f.c b/20221010/loesung-3-12f.c
deleted file mode 100644
index 7ca898622fd72bac0cf074b947f0e0f8810d3689..0000000000000000000000000000000000000000
--- a/20221010/loesung-3-12f.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- long double f0 = 0;
- long double f1 = 1;
- for (int i = 0; i < 200; i++)
- {
- printf ("f[%3d] = %60.0Lf\n", i, f0);
- long double f2 = f0 + f1;
- f0 = f1;
- f1 = f2;
- }
- return 0;
-}
diff --git a/20221010/loesung-3-2.c b/20221010/loesung-3-2.c
deleted file mode 100644
index 7043f66e6b73894be9547a5562de8cad43cf0e71..0000000000000000000000000000000000000000
--- a/20221010/loesung-3-2.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int f[50];
- f[0] = 0;
- f[1] = 1;
- for (int i = 2; i < 50; i++)
- f[i] = f[i - 2] + f[i - 1];
- for (int i = 0; i < 50; i++)
- printf ("f[%d] = %d\n", i, f[i]);
- return 0;
-}
diff --git a/20221010/loesung-3-3.c b/20221010/loesung-3-3.c
deleted file mode 100644
index c27f4717a14c244d609c4c2d86a21c1026679d3e..0000000000000000000000000000000000000000
--- a/20221010/loesung-3-3.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- long int f0 = 0;
- long int f1 = 1;
- for (int i = 0; i < 50; i++)
- {
- printf ("f[%d] = %d\n", i, f0);
- long int f2 = f0 + f1;
- f0 = f1;
- f1 = f2;
- }
- return 0;
-}
diff --git a/20221010/loesung-3-4.c b/20221010/loesung-3-4.c
deleted file mode 100644
index c3c0dbe62bffce9adfc49cadb1c747e2e932c04e..0000000000000000000000000000000000000000
--- a/20221010/loesung-3-4.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- long int f0 = 0;
- long int f1 = 1;
- for (int i = 0; i < 50; i++)
- {
- printf ("f[%d] = %ld\n", i, f0);
- long int f2 = f0 + f1;
- f0 = f1;
- f1 = f2;
- }
- return 0;
-}
diff --git a/20221010/loesung-3-5.c b/20221010/loesung-3-5.c
deleted file mode 100644
index 119125542cf5fdca1289cf5918428f1634c4f2ee..0000000000000000000000000000000000000000
--- a/20221010/loesung-3-5.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- long f0 = 0;
- long f1 = 1;
- for (int i = 0; i < 50; i++)
- {
- printf ("f[%d] = %ld\n", i, f0);
- long f2 = f0 + f1;
- f0 = f1;
- f1 = f2;
- }
- return 0;
-}
diff --git a/20221010/loesung-3-6.c b/20221010/loesung-3-6.c
deleted file mode 100644
index 339217e92fb44da2e667dc15c5bbd839b9f579c2..0000000000000000000000000000000000000000
--- a/20221010/loesung-3-6.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-int main (void)
-{
- uint64_t f0 = 0;
- uint64_t f1 = 1;
- for (int i = 0; i < 100; i++)
- {
- printf ("f[%d] = %lu\n", i, f0);
- uint64_t f2 = f0 + f1;
- f0 = f1;
- f1 = f2;
- }
- return 0;
-}
diff --git a/20221010/loesung-3-6a.c b/20221010/loesung-3-6a.c
deleted file mode 100644
index 685ba9744a1fe3104459a75c9f534887b8ad4cd9..0000000000000000000000000000000000000000
--- a/20221010/loesung-3-6a.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-int main (void)
-{
- uint128_t f0 = 0;
- uint128_t f1 = 1;
- for (int i = 0; i < 100; i++)
- {
- printf ("f[%d] = %lu\n", i, f0);
- uint128_t f2 = f0 + f1;
- f0 = f1;
- f1 = f2;
- }
- return 0;
-}
diff --git a/20221010/loesung-3-7f.c b/20221010/loesung-3-7f.c
deleted file mode 100644
index 11a9e200a07e1e7c368b014f659f3c5f55196ff3..0000000000000000000000000000000000000000
--- a/20221010/loesung-3-7f.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- long double f0 = 0;
- long double f1 = 1;
- for (int i = 0; i < 100; i++)
- {
- printf ("f[%d] = %llf\n", i, f0);
- long double f2 = f0 + f1;
- f0 = f1;
- f1 = f2;
- }
- return 0;
-}
diff --git a/20221010/loesung-3-8f.c b/20221010/loesung-3-8f.c
deleted file mode 100644
index d6aff68d21c4aa754fa94a434f5bb17235d6535e..0000000000000000000000000000000000000000
--- a/20221010/loesung-3-8f.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- long double f0 = 0;
- long double f1 = 1;
- for (int i = 0; i < 100; i++)
- {
- printf ("f[%d] = %Lf\n", i, f0);
- long double f2 = f0 + f1;
- f0 = f1;
- f1 = f2;
- }
- return 0;
-}
diff --git a/20221010/loesung-3-9f.c b/20221010/loesung-3-9f.c
deleted file mode 100644
index e1d95dc56e72da5a203548ff0907c6c128004a28..0000000000000000000000000000000000000000
--- a/20221010/loesung-3-9f.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- long double f0 = 0;
- long double f1 = 1;
- for (int i = 0; i < 100; i++)
- {
- printf ("f[%d] = %.0Lf\n", i, f0);
- long double f2 = f0 + f1;
- f0 = f1;
- f1 = f2;
- }
- return 0;
-}
diff --git a/20221010/loesung-4.c b/20221010/loesung-4.c
deleted file mode 100644
index f8481e994c02ac8e581244713756c9e9be7c7fd6..0000000000000000000000000000000000000000
--- a/20221010/loesung-4.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- for (int i = 10; i >= 0; i--)
- printf ("%d\n", i);
- return 0;
-}
diff --git a/20221010/logo-hochschule-bochum-cvh-text-v2.pdf b/20221010/logo-hochschule-bochum-cvh-text-v2.pdf
deleted file mode 120000
index 4aa99b8f81061aca6dcaf43eed2d9efef40555f8..0000000000000000000000000000000000000000
--- a/20221010/logo-hochschule-bochum-cvh-text-v2.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
diff --git a/20221010/logo-hochschule-bochum.pdf b/20221010/logo-hochschule-bochum.pdf
deleted file mode 120000
index b6b9491e370e499c9276918182cdb82cb311bcd1..0000000000000000000000000000000000000000
--- a/20221010/logo-hochschule-bochum.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20221010/pgscript.sty b/20221010/pgscript.sty
deleted file mode 120000
index 95c888478c99ea7fda0fd11ccf669ae91be7178b..0000000000000000000000000000000000000000
--- a/20221010/pgscript.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgscript.sty
\ No newline at end of file
diff --git a/20221010/pgslides.sty b/20221010/pgslides.sty
deleted file mode 120000
index 5be1416f4216f076aa268901f52a15d775e43f64..0000000000000000000000000000000000000000
--- a/20221010/pgslides.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgslides.sty
\ No newline at end of file
diff --git a/20221010/pointers-01.c b/20221010/pointers-01.c
deleted file mode 100644
index 421153a64907b61eebbacec398ed4f1fcb487cc6..0000000000000000000000000000000000000000
--- a/20221010/pointers-01.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-
-void calc_answer (int a)
-{
- a = 42;
-}
-
-int main (void)
-{
- int answer;
- calc_answer (answer);
- printf ("The answer is %d.\n", answer);
- return 0;
-}
diff --git a/20221010/pointers-02.c b/20221010/pointers-02.c
deleted file mode 100644
index 0a67f323100640643892d28f8675e725215b849b..0000000000000000000000000000000000000000
--- a/20221010/pointers-02.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <stdio.h>
-
-void calc_answer (int a)
-{
- printf ("1: a = %d\n", a);
- a = 42;
- printf ("2: a = %d\n", a);
-}
-
-int main (void)
-{
- int answer;
- calc_answer (answer);
- printf ("The answer is %d.\n", answer);
- return 0;
-}
diff --git a/20221010/pointers-03.c b/20221010/pointers-03.c
deleted file mode 100644
index 25e3c5698f86e558c8dfc33b55387d2ec9816e17..0000000000000000000000000000000000000000
--- a/20221010/pointers-03.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <stdio.h>
-
-void calc_answer (int a)
-{
- printf ("1: a = %d\n", a);
- a = 42;
- printf ("2: a = %d\n", a);
-}
-
-int main (void)
-{
- int answer;
- calc_answer (&answer);
- printf ("The answer is %d.\n", answer);
- return 0;
-}
diff --git a/20221010/pointers-04.c b/20221010/pointers-04.c
deleted file mode 100644
index 3bd2e86c08fbe05eb8eb9b42d886e30f8f0be286..0000000000000000000000000000000000000000
--- a/20221010/pointers-04.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-
-void calc_answer (int *a)
-{
- *a = 42;
-}
-
-int main (void)
-{
- int answer;
- calc_answer (&answer);
- printf ("The answer is %d.\n", answer);
- return 0;
-}
diff --git a/20221010/pointers-05.c b/20221010/pointers-05.c
deleted file mode 100644
index 8ed7f9367ad4757f48f81193e41b12b6b730b69a..0000000000000000000000000000000000000000
--- a/20221010/pointers-05.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int answer = 42;
- int *a = &answer;
- int *b = a;
- *b = 137;
- printf ("The answer is %d.\n", answer);
- return 0;
-}
diff --git a/20221010/pointers-06.c b/20221010/pointers-06.c
deleted file mode 100644
index bdd6a1fd48cdfbb41f418a038e87c9cc600613e7..0000000000000000000000000000000000000000
--- a/20221010/pointers-06.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-void calc_answers (int *a, int *b)
-{
- *a = 42;
- *b = 127;
-}
-
-int main (void)
-{
- int answer;
- calc_answers (&answer, &answer);
- printf ("The answer is %d.\n", answer);
- return 0;
-}
diff --git a/20221010/strings-01.c b/20221010/strings-01.c
deleted file mode 100644
index 81bc3cda8affb6268786ac989dd2907d9a84783a..0000000000000000000000000000000000000000
--- a/20221010/strings-01.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char hello[] = "Hello, world!\n";
- for (char *p = hello; *p; p++)
- printf ("%d", *p);
- return 0;
-}
diff --git a/20221010/strings-02.c b/20221010/strings-02.c
deleted file mode 100644
index 0e62e1e346091fab3da99c27973f54552eca2b5e..0000000000000000000000000000000000000000
--- a/20221010/strings-02.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char hello[] = "Hello, world!\n";
- for (char *p = hello; *p; p++)
- printf ("%x", *p);
- return 0;
-}
diff --git a/20221010/strings-03.c b/20221010/strings-03.c
deleted file mode 100644
index ca99a886dc567e2ec28391d6284697298f996fd9..0000000000000000000000000000000000000000
--- a/20221010/strings-03.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char hello[] = "Hello, world!\n";
- for (char *p = hello; *p; p++)
- printf ("%02x", *p);
- return 0;
-}
diff --git a/20221010/strings-04.c b/20221010/strings-04.c
deleted file mode 100644
index 4df32974a15ef2752512cc8b9889381b5a0917cd..0000000000000000000000000000000000000000
--- a/20221010/strings-04.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char hello[] = "Hello, world!\n";
- for (char *p = hello; *p; p++)
- printf ("%c", *p);
- return 0;
-}
diff --git a/20221010/strings-05.c b/20221010/strings-05.c
deleted file mode 100644
index 5c36db92dac8129b66d1f0ff6b709534b9e1bdb3..0000000000000000000000000000000000000000
--- a/20221010/strings-05.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char hello[] = { 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 10, 0 };
- for (char *p = hello; *p; p++)
- printf ("%c", *p);
- return 0;
-}
diff --git a/20221010/strings-06.c b/20221010/strings-06.c
deleted file mode 100644
index efd6ac33660fc6ae2a53077739760e0e59fbc768..0000000000000000000000000000000000000000
--- a/20221010/strings-06.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char hello[] = "Hell0, w0rld!\n";
- for (char *p = hello; *p; p++)
- printf ("%c", *p);
- return 0;
-}
diff --git a/20221010/strings-07.c b/20221010/strings-07.c
deleted file mode 100644
index 5c76dfd93c25c3241db4e12cd18738e0c11cd258..0000000000000000000000000000000000000000
--- a/20221010/strings-07.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char hello[] = "Hell0, w0rld!\n";
- for (char *p = hello; *p; p++)
- printf ("%d ", *p);
- return 0;
-}
diff --git a/20221010/strings-08.c b/20221010/strings-08.c
deleted file mode 100644
index fefbc1e4bc1e73c3160f4d6a8cfa438d26a04fbf..0000000000000000000000000000000000000000
--- a/20221010/strings-08.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char hello[] = { 72, 101, 49, 49, 48, 44, 32, 119, 48, 114, 49, 100, 33, 10, 0 };
- for (char *p = hello; *p; p++)
- printf ("%c", *p);
- return 0;
-}
diff --git a/20221010/strings-09.c b/20221010/strings-09.c
deleted file mode 100644
index 809ffebea4c1421100dcef5ce5e055fb2fe5e62f..0000000000000000000000000000000000000000
--- a/20221010/strings-09.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Die Antwort lautet: %d.\n", '*');
- return 0;
-}
diff --git a/20221010/strings-10.c b/20221010/strings-10.c
deleted file mode 100644
index 72b828a90ee844229d0c6d07c8fe59d7ce8dd7a5..0000000000000000000000000000000000000000
--- a/20221010/strings-10.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Die Antwort lautet: %d.\n", ' ' + 10);
- return 0;
-}
diff --git a/20221010/strings-11.c b/20221010/strings-11.c
deleted file mode 100644
index 10f1cf13094d8c5c1bc7cb362bc8c3d9140dbfb4..0000000000000000000000000000000000000000
--- a/20221010/strings-11.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char x = '4';
- if (x >= 48 && x <= 57)
- printf ("%c ist eine Ziffer.\n", x);
- else
- printf ("%c ist keine Ziffer.\n", x);
- return 0;
-}
diff --git a/20221010/strings-12.c b/20221010/strings-12.c
deleted file mode 100644
index 75dd7d07f6aa64bd87763935984ea18e8e407551..0000000000000000000000000000000000000000
--- a/20221010/strings-12.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char x = '4';
- if (x >= '0' && x <= '9')
- printf ("%c ist eine Ziffer.\n", x);
- else
- printf ("%c ist keine Ziffer.\n", x);
- return 0;
-}
diff --git a/20221010/strings-13.c b/20221010/strings-13.c
deleted file mode 100644
index 073b57dbc6415f165428369df3f6ef04e356308a..0000000000000000000000000000000000000000
--- a/20221010/strings-13.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char x = 'ä';
- if (x >= '0' && x <= '9')
- printf ("%c ist eine Ziffer.\n", x);
- else
- printf ("%c ist keine Ziffer.\n", x);
- return 0;
-}
diff --git a/20221010/strings-14.c b/20221010/strings-14.c
deleted file mode 100644
index d627a0f382f711a82f499ba4d1637be397a6709b..0000000000000000000000000000000000000000
--- a/20221010/strings-14.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char x = 'ä';
- if (x >= '0' && x <= '9')
- printf ("%02x ist eine Ziffer.\n", x);
- else
- printf ("%02x ist keine Ziffer.\n", x);
- return 0;
-}
diff --git a/20221010/strings-15.c b/20221010/strings-15.c
deleted file mode 100644
index 30fb1f10d5df083f9b623d36ae600fff6e3b624a..0000000000000000000000000000000000000000
--- a/20221010/strings-15.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char x = 'ä';
- if (x >= '0' && x <= '9')
- printf ("%02x wäre eine Ziffer.\n", x);
- else
- printf ("%02x wäre keine Ziffer.\n", x);
- return 0;
-}
diff --git a/20221010/strings-16.c b/20221010/strings-16.c
deleted file mode 100644
index 674b096c8abb968c5de1057233bda9cd3710dc25..0000000000000000000000000000000000000000
--- a/20221010/strings-16.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char hello[] = "ä";
- for (char *p = hello; *p; p++)
- printf ("%02hhx", *p);
- printf ("\n");
- return 0;
-}
diff --git a/20221010/strings-17.c b/20221010/strings-17.c
deleted file mode 100644
index 952681bf1c382c1e69e44db29aa175f2445aa5b4..0000000000000000000000000000000000000000
--- a/20221010/strings-17.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char hello[] = "ä";
- for (char *p = hello; *p; p++)
- printf ("%hhd ", *p);
- printf ("\n");
- return 0;
-}
diff --git a/20221010/strings-18.c b/20221010/strings-18.c
deleted file mode 100644
index 2f651cea98a0010fe2fff3937d150ad25d69eb1c..0000000000000000000000000000000000000000
--- a/20221010/strings-18.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char hello[] = "ä";
- for (char *p = hello; *p; p++)
- printf ("%hhu ", *p);
- printf ("\n");
- return 0;
-}
diff --git a/20221010/strings-19.c b/20221010/strings-19.c
deleted file mode 100644
index ad8a7aa046e5ae2a635ab2548b967efbccc3e0d1..0000000000000000000000000000000000000000
--- a/20221010/strings-19.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char hello[] = "HELLO";
- for (char *p = hello; *p; p++)
- printf ("%c", *p - 'A' + 'a');
- printf ("\n");
- return 0;
-}
diff --git a/20221017/aufgabe-3.c b/20221017/aufgabe-3.c
deleted file mode 100644
index ad9d80416bad5c7c0edf9c9d4f175146c92a2755..0000000000000000000000000000000000000000
--- a/20221017/aufgabe-3.c
+++ /dev/null
@@ -1,8 +0,0 @@
-int fun_1 (char *s1, char *s2)
-{
- int result = 1;
- for (int i = 0; s1[i] && s2[i]; i++)
- if (s1[i] != s2[i])
- result = 0;
- return result;
-}
diff --git a/20221017/aufgabe-4.c b/20221017/aufgabe-4.c
deleted file mode 100644
index dc58b6e8ee4a7a023654aa0eb3a9715a5b9f75cf..0000000000000000000000000000000000000000
--- a/20221017/aufgabe-4.c
+++ /dev/null
@@ -1 +0,0 @@
-char*f="char*f=%c%s%c;main(){printf(f,34,f,34,10);}%c";main(){printf(f,34,f,34,10);}
diff --git a/20221017/ausgabe.txt b/20221017/ausgabe.txt
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/20221017/fhello.txt b/20221017/fhello.txt
deleted file mode 100644
index 95e75d98dbaf42c1efc9be0405e079f97aa24888..0000000000000000000000000000000000000000
--- a/20221017/fhello.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-Hello, world!
-Hello, world!
diff --git a/20221017/files-01.c b/20221017/files-01.c
deleted file mode 100644
index 6548d9c81c73a7f3da8b1b2e62290bc8029d11f0..0000000000000000000000000000000000000000
--- a/20221017/files-01.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- FILE *f = fopen ("fhello.txt", "w");
- fprintf (f, "Hello, world!\n");
- fclose (f);
- return 0;
-}
diff --git a/20221017/files-02.c b/20221017/files-02.c
deleted file mode 100644
index 988cb71488e7b9c32771cf8c9305e9ca3b142faa..0000000000000000000000000000000000000000
--- a/20221017/files-02.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- FILE *f = fopen ("fhello.txt", "a");
- fprintf (f, "Hello, world!\n");
- fclose (f);
- return 0;
-}
diff --git a/20221017/files-03.c b/20221017/files-03.c
deleted file mode 100644
index a65c5c766b07f09ea4b002fd28369e51271b2fca..0000000000000000000000000000000000000000
--- a/20221017/files-03.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- FILE *f = fopen ("bla/blubb", "w");
- fprintf (f, "Hello, world!\n");
- fclose (f);
- return 0;
-}
diff --git a/20221017/files-04.c b/20221017/files-04.c
deleted file mode 100644
index d6fea32f7c9d53e85813ef51a306411c8ce8adf4..0000000000000000000000000000000000000000
--- a/20221017/files-04.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- FILE *f = fopen ("bla/blubb", "w");
- if (f)
- {
- fprintf (f, "Hello, world!\n");
- fclose (f);
- }
- return 0;
-}
diff --git a/20221017/files-05.c b/20221017/files-05.c
deleted file mode 100644
index 4367f987813c0fb4780867123f788c54fa1c0775..0000000000000000000000000000000000000000
--- a/20221017/files-05.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- FILE *f = fopen ("bla/blubb", "w");
- if (f)
- {
- fprintf (f, "Hello, world!\n");
- fclose (f);
- }
- else
- fprintf (stderr, "Konnte Datei nicht öffnen. :-(\n");
- return 0;
-}
diff --git a/20221017/files-06.c b/20221017/files-06.c
deleted file mode 100644
index 41e67d4d4e5718e6712286ea87480d105c00112c..0000000000000000000000000000000000000000
--- a/20221017/files-06.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-#include <errno.h>
-
-int main (void)
-{
- FILE *f = fopen ("bla/blubb", "w");
- if (f)
- {
- fprintf (f, "Hello, world!\n");
- fclose (f);
- }
- else
- fprintf (stderr, "Konnte Datei nicht öffnen. :-( Grund: %d\n", errno);
- return 0;
-}
diff --git a/20221017/files-07.c b/20221017/files-07.c
deleted file mode 100644
index 67f97d6d1a990a0e6e8423caddd23bdb5b60dc24..0000000000000000000000000000000000000000
--- a/20221017/files-07.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-#include <errno.h>
-
-int main (void)
-{
- FILE *f = fopen ("/fhello.txt", "w");
- if (f)
- {
- fprintf (f, "Hello, world!\n");
- fclose (f);
- }
- else
- fprintf (stderr, "Konnte Datei nicht öffnen. :-( Grund: %d\n", errno);
- return 0;
-}
diff --git a/20221017/files-08.c b/20221017/files-08.c
deleted file mode 100644
index 18a331edff6b4e8d8e40362ac9365bdd763cad40..0000000000000000000000000000000000000000
--- a/20221017/files-08.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-#include <errno.h>
-#include <string.h>
-
-int main (void)
-{
- FILE *f = fopen ("/fhello.txt", "w");
- if (f)
- {
- fprintf (f, "Hello, world!\n");
- fclose (f);
- }
- else
- {
- char *msg = strerror (errno);
- fprintf (stderr, "Konnte Datei nicht öffnen. :-( Grund: %s\n", msg);
- }
- return 0;
-}
diff --git a/20221017/files-09.c b/20221017/files-09.c
deleted file mode 100644
index 1ab0b5e4e22cbfee74af0e7d3bd0a2854e8de925..0000000000000000000000000000000000000000
--- a/20221017/files-09.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-#include <errno.h>
-#include <string.h>
-
-int main (void)
-{
- FILE *f = fopen ("bla/blubb", "w");
- if (f)
- {
- fprintf (f, "Hello, world!\n");
- fclose (f);
- }
- else
- {
- char *msg = strerror (errno);
- fprintf (stderr, "Konnte Datei nicht öffnen. :-( Grund: %s\n", msg);
- }
- return 0;
-}
diff --git a/20221017/files-10.c b/20221017/files-10.c
deleted file mode 100644
index 0e718a693947d403329586fc86bca4c043abf7d2..0000000000000000000000000000000000000000
--- a/20221017/files-10.c
+++ /dev/null
@@ -1,20 +0,0 @@
-#include <stdio.h>
-#include <errno.h>
-#include <string.h>
-
-int main (void)
-{
- FILE *f = fopen ("bla/blubb", "w");
- if (f)
- {
- fprintf (f, "Hello, world!\n");
- fclose (f);
- }
- else
- {
- char *msg = strerror (errno);
- fprintf (stderr, "Konnte Datei nicht öffnen. :-( Grund: %s\n", msg);
- return 1;
- }
- return 0;
-}
diff --git a/20221017/files-11.c b/20221017/files-11.c
deleted file mode 100644
index ce0cbb5c900ba6fbc0b179301ae63e74a183eae7..0000000000000000000000000000000000000000
--- a/20221017/files-11.c
+++ /dev/null
@@ -1,20 +0,0 @@
-#include <stdio.h>
-#include <errno.h>
-#include <string.h>
-
-int main (void)
-{
- FILE *f = fopen ("bla/blubb", "w");
- if (f)
- {
- fprintf (f, "Hello, world!\n");
- fclose (f);
- }
- else
- {
- char *msg = strerror (errno);
- fprintf (stderr, "Konnte Datei nicht öffnen. :-( Grund: %s\n", msg);
- return errno;
- }
- return 0;
-}
diff --git a/20221017/files-12.c b/20221017/files-12.c
deleted file mode 100644
index 47a8e4035b9eb9303ed5eda50546a4cc49476c37..0000000000000000000000000000000000000000
--- a/20221017/files-12.c
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <stdio.h>
-#include <errno.h>
-#include <string.h>
-#include <stdlib.h>
-
-int main (void)
-{
- FILE *f = fopen ("bla/blubb", "w");
- if (f)
- {
- fprintf (f, "Hello, world!\n");
- fclose (f);
- }
- else
- {
- char *msg = strerror (errno);
- fprintf (stderr, "Konnte Datei nicht öffnen. :-( Grund: %s\n", msg);
- exit (errno);
- }
- return 0;
-}
diff --git a/20221017/files-13.c b/20221017/files-13.c
deleted file mode 100644
index 62ae60e998a6a4af74a1d858ee4153e8b2b0486a..0000000000000000000000000000000000000000
--- a/20221017/files-13.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-#include <errno.h>
-#include <error.h>
-
-int main (void)
-{
- FILE *f = fopen ("bla/blubb", "w");
- if (!f)
- error (errno, errno, "cannot open file");
- fprintf (f, "Hello, world!\n");
- fclose (f);
- return 0;
-}
diff --git a/20221017/files-14.c b/20221017/files-14.c
deleted file mode 100644
index 299b52ac2592b5a829ace1fc5964c114e409d9f9..0000000000000000000000000000000000000000
--- a/20221017/files-14.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-#include <errno.h>
-#include <error.h>
-
-int main (void)
-{
- FILE *f = fopen ("bla/blubb", "w");
- if (!f)
- error (0, errno, "cannot open file");
- fprintf (f, "Hello, world!\n");
- fclose (f);
- return 0;
-}
diff --git a/20221017/hp-20221017.pdf b/20221017/hp-20221017.pdf
deleted file mode 100644
index 48829fe532924d9efcfe41e1c4e7fac1a637383e..0000000000000000000000000000000000000000
Binary files a/20221017/hp-20221017.pdf and /dev/null differ
diff --git a/20221017/hp-20221017.tex b/20221017/hp-20221017.tex
deleted file mode 100644
index 7bd34ca2aeac191847e684b08313cd62e60586ca..0000000000000000000000000000000000000000
--- a/20221017/hp-20221017.tex
+++ /dev/null
@@ -1,1137 +0,0 @@
-% hp-20221017.pdf - Lecture Slides on Low-Level Programming
-% Copyright (C) 2012, 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Strukturen, Dateien und Fehlerbehandlung, Parameter des Hauptprogramms, String-Operationen
-
-\documentclass[10pt,t]{beamer}
-
-\usepackage{pgslides}
-\usepackage{pdftricks}
-\usepackage{tikz}
-
-\begin{psinputs}
- \usepackage[utf8]{inputenc}
- \usepackage[german]{babel}
- \usepackage[T1]{fontenc}
- \usepackage{helvet}
- \renewcommand*\familydefault{\sfdefault}
- \usepackage{pstricks,pst-grad}
-\end{psinputs}
-
-\newcommand{\redurl}[1]{\href{#1}{\color{red}\nolinkurl{#1}}}
-
-\title{Hardwarenahe Programmierung}
-\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
-\date{17.\ Oktober 2022}
-
-\begin{document}
-
-\maketitleframe
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \begin{itemize}
- \item[2.1] Hello, world!
- \item[2.2] Programme compilieren und ausführen
- \item[2.3] Elementare Aus- und Eingabe
- \item[2.4] Elementares Rechnen
- \item[2.5] Verzweigungen
- \item[2.6] Schleifen
- \item[2.7] Strukturierte Programmierung
- \item[2.8] Seiteneffekte
- \color{medgreen}
- \item[2.9] Funktionen
- \item[2.10] Zeiger
- \item[2.11] Arrays und Strings
- \color{red}
- \item[2.12] Strukturen
- \item[\dots]
- \end{itemize}
- \color{gray}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \vspace*{-\smallskipamount}
- \item[\textbf{\dots}]
-% \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
-% \item[\textbf{5}] \textbf{Algorithmen}
-% \item[\textbf{6}] \textbf{Ergänzungen und Ausblicke}
- \end{itemize}
-
-\end{frame}
-
-\setcounter{section}{1}
-\section{Einführung in C}
-\setcounter{subsection}{8}
-\subsection{Funktionen}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{minipage}[t]{6.5cm}
- \vspace{-\medskipamount}
- \begin{lstlisting}[gobble=6]
- ¡#include <stdio.h>
-
- int answer (void)
- {
- return 42;
- }
-
- void foo (void)
- {
- printf ("%d\n", answer ());
- }
-
- int main (void)
- {
- foo ();
- return 0;
- }¿
- \end{lstlisting}
- \vspace*{-1cm}
- \end{minipage}%
- \begin{minipage}[t]{6cm}
- \begin{itemize}
- \pause
- \item
- Funktionsdeklaration:\\[\smallskipamount]
- Typ Name ( Parameterliste )\\
- \{\\
- \quad Anweisungen\\
- \}
- \end{itemize}
- \end{minipage}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{minipage}[t]{6.5cm}
- \vspace{-\medskipamount}
- \begin{lstlisting}[gobble=6]
- ¡#include <stdio.h>
-
- void add_verbose (int a, int b)
- {
- printf ("%d + %d = %d\n", a, b, a + b);
- }
-
- int main (void)
- {
- add_verbose (3, 7);
- return 0;
- }¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{6cm}
- \begin{itemize}
- \item
- Funktionsdeklaration:\\[\smallskipamount]
- Typ Name ( Parameterliste )\\
- \{\\
- \quad Anweisungen\\
- \}
- \pause
- \bigskip
- \item
- Der Datentyp \lstinline{void}\\
- steht für "`nichts"'\\
- und \alt<3->{muß}{kann} ignoriert werden.
- \end{itemize}
- \end{minipage}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{minipage}{6cm}
- \begin{lstlisting}[gobble=6]
- ¡#include <stdio.h>
-
- int a, b = 3;
-
- void foo (void)
- {
- b++;
- static int a = 5;
- int b = 7;
- printf ("foo(): "
- "a = %d, b = %d\n",
- a, b);
- a++;
- }¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}{6cm}
- \vspace{-1cm}
- \begin{lstlisting}[gobble=6]
- ¡int main (void)
- {
- printf ("main(): "
- "a = %d, b = %d\n",
- a, b);
- foo ();
- printf ("main(): "
- "a = %d, b = %d\n",
- a, b);
- a = b = 12;
- printf ("main(): "
- "a = %d, b = %d\n",
- a, b);
- foo ();
- printf ("main(): "
- "a = %d, b = %d\n",
- a, b);
- return 0;
- }¿
- \end{lstlisting}
- \end{minipage}
-
-\end{frame}
-
-\subsection{Zeiger}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{lstlisting}
- #include <stdio.h>
-
- void calc_answer (int *a)
- {
- *a = 42;
- }
-
- int main (void)
- {
- int answer;
- calc_answer (&answer);
- printf ("The answer is %d.\n", answer);
- return 0;
- }
- \end{lstlisting}
-
-% \pause
- \vspace{-5cm}\hspace{5cm}%
- \begin{minipage}{7cm}
- \begin{itemize}
- \item
- \lstinline{*a} ist eine \lstinline{int}.
-% \pause
- \item
- unärer Operator \lstinline{*}:\\
- Pointer-Dererefenzierung
-% \pause
- \arrowitem
- \lstinline{a} ist ein Zeiger (Pointer) auf eine \lstinline{int}.
-% \pause
- \bigskip
- \item
- unärer Operator \lstinline{&}: Adresse
- \end{itemize}
- \end{minipage}
-\end{frame}
-
-\subsection{Arrays und Strings}
-
-\begin{frame}[fragile]
- \showsubsection
-
- Ein Zeiger zeigt auf eine Variable\only<1->{ und deren Nachbarn}.
-
-% \bigskip
-% \pause
-% \pause
-
- \begin{onlyenv}<1>
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- int prime[5] = { 2, 3, 5, 7, 11 };
- int *p = prime;
- for (int i = 0; i < 5; i++)
- printf ("%d\n", *(p + i));
- return 0;
- }
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<2>
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- int prime[5] = { 2, 3, 5, 7, 11 };
- int *p = prime;
- for (int i = 0; i < 5; i++)
- printf ("%d\n", p[i]);
- return 0;
- }
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<3>
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- int prime[5] = { 2, 3, 5, 7, 11 };
- for (int i = 0; i < 5; i++)
- printf ("%d\n", prime[i]);
- return 0;
- }
- ¡ ¿
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<4>
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- int prime[5] = { 2, 3, 5, 7, 11 };
- for (int *p = prime;
- p < prime + 5; p++)
- printf ("%d\n", *p);
- return 0;
- }
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<5>
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- int prime[6] = { 2, 3, 5, 7, 11, 0 };
- for (int *p = prime; *p; p++)
- printf ("%d\n", *p);
- return 0;
- }
- ¡ ¿
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<6->
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- int prime[] = { 2, 3, 5, 7, 11, 0 };
- for (int *p = prime; *p; p++)
- printf ("%d\n", *p);
- return 0;
- }
- ¡ ¿
- \end{lstlisting}
- \end{onlyenv}
-
-% \pause
- \vspace{-3.05cm}\hspace{5.5cm}%
- \begin{minipage}{6.5cm}
- \begin{itemize}
- \item
- \lstinline{prime} ist \alt<1->{ein Array}{eine Ansammlung} von\\fünf ganzen Zahlen.
-% \pause
-% \pause
- \item
- \only<1>{\begin{picture}(0,0)
- \color{red}
- \put(-1.6,0.1){\tikz{\draw[-latex](0.0,0.0)--(-1,0);}}
- \end{picture}}%
- \lstinline{prime} ist ein Zeiger auf eine \lstinline{int}.
-% \pause
- \item
- \lstinline{p + i} ist ein Zeiger\\
- auf den \lstinline{i}-ten Nachbarn von \lstinline{*p}.
-% \pause
- \item
- \lstinline{*(p + i)} ist der \lstinline{i}-te Nachbar von \lstinline{*p}.
- \pause
- \item
- Andere Schreibweise:\\
- \lstinline{p[i]} statt \lstinline{*(p + i)}
- \pause
- \pause
- \item
- Zeiger-Arithmetik:\\
- \lstinline{p++} rückt den Zeiger \lstinline{p}\\
- um eine \lstinline{int} weiter.
- \pause
- \pause
- \item
- Array ohne \only<1->{explizite }Längenangabe:\\
- Compiler zählt selbst
- \vspace*{-1cm}
-% \pause
- \begin{picture}(0,0)
- \put(-5.2,1.0){\makebox(0,0)[br]{\color{red}\bf\shortstack{Die Länge des Arrays\\ist \emph{nicht\/} veränderlich!}}}
- \end{picture}
- \end{itemize}
- \end{minipage}
-\end{frame}
-
-% \begin{frame}[fragile]
-% \showsubsection
-%
-% \begin{lstlisting}
-% #include <stdio.h>
-%
-% int main (void)
-% {
-% char hello_world[] = "Hello, world!\n";
-% int i = 0;
-% while (hello_world[i] != 0)
-% printf ("%d", hello_world[i++]);
-% return 0;
-% }
-% \end{lstlisting}
-% \end{frame}
-
-% \begin{frame}[fragile]
-% \showsubsection
-%
-% \begin{lstlisting}
-% #include <stdio.h>
-%
-% int main (void)
-% {
-% char hello_world[] = "Hello, world!\n";
-% int i = 0;
-% while (hello_world[i])
-% printf ("%d", hello_world[i++]);
-% return 0;
-% }
-% \end{lstlisting}
-% \end{frame}
-
-% \begin{frame}[fragile]
-% \showsubsection
-%
-% \begin{lstlisting}
-% #include <stdio.h>
-%
-% int main (void)
-% {
-% char hello_world[] = "Hello, world!\n";
-% char *p = hello_world;
-% while (*p)
-% printf ("%c", *p++);
-% return 0;
-% }
-% \end{lstlisting}
-% \end{frame}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{onlyenv}<1>
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- char hello[] = "Hello, world!\n";
- for (char *p = hello; *p; p++)
- printf ("%d", *p);
- return 0;
- }
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<2>
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- char hello[] = "Hello, world!\n";
- for (char *p = hello; *p; p++)
- printf ("%c", *p);
- return 0;
- }
- \end{lstlisting}
- \end{onlyenv}
-% \begin{onlyenv}<8>
-% \begin{lstlisting}[gobble=6]
-% #include <stdio.h>
-%
-% int main (void)
-% {
-% char hello[] = "Hello, world!\n";
-% printf ("%s", hello);
-% return 0;
-% }
-% ¡ ¿
-% \end{lstlisting}
-% \end{onlyenv}
-% \begin{onlyenv}<9>
-% \begin{lstlisting}[gobble=6]
-% #include <stdio.h>
-%
-% int main (void)
-% {
-% char *hello = "Hello, world!\n";
-% printf ("%s", hello);
-% return 0;
-% }
-% ¡ ¿
-% \end{lstlisting}
-% \end{onlyenv}
-% \begin{onlyenv}<10>
-% \begin{lstlisting}[gobble=6]
-% #include <stdio.h>
-%
-% int main (void)
-% {
-% char *hello = "Hello, world!\n";
-% while (*hello)
-% printf ("%c", *hello++);
-% return 0;
-% }
-% \end{lstlisting}
-% \end{onlyenv}
-
- \vspace{-1.7cm}\hfill
- \begin{minipage}{6.8cm}
- \begin{itemize}
-% \pause[2]
- \item
- Ein \lstinline{char} ist eine kleinere \lstinline{int}.
-% \pause
- \item
- Ein "`String"' in C ist ein Array von \lstinline{char}s\only<1->{,\\
- also ein Zeiger auf \lstinline{char}s}\only<1->{\\
- also ein Zeiger auf (kleinere) Integer}.
-% \pause
-% \pause
-% \pause
- \item
- Der letzte \lstinline{char} muß 0 sein.\\
- Er kennzeichnet das Ende des Strings.
-% \pause
- \item
- Die Formatspezifikation\\
- entscheidet über die Ausgabe:\\[\smallskipamount]
- \begin{tabular}{ll}
- \lstinline|%d|\hspace*{0.5em}dezimal
- & \lstinline|%c|\hspace*{0.5em}Zeichen\\
- \lstinline|%x|\hspace*{0.5em}hexadezimal
-% \pause
- & \lstinline|%s|\hspace*{0.5em}{\color{red}String}
- \end{tabular}
- \vspace*{-1cm}
- \end{itemize}
- \end{minipage}
-\end{frame}
-
-\addtocounter{subsection}{-1}
-\subsection{Arrays und Strings \protect\color{gray}und Zeichen}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \emph{"`Alles ist Zahl."'\/} -- Schule der Pythagoreer, 6.\ Jh.\ v.\,Chr.
-
- \medskip
-
- \begin{center}
- \renewcommand{\arraystretch}{1.5}
- \begin{tabular}{r}
- \lstinline|"Hello"|\\
- \lstinline|'H'|\\
- \lstinline|'a' + 4|
- \end{tabular}
- \renewcommand{\arraystretch}{1.0}
- \begin{tabular}{c}
- ist nur eine andere\\
- Schreibweise für
- \end{tabular}
- \renewcommand{\arraystretch}{1.5}
- \begin{tabular}{l}
- \lstinline|{ 72, 101, 108, 108, 111, 0 }|\\
- \lstinline|72|\\
- \lstinline|'e'|
- \end{tabular}
- \renewcommand{\arraystretch}{1.0}
- \end{center}
-
- \begin{itemize}
- \item
- Welchen Zahlenwert hat \lstinline{'*'} im Zeichensatz?
-
- \smallskip
-
- \begin{lstlisting}[gobble=8]
- printf ("%d\n", '*');
- \end{lstlisting}
-
- \smallskip
-
- (normalerweise: ASCII)
- \medskip
- \item
- Ist \lstinline{char ch} ein Großbuchstabe?
-
- \smallskip
-
- \begin{lstlisting}[gobble=8]
- if (ch >= 'A' && ch <= 'Z')
- ...
- \end{lstlisting}
- \medskip
- \item
- Groß- in Kleinbuchstaben umwandeln
-
- \smallskip
-
- \begin{lstlisting}[gobble=8]
- ch += 'a' - 'A';
- \end{lstlisting}
- \end{itemize}
-\end{frame}
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \begin{itemize}
- \vspace*{-\smallskipamount}
- \item[\dots]
- \item[2.5] Verzweigungen
- \item[2.6] Schleifen
- \item[2.7] Strukturierte Programmierung
- \item[2.8] Seiteneffekte
- \color{medgreen}
- \item[2.9] Funktionen
- \item[2.10] Zeiger
- \item[2.11] Arrays und Strings
- \color{red}
- \item[2.12] Strukturen
- \item[2.13] Dateien und Fehlerbehandlung
- \item[2.14] Parameter des Hauptprogramms
- \item[2.15] String-Operationen
- \end{itemize}
- \color{gray}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \vspace*{-\smallskipamount}
- \item[\textbf{\dots}]
-% \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
-% \item[\textbf{5}] \textbf{Algorithmen}
-% \item[\textbf{6}] \textbf{Ergänzungen und Ausblicke}
- \end{itemize}
- \vspace*{-1cm}
-
-\end{frame}
-
-\subsection{Strukturen}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{lstlisting}
- #include <stdio.h>
-
- typedef struct
- {
- char day, month;
- int year;
- }
- date;
-
- int main (void)
- {
- date today = { 17, 10, 2022 };
- printf ("%d.%d.%d\n", today.day, today.month, today.year);
- return 0;
- }
- \end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \vspace*{0.9mm}
- \begin{minipage}[b]{6cm}
- \begin{lstlisting}[gobble=6]
- ¡#include <stdio.h>
-
- typedef struct
- {
- char day, month;
- int year;
- }
- date;
-
- void set_date (date *d)
- {
- (*d).day = 17;
- (*d).month = 10;
- (*d).year = 2022;
- }¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[b]{6cm}
- \begin{lstlisting}[gobble=6]
- ¡int main (void)
- {
- date today;
- set_date (&today);
- printf ("%d.%d.%d\n", today.day,
- today.month, today.year);
- return 0;
- }¿
- \end{lstlisting}
- \end{minipage}
-\end{frame}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \vspace*{0.9mm}
- \begin{minipage}[b]{6cm}
- \begin{lstlisting}[gobble=6]
- ¡#include <stdio.h>
-
- typedef struct
- {
- char day, month;
- int year;
- }
- date;
-
- void set_date (date *d)
- {
- d->day = 17;
- d->month = 10;
- d->year = 2022;
- }¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[b]{6cm}
- \hspace*{-1cm}%
- \lstinline{foo->bar}
- ist Abkürzung für
- \lstinline{(*foo).bar}
-
- \bigskip
-
- \visible<2->{%
- \hspace*{-1cm}%
- Eine Funktion, die mit einem \lstinline{struct} arbeitet,\\
- \hspace*{-1cm}%
- kann man eine \newterm{Methode\/} des \lstinline{struct} nennen.}
-
- \bigskip
- \bigskip
-
- \begin{lstlisting}[gobble=6]
- ¡int main (void)
- {
- date today;
- set_date (&today);
- printf ("%d.%d.%d\n", today.day,
- today.month, today.year);
- return 0;
- }¿
- \end{lstlisting}
- \end{minipage}
-
-\end{frame}
-
-\subsection{Dateien und Fehlerbehandlung}
-
-\begin{frame}[fragile]
- \showsubsection
- \vspace*{-0.2925cm}
- \begin{minipage}[t]{6cm}
- \begin{onlyenv}<1>
- \begin{lstlisting}[gobble=8]
- ¡#include <stdio.h>
-
- int main (void)
- {
- FILE *f = fopen ("fhello.txt", "w");
- fprintf (f, "Hello, world!\n");
- fclose (f);
- return 0;
- }¿
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<2>
- \begin{lstlisting}[gobble=8]
- ¡#include <stdio.h>
-
- int main (void)
- {
- FILE *f = fopen ("fhello.txt", "w");
- if (f)
- {
- fprintf (f, "Hello, world!\n");
- fclose (f);
- }
- return 0;
- }¿
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<3>
- \begin{lstlisting}[gobble=8]
- ¡#include <stdio.h>
- #include <errno.h>
-
- int main (void)
- {
- FILE *f = fopen ("fhello.txt", "w");
- if (f)
- {
- fprintf (f, "Hello, world!\n");
- fclose (f);
- }
- else
- fprintf (stderr, "error #%d\n", errno);
- return 0;
- }¿
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<4>
- \begin{lstlisting}[gobble=8]
- ¡#include <stdio.h>
- #include <errno.h>
- #include <string.h>
-
- int main (void)
- {
- FILE *f = fopen ("fhello.txt", "w");
- if (f)
- {
- fprintf (f, "Hello, world!\n");
- fclose (f);
- }
- else
- {
- char *msg = strerror (errno);
- fprintf (stderr, "%s\n", msg);
- }
- return 0;
- }¿
- \end{lstlisting}
- \vspace*{-1cm}
- \end{onlyenv}
- \begin{onlyenv}<5->
- \begin{lstlisting}[gobble=8]
- ¡#include <stdio.h>
- #include <errno.h>
- #include <er¡ror.h>
-
- int main (void)
- {
- FILE *f = fopen ("fhello.txt", "w");
- if (!f)
- error (errno, errno, "cannot open file");
- fprintf (f, "Hello, world!\n");
- fclose (f);
- return 0;
- }
- \end{lstlisting}
- \end{onlyenv}
- \end{minipage}\pause\hspace*{-1.5cm}%
- \begin{minipage}[t]{8.5cm}
- \bigskip
- \only<3->{\bigskip}
- \begin{itemize}
- \item
- Wenn die Datei nicht geöffnet werden kann,\\
- gibt \lstinline{fopen()} den Wert \lstinline{NULL} zurück.
- \pause
- \medskip
- \item
- \addtolength{\leftskip}{1cm}
- Die globale Variable \lstinline{int errno}\\
- enthält dann die Nummer des Fehlers.\\
- Benötigt: \lstinline{#include <errno.h>}
- \pause
- \medskip
- \only<5->{\bigskip}
- \item
- Die Funktion \lstinline{strerror()} wandelt \lstinline{errno}\\
- in einen Fehlermeldungstext um.\\
- Benötigt: \lstinline{#include <string.h>}
- \pause
- \medskip
- \item
- \addtolength{\leftskip}{-1.5cm}
- Die Funktion \lstinline{error()} gibt eine Fehlermeldung aus\\
- und beendet das Programm.\\
- Benötigt: \lstinline{#include <er¡¿ror.h>}
- \pause
- \medskip
- \item
- \textbf{Niemals Fehler einfach ignorieren!}
- \end{itemize}
- \addtolength{\leftskip}{0.5cm}
- \end{minipage}
-\end{frame}
-
-\subsection{Parameter des Hauptprogramms}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{lstlisting}
- #include <stdio.h>
-
- int main (int argc, char **argv)
- {
- printf ("argc = %d\n", argc);
- for (int i = 0; i < argc; i++)
- printf ("argv[%d] = \"%s\"\n", i, argv[i]);
- return 0;
- }
- \end{lstlisting}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{lstlisting}
- #include <stdio.h>
-
- int main (int argc, char **argv)
- {
- printf ("argc = %d\n", argc);
- for (int i = 0; *argv; i++, argv++)
- printf ("argv[%d] = \"%s\"\n", i, *argv);
- return 0;
- }
- \end{lstlisting}
-
-\end{frame}
-
-\subsection{String-Operationen}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \vspace*{-0.4cm}
- \begin{lstlisting}
- #include <stdio.h>
- #include <string.h>
-
- int main (void)
- {
- char hello[] = "Hello, world!\n";
-
- printf ("%s\n", hello);
- printf ("%zd\n", strlen (hello));
-
- printf ("%s\n", hello + 7);
- printf ("%zd\n", strlen (hello + 7));
-
- hello[5] = 0;
- printf ("%s\n", hello);
- printf ("%zd\n", strlen (hello));
-
- return 0;
- }
- \end{lstlisting}
- \vspace*{-1cm}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \vspace*{-0.4cm}
- \begin{lstlisting}
- #include <stdio.h>
- #include <string.h>
-
- int main (void)
- {
- char *anton = "Anton";
- char *zacharias = "Zacharias";
-
- printf ("%d\n", strcmp (anton, zacharias));
- printf ("%d\n", strcmp (zacharias, anton));
- printf ("%d\n", strcmp (anton, anton));
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-
- return 0;
- }
- \end{lstlisting}
- \vspace*{-1cm}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \vspace*{-0.4cm}
- \begin{lstlisting}
- #include <stdio.h>
- #include <string.h>
-
- int main (void)
- {
- char buffer[100] = "";
- sprintf (buffer, "Die Antwort lautet: %d", 42);
- printf ("%s\n", buffer);
-
- char *answer = strstr (buffer, "Antwort");
- printf ("%s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- return 0;
- }
- \end{lstlisting}
- \vspace*{-1cm}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \vspace*{-0.4cm}
- \begin{lstlisting}
- #include <stdio.h>
- #include <string.h>
-
- int main (void)
- {
- char buffer[100] = "";
- snprintf (buffer, 100, "Die Antwort lautet: %d", 42);
- printf ("%s\n", buffer);
-
- char *answer = strstr (buffer, "Antwort");
- printf ("%s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- return 0;
- }
- \end{lstlisting}
-
-\end{frame}
-
-\iffalse
-
-\begin{frame}
-
- \showsection
-
- Sprachelemente weitgehend komplett
-
- \bigskip
- Es fehlen:
- \begin{itemize}
- \item
- Ergänzungen (z.\,B.\ ternärer Operator, \lstinline{union}, \lstinline{unsigned}, \lstinline{volatile})
- \item
- Bibliotheksfunktionen (z.\,B.\ \lstinline{malloc()})
- \arrowitem
- werden eingeführt, wenn wir sie brauchen
- \bigskip
- \item
- Konzepte (z.\,B.\ rekursive Datenstrukturen, Klassen selbst bauen)
- \arrowitem
- werden eingeführt, wenn wir sie brauchen, oder:
- \arrowitem
- Literatur\\[\smallskipamount]
- (z.\,B.\ Wikibooks: C-Programmierung,\\
- Dokumentation zu Compiler und Bibliotheken)
- \bigskip
- \item
- Praxiserfahrung
- \arrowitem
- Übung und Praktikum: nur Einstieg
- \arrowitem
- selbständig arbeiten
- \end{itemize}
-\end{frame}
-
-\fi
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \begin{itemize}
- \vspace*{-\smallskipamount}
- \item[\dots]
- \item[2.5] Verzweigungen
- \item[2.6] Schleifen
- \item[2.7] Strukturierte Programmierung
- \item[2.8] Seiteneffekte
- \item[2.9] Funktionen
- \item[2.10] Zeiger
- \item[2.11] Arrays und Strings
- \color{medgreen}
- \item[2.12] Strukturen
- \item[2.13] Dateien und Fehlerbehandlung
- \item[2.14] Parameter des Hauptprogramms
- \item[2.15] String-Operationen
- \end{itemize}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \vspace*{-\smallskipamount}
- \item[\textbf{\dots}]
-% \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
-% \item[\textbf{5}] \textbf{Algorithmen}
-% \item[\textbf{6}] \textbf{Ergänzungen und Ausblicke}
- \end{itemize}
-
-\end{frame}
-
-\end{document}
diff --git a/20221017/hp-musterloesung-20221017.pdf b/20221017/hp-musterloesung-20221017.pdf
deleted file mode 100644
index 682b51a374a737deb4eef50681b0740524e3a6a4..0000000000000000000000000000000000000000
Binary files a/20221017/hp-musterloesung-20221017.pdf and /dev/null differ
diff --git a/20221017/hp-musterloesung-20221017.tex b/20221017/hp-musterloesung-20221017.tex
deleted file mode 100644
index 0069168a76a638d0ccf4e799e26668a16d9136db..0000000000000000000000000000000000000000
--- a/20221017/hp-musterloesung-20221017.tex
+++ /dev/null
@@ -1,523 +0,0 @@
-% hp-musterloesung-20221017.pdf - Solutions to the Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Seltsame Programme, Kalender-Berechnung, Strings, Programm analysieren
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-\renewcommand{\breath}{\bigskip}
-
-\begin{document}
-
- \section*{Hardwarenahe Programmierung\\
- Musterlösung zu den Übungsaufgaben -- 17.\ Oktober 2022}
-
- \exercise{Seltsame Programme}
-
- Unter \url{https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/20221017}
- finden Sie (unter anderem)\\
- die Programme \gitfile{hp}{2022ws/20221017}{test-1.c},
- \gitfile{hp}{2022ws/20221017}{test-2.c} und \gitfile{hp}{2022ws/20221017}{test-3.c}.
-
- Was bewirken diese Programme, und warum verhalten sie sich so?
-
- \solution
-
- \begin{itemize}
- \item
- \gitfile{hp}{2022ws/20221017}{test-1.c}
-
- Hinter \lstinline{return} steht ein Ausdruck mit dem
- Komma-Operator. Dieser bewirkt, daß der Wert vor dem Komma
- berechnet und ignoriert und danach der Wert nach dem Komma
- zurückgegeben wird.
-
- In diesem Fall wird vor dem Komma der Wert des
- \lstinline{printf()}-Aufrufs berechnet und ignoriert.
- Als Seiteneffekt gibt das Programm die Zeile
- \lstinline[style=terminal]{Hello, world!} aus.
- Anschließend wird der Wert \lstinline{0} an \lstinline{return}
- übergeben und daher \lstinline{return 0} ausgeführt.
-
- \item
- \gitfile{hp}{2022ws/20221017}{test-2.c}
-
- Das Programm gibt die Zeile
- \lstinline[style=terminal]{Die Antwort lautet: 42} aus.
-
- Die \lstinline{if}-Bedingung ist eine Zuweisung \lstinline{b = 42},
- die den zugewiesenen Wert \lstinline{42} zurückgibt.
- Weil dieser Wert ungleich Null ist, interpretiert
- \lstinline{if} ihn als Wahrheitswert "`wahr"', führt also den
- \lstinline{if}-Zweig aus und überspringt den
- \lstinline{else}-Zweig.
-
- \item
- \gitfile{hp}{2022ws/20221017}{test-3.c}
-
- Das Programm stürzt mit einer Fehlermeldung
- "`Speicherzugriffsfehler"' oder "`Schutzverletzung"' ab.
-
- Der Funktionsaufruf \lstinline{printf (42)} übergibt den
- Zahlenwert \lstinline{42} als String, also als einen Zeiger
- auf \lstinline{char}-Variable, an die Funktion
- \lstinline{printf()}. Diese versucht, auf den Speicher ab
- Adresse 42 zuzugreifen, wofür aber das Programm keine
- Zugriffsrechte hat. Das Betriebssystem beendet daraufhin das
- Programm mit der o.\,a.\ Fehlermeldung.
-
- Der String \lstinline{"Die Antwort lautet: "} wird nicht
- ausgegeben, weil Schreiboperationen aus Effizienzgründen
- erst nach einer abgeschlossenen Zeile (\lstinline{"\n"})
- durchgeführt werden.
- \end{itemize}
-
- \clearpage
-
- \exercise{Kalender-Berechnung}
-
- Am 3.\,1.\,2009 meldete \emph{heise online\/}:
- \begin{quote}
- Kunden des ersten mobilen Media-Players von Microsoft
- erlebten zum Jahresende eine böse Überraschung:
- Am 31.\ Dezember 2008 fielen weltweit alle Zune-Geräte der ersten Generation aus.
- Ursache war ein interner Fehler bei der Handhabung von Schaltjahren.
-
- \strut\hfill\url{http://heise.de/-193332},
- \end{quote}
- Der Artikel verweist auf ein Quelltextfragment (Datei: \gitfile{hp}{2022ws/20221017}{aufgabe-2.c}),
- das für einen gegebenen Wert \lstinline{days}
- das Jahr und den Tag innerhalb des Jahres
- für den \lstinline{days}-ten Tag nach dem 1.\,1.\,1980 berechnen soll:
- \begin{lstlisting}
- year = ORIGINYEAR; /* = 1980 */
-
- while (days > 365)
- {
- if (IsLeapYear (year))
- {
- if (days > 366)
- {
- days -= 366;
- year += 1;
- }
- }
- else
- {
- days -= 365;
- year += 1;
- }
- }
- \end{lstlisting}
- Dieses Quelltextfragment enthält schlechten Programmierstil,
- nämlich mehrere Code-Verdopplungen:
- \begin{itemize}
- \item
- Die Anweisung \lstinline{year += 1} taucht an zwei Stellen auf.
- \item
- Es gibt zwei unabhängige Abfragen \lstinline{days > 365} und \lstinline{days > 366}:\\
- eine in einer \lstinline{while}- und die andere in einer \lstinline{if}-Bedingung.
- \item
- Die Länge eines Jahres wird nicht durch eine Funktion berechnet oder in einer Variablen gespeichert;
- stattdessen werden an mehreren Stellen die expliziten numerischen Konstanten 365 und 366 verwendet.
- \end{itemize}
- Diese Probleme führten am 31.\ Dezember 2008 zu einer Endlosschleife.
-
- Gut hingegen ist die Verwendung einer Konstanten \lstinline{ORIGINYEAR}
- anstelle der Zahl 1980
- sowie die Kapselung der Berechnung der Schaltjahr-Bedingung
- in einer Funktion \lstinline{IsLeapYear()}.
-
- \begin{itemize}
- \item[(a)]
- Erklären Sie das Zustandekommen der Endlosschleife.
- \item[(b)]
- Schreiben Sie das Quelltextfragment so um, daß es die beschriebenen Probleme
- nicht mehr enthält.
- \end{itemize}
-
- \textbf{Hinweis 1:} Verwenden Sie Ihre eigene Funktion \lstinline{IsLeapYear()}.
-
- \textbf{Hinweis 2}: Schreiben Sie zusätzlich eine Funktion \lstinline{DaysInYear()}.
-
- \clearpage
-
- \solution
-
- \begin{itemize}
- \item[(a)]
- \textbf{Erklären Sie das Zustandekommen der Endlosschleife.}
-
- Das Programm startet mit demjenigen Wert für \lstinline{days},
- der der Anzahl der Tage vom 1.\,1.\,1980 bis zum
- 31.\,12.\,2008 entspricht. Die \lstinline{while}-Schleife
- läuft zunächst solange korrekt durch, bis \lstinline{year} den
- Wert \lstinline{2008} und \lstinline{days} den Wert
- \lstinline{366} hat. (Der 31.\,12.\ des Schaltjahres 2008 ist
- der 366.\ Tag seines Jahres.)
-
- Die Bedingung der \lstinline{while}-Schleife ist damit
- weiterhin erfüllt; das Programm läuft weiter.
-
- Da 2008 ein Schaltjahr ist, ist auch die Bedingung der äußeren
- \lstinline{if}-Anweisung erfüllt.
-
- Da \lstinline{days} den Wert 366 hat und dieser nicht größer
- als 366 ist, ist die innere \lstinline{if}-Bedingung nicht
- erfüllt. Somit wird innerhalb der \lstinline{while}-Schleife
- kein weiterer Code ausgeführt, die \lstinline{while}-Bedingung
- bleibt erfüllt, und das Programm führt eine Endlosschleife
- aus.
-
- \item[(b)]
- \textbf{Schreiben Sie das Quelltextfragment so um, daß es die beschriebenen Probleme
- nicht mehr enthält.}
-
- Um das Programm zu testen, genügt es, das Datum auf den
- 31.\,12.\,1980 zu stellen, also \lstinline{days} auf den Wert
- 366 zu setzen. Darüberhinaus muß man die Funktion
- \lstinline{IsLeapYear()} bereitstellen (vgl.\ Aufgabe 1 vom 11.\,10.\,2021).
-
- Der Quelltext \gitfile{hp}{2022ws/20221017}{loesung-2-f1.c} ist eine lauffähige
- Version des Programms, die den Fehler (Endlosschleife)
- reproduziert.
-
- \breath
-
- Es liegt nahe, den Fehler in der \lstinline{while}-Bedingung
- zu korrigieren, so daß diese Schaltjahre berücksichtigt. Der
- Quelltext \gitfile{hp}{2022ws/20221017}{loesung-2-f2.c} behebt den Fehler auf diese
- Weise mit Hilfe von Und- (\lstinline{&&}) und
- Oder-Verknüpfungen (\lstinline{||}) in der
- \lstinline{while}-Bedingung.
-
- Der Quelltext \gitfile{hp}{2022ws/20221017}{loesung-2-f3.c} vermeidet die umständliche
- Formulierung mit \lstinline{&&} und \lstinline{||} durch
- Verwendung des ternären Operators \lstinline{?:}. Dieser
- stellt eine "`\lstinline{if}-Anweisung für Ausdrücke"' bereit.
- In diesem Fall liefert er für die rechte Seite des Vergleichs
- \lstinline{days >} den Wert 366 im Falle eines Schaltjahrs
- bzw.\ ansonsten den Wert 365.
-
- Beide Lösungen \gitfile{hp}{2022ws/20221017}{loesung-2-f2.c} und \gitfile{hp}{2022ws/20221017}{loesung-2-f3.c}
- sind jedoch im Sinne der Aufgabenstellung \textbf{falsch}.
- Diese lautet: "`Schreiben Sie das Quelltextfragment so um,
- daß es die beschriebenen Probleme nicht mehr enthält."'
- Mit den beschriebenen Problemen sind die genannten drei
- Code-Verdopplungen gemeint, und diese befinden sich weiterhin
- im Quelltext. Damit ist der Fehler zwar "`korrigiert"', aber
- das Programm ist eher noch unübersichtlicher geworden, so daß
- nicht klar ist, ob es nicht noch weitere Fehler enthält.
-
- \breath
-
- Eine richtige Lösung liefert \gitfile{hp}{2022ws/20221017}{loesung-2-4.c}. Dieses
- Programm speichert den Wert der Tage im Jahr in einer
- Variablen \lstinline{DaysInYear}. Damit erübrigen sich die
- \lstinline{if}-Anweisungen innerhalb der
- \lstinline{while}-Schleife, und die damit verbundenen
- Code-Verdopplungen verschwinden.
-
- Etwas unschön ist hierbei die neu hinzugekommene
- Code-Verdopplung bei der Berechnung von \lstinline{DaysInYear}.
- Diese ist allerdings weniger kritisch als die vorherigen, da
- sie nur einmal innerhalb der \lstinline{while}-Schleife
- vorkommt und das andere Mal außerhalb derselben.
-
- Um diese Code-Verdopplung loszuwerden, kann man das
- \lstinline{if} durch den \lstinline{?:}-Operator ersetzen und
- die Zuweisung innerhalb der \lstinline{while}-Bedingung
- vornehmen -- siehe \gitfile{hp}{2022ws/20221017}{loesung-2-5.c}. Dies ist einer der
- seltenen Fälle, in denen ein Programm \emph{übersichtlicher\/}
- wird, wenn eine Zuweisung innerhalb einer Bedingung
- stattfindet.
-
- Alternativ kann \lstinline{DaysInYear()} auch eine Funktion
- sein -- siehe \gitfile{hp}{2022ws/20221017}{loesung-2-6.c}. Diese Version ist
- wahrscheinlich die übersichtlichste, hat jedoch den Nachteil,
- daß die Berechnung von \lstinline{DaysInYear()} zweimal statt
- nur einmal pro Schleifendurchlauf erfolgt, wodurch Rechenzeit
- verschwendet wird.
-
- \gitfile{hp}{2022ws/20221017}{loesung-2-7.c} und \gitfile{hp}{2022ws/20221017}{loesung-2-8.c} beseitigen
- dieses Problem durch eine Zuweisung des Funktionsergebnisses
- an eine Variable -- einmal innerhalb der
- \lstinline{while}-Bedingung und einmal außerhalb.
- Der zweimalige Aufruf der Funktion \lstinline{DaysInYear()} in
- \gitfile{hp}{2022ws/20221017}{loesung-2-8.c} zählt nicht als Code-Verdopplung, denn
- der Code ist ja in einer Funktion gekapselt. (Genau dazu sind
- Funktionen ja da: daß man sie mehrfach aufrufen kann.)
-
- \breath
-
- Fazit: Wenn Sie sich beim Programmieren bei
- Cut-And-Paste-Aktionen erwischen, sollten Sie die Struktur
- Ihres Programms noch einmal überdenken.
-
- Wahrscheinlich gibt es dann eine elegantere Lösung, deren
- Korrektheit man auf den ersten Blick sieht.
-
- \end{itemize}
-
- \exercise{Strings}
-
- Strings werden in der Programmiersprache C
- durch Zeiger auf \lstinline{char}-Variable realisiert.
-
- Wir betrachten die folgende Funktion (Datei: \gitfile{hp}{2022ws/20221017}{aufgabe-3.c}):
- \begin{center}
- \begin{minipage}{8cm}
- \begin{lstlisting}[gobble=8]
- int fun_1 (char *s1, char *s2)
- {
- int result = 1;
- for (int i = 0; s1[i] && s2[i]; i++)
- if (s1[i] != s2[i])
- result = 0;
- return result;
- }
- \end{lstlisting}
- \end{minipage}%
- \end{center}
- \begin{itemize}
- \item[(a)]
- Was bewirkt die Funktion? % \points{3}
- \item[(b)]
- Welchen Sinn hat die Bedingung "`\lstinline{s1[i] && s2[i]}"'
- in der \lstinline{for}-Schleife? % \points{2}
- \item[(c)]
- Was würde sich ändern, wenn die Bedingung "`\lstinline{s1[i] && s2[i]}"'
- in der \lstinline{for}-Schleife\\
- zu "`\lstinline{s1[i]}"' verkürzt würde? % \points{3}
-% \item[(d)]
-% Von welcher Ordnung (Landau-Symbol) ist die Funktion \lstinline{fun_1()}
-% hinsichtlich der Anzahl ihrer Zugriffe auf die Zeichen in den Strings
-% -- und warum? % \points{2}
- \item[(d)]
- Schreiben Sie eine eigene Funktion,
- die dieselbe Aufgabe erledigt wie \lstinline{fun_1()}, nur effizienter.
-% und geben Sie die Ordnung (Landau-Symbol) der von Ihnen geschriebenen Funktion an. % \points{5}
- \end{itemize}
-
- \solution
-
- \begin{itemize}
- \item[(a)]
- \textbf{Was bewirkt die Funktion?}
-
- Sie vergleicht zwei Strings miteinander bis zur Länge des kürzeren Strings
- und gibt bei Gleichheit 1 zurück, ansonsten 0.
-
- Alternative Formulierung:
- Die Funktion prüft, ob zwei Strings bis zur Länge des kürzeren übereinstimmen,
- und gibt bei Gleichheit 1 zurück, ansonsten 0.
-
- Die Funktion prüft insbesondere \textbf{nicht} zwei Strings auf Gleichheit,
- und sie ist \textbf{nicht} funktionsgleich zur
- Standard-Bibliotheksfunktion \lstinline{strcmp()}.
-
- \item[(b)]
- \textbf{Welchen Sinn hat die Bedingung "`\lstinline{s1[i] && s2[i]}"'
- in der \lstinline{for}-Schleife?}
-
- Die Bedingung prüft, ob \emph{bei einem der beiden Strings\/}
- die Ende-Markierung (Null-Symbol) erreicht ist.
- Falls ja, wird die Schleife beendet.
-
- \item[(c)]
- \textbf{Was würde sich ändern, wenn die Bedingung "`\lstinline{s1[i] && s2[i]}"'
- in der \lstinline{for}-Schleife\\
- zu "`\lstinline{s1[i]}"' verkürzt würde?}
-
- In diesem Fall würde nur für \lstinline{s1} geprüft,
- ob das Ende erreicht ist.
- Wenn \lstinline{s1} länger ist als \lstinline{s2},
- würde \lstinline{s2} über sein Ende hinaus ausgelesen.
- Dies kann zu Lesezugriffen auf Speicher außerhalb des Programms
- und damit zu einem Absturz führen
- ("`Speicherzugriffsfehler"', "`Schutzverletzung"').
-
- \item[(d)]
- \textbf{Schreiben Sie eine eigene Funktion,
- die dieselbe Aufgabe erledigt wie \lstinline{fun_1()}, nur effizienter.}
-
- Die Effizienz läßt sich steigern, indem man die Schleife abbricht,
- sobald das Ergebnis feststeht.
- Es folgen drei Möglichkeiten, dies zu realisieren.
- \end{itemize}
-
- \begin{center}
- \begin{minipage}[t]{8cm}
- Erweiterung der Schleifenbedingung:
-
- \begin{lstlisting}[gobble=8]
- int fun_2 (char *s1, char *s2)
- {
- int result = 1;
- for (int i = 0; s1[i] && s2[i] && result; i++)
- if (s1[i] != s2[i])
- result = 0;
- return result;
- }
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{6cm}
- Verwendung von \lstinline{return}:
-
- \begin{lstlisting}[gobble=8]
- int fun_3 (char *s1, char *s2)
- {
- for (int i = 0; s1[i] && s2[i]; i++)
- if (s1[i] != s2[i])
- return 0;
- return 1;
- }
- \end{lstlisting}
- \end{minipage}
- \end{center}
- \vspace*{-1cm}\goodbreak
-
- \begin{center}
- \begin{minipage}{9cm}
- Die nebenstehende Lösung unter Verwendung von \lstinline{break}
- ist zwar ebenfalls richtig, aber länger und weniger übersichtlich
- als die beiden anderen Lösungen.
-
- \smallskip
-
- Die Datei \gitfile{hp}{2022ws/20221017}{loesung-3.c} enthält ein Testprogramm
- für alle o.\,a.\ Lösungen.
- Das Programm testet nur die offensichtlichsten Fälle;
- für den Einsatz der Funktionen in einer Produktivumgebung
- wären weitaus umfassendere Tests erforderlich.
-
- \smallskip
-
- Das Testprogramm enthält String-Zuweisungen wie z.\,B.\
- \lstinline{s2 = "Apfel"}.
- Dies funktioniert, weil wir damit einen Zeiger (\lstinline{char *s2})
- auf einen neuen Speicherbereich (\lstinline{"Apfel"}) zeigen lassen.
- Eine entsprechende Zuweisung zwischen Arrays
- (\lstinline{char s3[] = "Birne"; s3 = "Pfirsich";)}
- funktioniert \emph{nicht}.
-
- \end{minipage}\hspace*{1cm}%
- \begin{minipage}{6cm}
- \begin{lstlisting}[gobble=8]
- int fun_4 (char *s1, char *s2)
- {
- int result = 1;
- for (int i = 0; s1[i] && s2[i]; i++)
- if (s1[i] != s2[i])
- {
- result = 0;
- break;
- }
- return result;
- }
- \end{lstlisting}
- \end{minipage}
- \end{center}
-
- \exercise{Programm analysieren}
-
- Wir betrachten das folgende C-Programm (Datei: \gitfile{hp}{2022ws/20221017}{aufgabe-4.c}):
- \begin{lstlisting}
- char*f="char*f=%c%s%c;main(){printf(f,34,f,34,10);}%c";main(){printf(f,34,f,34,10);}
- \end{lstlisting}
- \vspace{-\medskipamount}
- \begin{itemize}
- \item[(a)]
- Was bewirkt dieses Programm?
- \item[(b)]
- Wofür stehen die Zahlen?
- \item[(c)]
- Ergänzen Sie das Programm derart, daß seine \lstinline{main()}-Funktion
- \lstinline{int main (void)} lautet und eine \lstinline{return}-Anweisung hat,
- wobei die in Aufgabenteil (a) festgestellte Eigenschaft erhalten bleiben soll.
- \end{itemize}
-
- \solution
-
- \begin{itemize}
- \item[(a)]
- \textbf{Was bewirkt dieses Programm?}
-
- Es gibt \emph{seinen eigenen Quelltext\/} aus.
-
- (Wichtig ist die Bezugnahme auf den eigenen Quelltext.
- Die Angabe\\
- "`Es gibt
- \lstinline|char*f="char*f=%c%s%c;main(){printf(f,34,f,34,10);}%c";main(){printf(f,34,f,34,10);}|
- aus"'\\
- genügt insbesondere nicht.)
-
- \item[(b)]
- \textbf{Wofür stehen die Zahlen?}
-
- Die 34 steht für ein Anführungszeichen und die 10 für ein
- Zeilenendezeichen (\lstinline{\n}).
-
- Hintergrund: Um den eigenen Quelltext ausgeben zu können, muß
- das Programm auch Anführungszeichen und Zeilenendezeichen
- ausgeben. Dies geschieht normalerweise mit vorangestelltem
- Backslash: \lstinline{\"} bzw.\ \lstinline{\n}. Um dann aber
- den Backslash ausgeben zu können, müßte man diesem ebenfalls
- einen Backslash voranstellen: \lstinline{\\}. Damit dies nicht
- zu einer Endlosschleife wird, verwendet der Programmierer
- dieses Programms den Trick mit den Zahlen, die durch
- \lstinline{%c} als Zeichen ausgegeben werden.
-
- \item[(c)]
- \textbf{Ergänzen Sie das Programm derart, daß seine \lstinline{main()}-Funktion
- \lstinline{int main (void)} lautet und eine \lstinline{return}-Anweisung hat,
- wobei die in Aufgabenteil (a) festgestellte Eigenschaft erhalten bleiben soll.}
-
- Datei: \gitfile{hp}{2022ws/20221017}{loesung-4.c}
- \begin{lstlisting}[gobble=8]
- char*f="char*f=%c%s%c;int main(void){printf(f,34,f,34,10);return 0;}%c";
- int main(void){printf(f,34,f,34,10);return 0;}
- \end{lstlisting}
- Das Programm ist eine einzige, lange Zeile, die hier nur aus
- Platzgründen als zwei Zeilen abgedruckt wird. Auf das
- Semikolon am Ende der "`ersten Zeile"' folgt unmittelbar -- ohne Leerzeichen --
- das Schlüsselwort \lstinline{int} am Anfang der "`zweiten Zeile"'.
-
- Mit "`die in Aufgabenteil (a) festgestellte Eigenschaft"' ist
- gemeint, daß das Programm weiterhin seinen eigenen Quelltext
- ausgeben soll. Die Herausforderung dieser Aufgabe besteht
- darin, das Programm zu modifizieren, ohne diese Eigenschaft zu
- verlieren.
-
- Zusatzaufgabe für Interessierte: Ergänzen Sie das Programm so,
- daß es auch mit \lstinline[style=cmd]{-Wall} ohne Warnungen
- compiliert werden kann.
-
- Hinweis dazu: \lstinline{#include<stdio.h>}
- (ohne Leerzeichen, um Platz zu sparen)
-
- Lösung der Zusatzaufgabe: \gitfile{hp}{2022ws/20221017}{loesung-4x.c}
-
- \end{itemize}
-
-\end{document}
diff --git a/20221017/hp-uebung-20221017.pdf b/20221017/hp-uebung-20221017.pdf
deleted file mode 100644
index 7a88b19169bab72f6c16f37d65c25525aec6c1cb..0000000000000000000000000000000000000000
Binary files a/20221017/hp-uebung-20221017.pdf and /dev/null differ
diff --git a/20221017/hp-uebung-20221017.tex b/20221017/hp-uebung-20221017.tex
deleted file mode 100644
index 7eec41a20a3bd8a0e56e27003d3c7bef3f8c825c..0000000000000000000000000000000000000000
--- a/20221017/hp-uebung-20221017.tex
+++ /dev/null
@@ -1,170 +0,0 @@
-% hp-uebung-20221017.pdf - Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Seltsame Programme, Kalender-Berechnung, Strings, Programm analysieren
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\begin{document}
-
- \thispagestyle{empty}
-
- \section*{Hardwarenahe Programmierung\\
- Übungsaufgaben -- 17.\ Oktober 2022}
-
- \exercise{Seltsame Programme}
-
- Unter \url{https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/20211017}
- finden Sie (unter anderem)\\
- die Programme \gitfile{hp}{2022ws/20221017}{test-1.c},
- \gitfile{hp}{2022ws/20221017}{test-2.c} und \gitfile{hp}{2022ws/20221017}{test-3.c}.
-
- Was bewirken diese Programme, und warum verhalten sie sich so?
-
- \exercise{Kalender-Berechnung}
-
- Am 3.\,1.\,2009 meldete \emph{heise online\/}:
- \begin{quote}
- Kunden des ersten mobilen Media-Players von Microsoft
- erlebten zum Jahresende eine böse Überraschung:
- Am 31.\ Dezember 2008 fielen weltweit alle Zune-Geräte der ersten Generation aus.
- Ursache war ein interner Fehler bei der Handhabung von Schaltjahren.
-
- \strut\hfill\url{http://heise.de/-193332},
- \end{quote}
- Der Artikel verweist auf ein Quelltextfragment (Datei: \gitfile{hp}{2022ws/20221017}{aufgabe-2.c}),
- das für einen gegebenen Wert \lstinline{days}
- das Jahr und den Tag innerhalb des Jahres
- für den \lstinline{days}-ten Tag nach dem 1.\,1.\,1980 berechnen soll:
- \begin{lstlisting}
- year = ORIGINYEAR; /* = 1980 */
-
- while (days > 365)
- {
- if (IsLeapYear (year))
- {
- if (days > 366)
- {
- days -= 366;
- year += 1;
- }
- }
- else
- {
- days -= 365;
- year += 1;
- }
- }
- \end{lstlisting}
- Dieses Quelltextfragment enthält schlechten Programmierstil,
- nämlich mehrere Code-Verdopplungen:
- \begin{itemize}
- \item
- Die Anweisung \lstinline{year += 1} taucht an zwei Stellen auf.
- \item
- Es gibt zwei unabhängige Abfragen \lstinline{days > 365} und \lstinline{days > 366}:\\
- eine in einer \lstinline{while}- und die andere in einer \lstinline{if}-Bedingung.
- \item
- Die Länge eines Jahres wird nicht durch eine Funktion berechnet oder in einer Variablen gespeichert;
- stattdessen werden an mehreren Stellen die expliziten numerischen Konstanten 365 und 366 verwendet.
- \end{itemize}
- Diese Probleme führten am 31.\ Dezember 2008 zu einer Endlosschleife.
-
- Gut hingegen ist die Verwendung einer Konstanten \lstinline{ORIGINYEAR}
- anstelle der Zahl 1980
- sowie die Kapselung der Berechnung der Schaltjahr-Bedingung
- in einer Funktion \lstinline{IsLeapYear()}.
-
- \begin{itemize}
- \item[(a)]
- Erklären Sie das Zustandekommen der Endlosschleife.
- \item[(b)]
- Schreiben Sie das Quelltextfragment so um, daß es die beschriebenen Probleme
- nicht mehr enthält.
- \end{itemize}
-
- \textbf{Hinweis 1:} Verwenden Sie für \lstinline{IsLeapYear()}
- Ihre eigene Funktion aus Aufgabe 1 der letzten Übung.
-
- \textbf{Hinweis 2}: Schreiben Sie zusätzlich eine Funktion \lstinline{DaysInYear()}.
-
- \exercise{Strings}
-
- Strings werden in der Programmiersprache C
- durch Zeiger auf \lstinline{char}-Variable realisiert.
-
- Wir betrachten die folgende Funktion (Datei: \gitfile{hp}{2022ws/20221017}{aufgabe-3.c}):
- \begin{center}
- \begin{minipage}{8cm}
- \begin{lstlisting}[gobble=8]
- int fun_1 (char *s1, char *s2)
- {
- int result = 1;
- for (int i = 0; s1[i] && s2[i]; i++)
- if (s1[i] != s2[i])
- result = 0;
- return result;
- }
- \end{lstlisting}
- \end{minipage}%
- \end{center}
- \begin{itemize}
- \item[(a)]
- Was bewirkt die Funktion? % \points{3}
- \item[(b)]
- Welchen Sinn hat die Bedingung "`\lstinline{s1[i] && s2[i]}"'
- in der \lstinline{for}-Schleife? % \points{2}
- \item[(c)]
- Was würde sich ändern, wenn die Bedingung "`\lstinline{s1[i] && s2[i]}"'
- in der \lstinline{for}-Schleife\\
- zu "`\lstinline{s1[i]}"' verkürzt würde? % \points{3}
-% \item[(d)]
-% Von welcher Ordnung (Landau-Symbol) ist die Funktion \lstinline{fun_1()}
-% hinsichtlich der Anzahl ihrer Zugriffe auf die Zeichen in den Strings
-% -- und warum? % \points{2}
- \item[(d)]
- Schreiben Sie eine eigene Funktion,
- die dieselbe Aufgabe erledigt wie \lstinline{fun_1()}, nur effizienter.
-% und geben Sie die Ordnung (Landau-Symbol) der von Ihnen geschriebenen Funktion an. % \points{5}
- \end{itemize}
-
- \exercise{Programm analysieren}
-
- Wir betrachten das folgende C-Programm (Datei: \gitfile{hp}{2022ws/20221017}{aufgabe-4.c}):
- \begin{lstlisting}
- char*f="char*f=%c%s%c;main(){printf(f,34,f,34,10);}%c";main(){printf(f,34,f,34,10);}
- \end{lstlisting}
- \vspace{-\medskipamount}
- \begin{itemize}
- \item[(a)]
- Was bewirkt dieses Programm?
- \item[(b)]
- Wofür stehen die Zahlen?
- \item[(c)]
- Ergänzen Sie das Programm derart, daß seine \lstinline{main()}-Funktion
- \lstinline{int main (void)} lautet und eine \lstinline{return}-Anweisung hat,
- wobei die in Aufgabenteil (a) festgestellte Eigenschaft erhalten bleiben soll.
- \end{itemize}
-
-\end{document}
diff --git a/20221017/loesung-2-4.c b/20221017/loesung-2-4.c
deleted file mode 100644
index d141e32582374a3b3e6955f5634191d15edb3709..0000000000000000000000000000000000000000
--- a/20221017/loesung-2-4.c
+++ /dev/null
@@ -1,41 +0,0 @@
-#include <stdio.h>
-
-int IsLeapYear (int year)
-{
- if (year % 4)
- return 0;
- else if (year % 100)
- return 1;
- else if (year % 400)
- return 0;
- else
- return 1;
-}
-
-int main (void)
-{
- int ORIGINYEAR = 1980;
- int days = 366;
- int year;
-
- year = ORIGINYEAR; /* = 1980 */
-
- int DaysInYear;
- if (IsLeapYear (year))
- DaysInYear = 366;
- else
- DaysInYear = 365;
-
- while (days > DaysInYear)
- {
- days -= DaysInYear;
- year += 1;
- if (IsLeapYear (year))
- DaysInYear = 366;
- else
- DaysInYear = 365;
- }
-
- printf ("year = %d\ndays = %d\n", year, days);
- return 0;
-}
diff --git a/20221017/loesung-2-5.c b/20221017/loesung-2-5.c
deleted file mode 100644
index 8a71934b7df24a28d11a6696e212aaccc430277f..0000000000000000000000000000000000000000
--- a/20221017/loesung-2-5.c
+++ /dev/null
@@ -1,33 +0,0 @@
-#include <stdio.h>
-
-int IsLeapYear (int year)
-{
- if (year % 4)
- return 0;
- else if (year % 100)
- return 1;
- else if (year % 400)
- return 0;
- else
- return 1;
-}
-
-int main (void)
-{
- int ORIGINYEAR = 1980;
- int days = 366;
- int year;
-
- year = ORIGINYEAR; /* = 1980 */
-
- int DaysInYear;
-
- while (days > (DaysInYear = IsLeapYear (year) ? 366 : 365))
- {
- days -= DaysInYear;
- year += 1;
- }
-
- printf ("year = %d\ndays = %d\n", year, days);
- return 0;
-}
diff --git a/20221017/loesung-2-6.c b/20221017/loesung-2-6.c
deleted file mode 100644
index 0605571480991d1ec73a8cec50395ddf68ae3135..0000000000000000000000000000000000000000
--- a/20221017/loesung-2-6.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include <stdio.h>
-
-int IsLeapYear (int year)
-{
- if (year % 4)
- return 0;
- else if (year % 100)
- return 1;
- else if (year % 400)
- return 0;
- else
- return 1;
-}
-
-int DaysInYear (int year)
-{
- if (IsLeapYear (year))
- return 366;
- else
- return 365;
-}
-
-int main (void)
-{
- int ORIGINYEAR = 1980;
- int days = 366;
- int year;
-
- year = ORIGINYEAR; /* = 1980 */
-
- while (days > DaysInYear (year))
- {
- days -= DaysInYear (year);
- year += 1;
- }
-
- printf ("year = %d\ndays = %d\n", year, days);
- return 0;
-}
diff --git a/20221017/loesung-2-7.c b/20221017/loesung-2-7.c
deleted file mode 100644
index 5c98286730aae146cf587b5f3401eb6eadd17aa7..0000000000000000000000000000000000000000
--- a/20221017/loesung-2-7.c
+++ /dev/null
@@ -1,41 +0,0 @@
-#include <stdio.h>
-
-int IsLeapYear (int year)
-{
- if (year % 4)
- return 0;
- else if (year % 100)
- return 1;
- else if (year % 400)
- return 0;
- else
- return 1;
-}
-
-int DaysInYear (int year)
-{
- if (IsLeapYear (year))
- return 366;
- else
- return 365;
-}
-
-int main (void)
-{
- int ORIGINYEAR = 1980;
- int days = 366;
- int year;
-
- year = ORIGINYEAR; /* = 1980 */
-
- int d;
-
- while (days > (d = DaysInYear (year)))
- {
- days -= d;
- year += 1;
- }
-
- printf ("year = %d\ndays = %d\n", year, days);
- return 0;
-}
diff --git a/20221017/loesung-2-8.c b/20221017/loesung-2-8.c
deleted file mode 100644
index e94dc80375b88fd5ff3245e8a99f76a5955b6bb8..0000000000000000000000000000000000000000
--- a/20221017/loesung-2-8.c
+++ /dev/null
@@ -1,42 +0,0 @@
-#include <stdio.h>
-
-int IsLeapYear (int year)
-{
- if (year % 4)
- return 0;
- else if (year % 100)
- return 1;
- else if (year % 400)
- return 0;
- else
- return 1;
-}
-
-int DaysInYear (int year)
-{
- if (IsLeapYear (year))
- return 366;
- else
- return 365;
-}
-
-int main (void)
-{
- int ORIGINYEAR = 1980;
- int days = 366;
- int year;
-
- year = ORIGINYEAR; /* = 1980 */
-
- int d = DaysInYear (year);
-
- while (days > d)
- {
- days -= d;
- year += 1;
- d = DaysInYear (year);
- }
-
- printf ("year = %d\ndays = %d\n", year, days);
- return 0;
-}
diff --git a/20221017/loesung-2-f1.c b/20221017/loesung-2-f1.c
deleted file mode 100644
index 4d511c4fa7ee6a9dfb0bc2f69412eeb48745af56..0000000000000000000000000000000000000000
--- a/20221017/loesung-2-f1.c
+++ /dev/null
@@ -1,42 +0,0 @@
-#include <stdio.h>
-
-int IsLeapYear (int year)
-{
- if (year % 4)
- return 0;
- else if (year % 100)
- return 1;
- else if (year % 400)
- return 0;
- else
- return 1;
-}
-
-int main (void)
-{
- int ORIGINYEAR = 1980;
- int days = 366;
- int year;
-
- year = ORIGINYEAR; /* = 1980 */
-
- while (days > 365)
- {
- if (IsLeapYear (year))
- {
- if (days > 366)
- {
- days -= 366;
- year += 1;
- }
- }
- else
- {
- days -= 365;
- year += 1;
- }
- }
-
- printf ("year = %d\ndays = %d\n", year, days);
- return 0;
-}
diff --git a/20221017/loesung-2-f2.c b/20221017/loesung-2-f2.c
deleted file mode 100644
index a44edb09ffde3d3c77cfe673da862260368c33e3..0000000000000000000000000000000000000000
--- a/20221017/loesung-2-f2.c
+++ /dev/null
@@ -1,43 +0,0 @@
-#include <stdio.h>
-
-int IsLeapYear (int year)
-{
- if (year % 4)
- return 0;
- else if (year % 100)
- return 1;
- else if (year % 400)
- return 0;
- else
- return 1;
-}
-
-int main (void)
-{
- int ORIGINYEAR = 1980;
- int days = 366;
- int year;
-
- year = ORIGINYEAR; /* = 1980 */
-
- while ((IsLeapYear (year) && days > 366)
- || (!IsLeapYear (year) && days > 365))
- {
- if (IsLeapYear (year))
- {
- if (days > 366)
- {
- days -= 366;
- year += 1;
- }
- }
- else
- {
- days -= 365;
- year += 1;
- }
- }
-
- printf ("year = %d\ndays = %d\n", year, days);
- return 0;
-}
diff --git a/20221017/loesung-2-f3.c b/20221017/loesung-2-f3.c
deleted file mode 100644
index dbfe5040274953c3b90d6b2da194c0c8ae64f04f..0000000000000000000000000000000000000000
--- a/20221017/loesung-2-f3.c
+++ /dev/null
@@ -1,42 +0,0 @@
-#include <stdio.h>
-
-int IsLeapYear (int year)
-{
- if (year % 4)
- return 0;
- else if (year % 100)
- return 1;
- else if (year % 400)
- return 0;
- else
- return 1;
-}
-
-int main (void)
-{
- int ORIGINYEAR = 1980;
- int days = 366;
- int year;
-
- year = ORIGINYEAR; /* = 1980 */
-
- while (days > (IsLeapYear (year) ? 366 : 365))
- {
- if (IsLeapYear (year))
- {
- if (days > 366)
- {
- days -= 366;
- year += 1;
- }
- }
- else
- {
- days -= 365;
- year += 1;
- }
- }
-
- printf ("year = %d\ndays = %d\n", year, days);
- return 0;
-}
diff --git a/20221017/loesung-3.c b/20221017/loesung-3.c
deleted file mode 100644
index 29a2b7f234ea5c31b06780e9dd461dff95dd33a3..0000000000000000000000000000000000000000
--- a/20221017/loesung-3.c
+++ /dev/null
@@ -1,67 +0,0 @@
-#include <stdio.h>
-
-int fun_1 (char *s1, char *s2)
-{
- int result = 1;
- for (int i = 0; s1[i] && s2[i]; i++)
- if (s1[i] != s2[i])
- result = 0;
- return result;
-}
-
-int fun_2 (char *s1, char *s2)
-{
- int result = 1;
- for (int i = 0; s1[i] && s2[i] && result; i++)
- if (s1[i] != s2[i])
- result = 0;
- return result;
-}
-
-int fun_3 (char *s1, char *s2)
-{
- for (int i = 0; s1[i] && s2[i]; i++)
- if (s1[i] != s2[i])
- return 0;
- return 1;
-}
-
-int fun_4 (char *s1, char *s2)
-{
- int result = 1;
- for (int i = 0; s1[i] && s2[i]; i++)
- if (s1[i] != s2[i])
- {
- result = 0;
- break;
- }
- return result;
-}
-
-int main (void)
-{
- char *s1 = "Apfel";
- char *s2 = "Apfelkuchen";
- if (fun_1 (s1, s2) && fun_2 (s1, s2) && fun_3 (s1, s2) && fun_4 (s1, s2))
- printf ("OK\n");
- else
- printf ("failed\n");
- s1 = "Apfelkuchen";
- s2 = "Apfel";
- if (fun_1 (s1, s2) && fun_2 (s1, s2) && fun_3 (s1, s2) && fun_4 (s1, s2))
- printf ("OK\n");
- else
- printf ("failed\n");
- s2 = "Birnenmarmelade";
- if (fun_1 (s1, s2) || fun_2 (s1, s2) || fun_3 (s1, s2) || fun_4 (s1, s2))
- printf ("failed\n");
- else
- printf ("OK\n");
- s1 = s2;
- s2 = "Apfelkuchen";
- if (fun_1 (s1, s2) || fun_2 (s1, s2) || fun_3 (s1, s2) || fun_4 (s1, s2))
- printf ("failed\n");
- else
- printf ("OK\n");
- return 0;
-}
diff --git a/20221017/loesung-4.c b/20221017/loesung-4.c
deleted file mode 100644
index 6346384a81d62e7e687f4db99be3ba8fe4020744..0000000000000000000000000000000000000000
--- a/20221017/loesung-4.c
+++ /dev/null
@@ -1 +0,0 @@
-char*f="char*f=%c%s%c;int main(void){printf(f,34,f,34,10);return 0;}%c";int main(void){printf(f,34,f,34,10);return 0;}
diff --git a/20221017/loesung-4x.c b/20221017/loesung-4x.c
deleted file mode 100644
index fcc65e153ddf009f55af118278774cd202f7c316..0000000000000000000000000000000000000000
--- a/20221017/loesung-4x.c
+++ /dev/null
@@ -1,2 +0,0 @@
-#include<stdio.h>
-char*f="#include<stdio.h>%cchar*f=%c%s%c;int main(void){printf(f,10,34,f,34,10);return 0;}%c";int main(void){printf(f,10,34,f,34,10);return 0;}
diff --git a/20221017/logo-hochschule-bochum-cvh-text-v2.pdf b/20221017/logo-hochschule-bochum-cvh-text-v2.pdf
deleted file mode 120000
index 4aa99b8f81061aca6dcaf43eed2d9efef40555f8..0000000000000000000000000000000000000000
--- a/20221017/logo-hochschule-bochum-cvh-text-v2.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
diff --git a/20221017/logo-hochschule-bochum.pdf b/20221017/logo-hochschule-bochum.pdf
deleted file mode 120000
index b6b9491e370e499c9276918182cdb82cb311bcd1..0000000000000000000000000000000000000000
--- a/20221017/logo-hochschule-bochum.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20221017/main-params-01.c b/20221017/main-params-01.c
deleted file mode 100644
index e6e64ba029e1042aff60960fc8b7c3d4d5d8e2e2..0000000000000000000000000000000000000000
--- a/20221017/main-params-01.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (int argc, char **argv)
-{
- printf ("argc = %d\n", argc);
- for (int i = 0; i < argc; i++)
- printf ("argv[%d] = \"%s\"\n", i, argv[i]);
- return 0;
-}
diff --git a/20221017/main-params-01.txt b/20221017/main-params-01.txt
deleted file mode 100644
index b4ff132e66b6baea75e4c41f4f506aac876fa4bf..0000000000000000000000000000000000000000
--- a/20221017/main-params-01.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <stdio.h>
-
-int main (int argc, char **argv)
-{
- printf ("argc = %d\n", argc);
- for (int i = 0; i < argc; i++)
- printf ("argv[%d] = \"%s\"\n", i, argv[i]);
- return 0;
-}
-cassini/home/peter/bo/2022ws/hp/20221017> gcc -Wall -O main-params-01.c -o main-params-01
-cassini/home/peter/bo/2022ws/hp/20221017> ./main-params-01 bla blubb
-argc = 3
-argv[0] = "./main-params-01"
-argv[1] = "bla"
-argv[2] = "blubb"
-cassini/home/peter/bo/2022ws/hp/20221017> /home/peter/bo/2022ws/hp/20221017/main-params-01 bla blubb
-argc = 3
-argv[0] = "/home/peter/bo/2022ws/hp/20221017/main-params-01"
-argv[1] = "bla"
-argv[2] = "blubb"
-cassini/home/peter/bo/2022ws/hp/20221017>
diff --git a/20221017/main-params-02.c b/20221017/main-params-02.c
deleted file mode 100644
index dc228bb2bed3ca98892f26c753668e6fb7d167e6..0000000000000000000000000000000000000000
--- a/20221017/main-params-02.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (int argc, char **argv)
-{
- printf ("argc = %d\n", argc);
- for (int i = 0; *argv; argv++)
- printf ("argv[%d] = \"%s\"\n", i, argv[i]);
- return 0;
-}
diff --git a/20221017/main-params-02.txt b/20221017/main-params-02.txt
deleted file mode 100644
index c90c054481d3feebd65dcd19b3993645473e6286..0000000000000000000000000000000000000000
--- a/20221017/main-params-02.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdio.h>
-
-int main (int argc, char **argv)
-{
- printf ("argc = %d\n", argc);
- for (int i = 0; *argv; argv++)
- printf ("argv[%d] = \"%s\"\n", i, argv[i]);
- return 0;
-}
-cassini/home/peter/bo/2022ws/hp/20221017> gcc -Wall -O main-params-02.c -o main-params-02
-cassini/home/peter/bo/2022ws/hp/20221017> ./main-params-02 bla blubb pruzzel proe
-argc = 5
-argv[0] = "./main-params-02"
-argv[0] = "bla"
-argv[0] = "blubb"
-argv[0] = "pruzzel"
-argv[0] = "proe"
-cassini/home/peter/bo/2022ws/hp/20221017>
diff --git a/20221017/main-params-03.c b/20221017/main-params-03.c
deleted file mode 100644
index 49e93fd84e36b54d429eee78af8906856b68ff35..0000000000000000000000000000000000000000
--- a/20221017/main-params-03.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (int argc, char **argv)
-{
- printf ("argc = %d\n", argc);
- for (int i = 0; *argv; argv++)
- printf ("argv[%d] = \"%s\"\n", i, *argv);
- return 0;
-}
diff --git a/20221017/main-params-04.c b/20221017/main-params-04.c
deleted file mode 100644
index 0e932b379ce3c7381241c8d8d58d2a8cad4a2f76..0000000000000000000000000000000000000000
--- a/20221017/main-params-04.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (int argc, char **argv)
-{
- printf ("argc = %d\n", argc);
- for (int i = 0; *argv; i++, argv++)
- printf ("argv[%d] = \"%s\"\n", i, *argv);
- return 0;
-}
diff --git a/20221017/main-params-05.c b/20221017/main-params-05.c
deleted file mode 100644
index 1edea2347d90713756b31e06b0f5dcef59adcbc9..0000000000000000000000000000000000000000
--- a/20221017/main-params-05.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (int argc, char **argv)
-{
- printf ("argc = %d\n", argc);
- for (int i = 0; *argv; argv++)
- printf ("argv[%d] = \"%s\"\n", i++, *argv);
- return 0;
-}
diff --git a/20221017/main-params-06.c b/20221017/main-params-06.c
deleted file mode 100644
index f4c1bb7bd17edc00d98586f73a91ab68e8a126f8..0000000000000000000000000000000000000000
--- a/20221017/main-params-06.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-
-int main (int argc, char **argv)
-{
- printf ("argc = %d\n", argc);
- for (int i = 0; *argv; argv++)
- {
- printf ("argv[%d] = \"%s\"\n", i, *argv);
- i++;
- }
- return 0;
-}
diff --git a/20221017/main-params-07.c b/20221017/main-params-07.c
deleted file mode 100644
index c9e41612a9001cd12a2ceb94b0b19015cf13de60..0000000000000000000000000000000000000000
--- a/20221017/main-params-07.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-int main (int argc, char **argv)
-{
- printf ("argc = %d\n", argc);
- int i = 0;
- for (; *argv; argv++)
- {
- printf ("argv[%d] = \"%s\"\n", i, *argv);
- i++;
- }
- return 0;
-}
diff --git a/20221017/main-params-08.c b/20221017/main-params-08.c
deleted file mode 100644
index 4182397a45152e780baf611a6031c37f9dcea5ac..0000000000000000000000000000000000000000
--- a/20221017/main-params-08.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-
-int main (int argc, char **argv)
-{
- printf ("argc = %d\n", argc);
- int i = 0;
- while (*argv)
- {
- printf ("argv[%d] = \"%s\"\n", i, *argv);
- i++;
- argv++;
- }
- return 0;
-}
diff --git a/20221017/main-params-09.c b/20221017/main-params-09.c
deleted file mode 100644
index 8fa64e701d9257dae4040a694ec651a054657cf4..0000000000000000000000000000000000000000
--- a/20221017/main-params-09.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-int main (int argc, char **argv)
-{
- printf ("argc = %d\n", argc);
- int i = 0;
- while (*argv)
- printf ("argv[%d] = \"%s\"\n", i++, *argv++);
- return 0;
-}
diff --git a/20221017/pgscript.sty b/20221017/pgscript.sty
deleted file mode 120000
index 95c888478c99ea7fda0fd11ccf669ae91be7178b..0000000000000000000000000000000000000000
--- a/20221017/pgscript.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgscript.sty
\ No newline at end of file
diff --git a/20221017/pgslides.sty b/20221017/pgslides.sty
deleted file mode 120000
index 5be1416f4216f076aa268901f52a15d775e43f64..0000000000000000000000000000000000000000
--- a/20221017/pgslides.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgslides.sty
\ No newline at end of file
diff --git a/20221017/pointers-07.c b/20221017/pointers-07.c
deleted file mode 100644
index 169a038c369979cf1de7015ccb4a6f5e2e2e8df6..0000000000000000000000000000000000000000
--- a/20221017/pointers-07.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-
-void calc_answer (int* a)
-{
- *a = 42;
-}
-
-int main (void)
-{
- int answer;
- calc_answer (&answer);
- printf ("The answer is %d.\n", answer);
- return 0;
-}
diff --git a/20221017/pointers-08.c b/20221017/pointers-08.c
deleted file mode 100644
index c83794a4cb515e9a033529340e979c8ec4dd0308..0000000000000000000000000000000000000000
--- a/20221017/pointers-08.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int answer;
- int *b = &answer;
- *b = 42;
- printf ("The answer is %d.\n", answer);
- return 0;
-}
diff --git a/20221017/pointers-09.c b/20221017/pointers-09.c
deleted file mode 100644
index 856e938ed0ce5a0c48ac64477859cf86ab6a3768..0000000000000000000000000000000000000000
--- a/20221017/pointers-09.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int answer;
- int *b, c;
- b = &answer;
- c = &answer;
- *b = 42;
- printf ("The answer is %d.\n", answer);
- printf ("c = %d\n", c);
- return 0;
-}
diff --git a/20221017/pointers-10.c b/20221017/pointers-10.c
deleted file mode 100644
index 615080b1e9ff5a1d13b8cb76fddf3f3fcd4c56a2..0000000000000000000000000000000000000000
--- a/20221017/pointers-10.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int answer;
- int* b, c;
- b = &answer;
- c = &answer;
- *b = 42;
- printf ("The answer is %d.\n", answer);
- printf ("c = %d\n", c);
- return 0;
-}
diff --git a/20221017/string-constants.png b/20221017/string-constants.png
deleted file mode 100644
index 3dba40f2857abbd1454eab9d85a96f70d6b509d4..0000000000000000000000000000000000000000
Binary files a/20221017/string-constants.png and /dev/null differ
diff --git a/20221017/string-constants.xcf.gz b/20221017/string-constants.xcf.gz
deleted file mode 100644
index a8fc3f2c62506054b51891b51888b55680ab7883..0000000000000000000000000000000000000000
Binary files a/20221017/string-constants.xcf.gz and /dev/null differ
diff --git a/20221017/string-ops-01.c b/20221017/string-ops-01.c
deleted file mode 100644
index 1c0d36087e291cfa3b200955724b7de6f4460995..0000000000000000000000000000000000000000
--- a/20221017/string-ops-01.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char hello[] = "Hello, world!\n";
-
- printf ("%s\n", hello);
- printf ("%zd\n", strlen (hello));
-
- return 0;
-
- printf ("%s\n", hello + 7);
- printf ("%zd\n", strlen (hello + 7));
-
- hello[5] = 0;
- printf ("%s\n", hello);
- printf ("%zd\n", strlen (hello));
-}
diff --git a/20221017/string-ops-02.c b/20221017/string-ops-02.c
deleted file mode 100644
index 0bf558ba459b2fe31b744b2703f26d1a3201a457..0000000000000000000000000000000000000000
--- a/20221017/string-ops-02.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char hello[] = "Hello, world!\n";
-
- printf ("%s\n", hello);
- printf ("%zd\n", strlen (hello));
-
- printf ("%s\n", hello + 7);
- printf ("%zd\n", strlen (hello + 7));
-
- return 0;
-
- hello[5] = 0;
- printf ("%s\n", hello);
- printf ("%zd\n", strlen (hello));
-}
diff --git a/20221017/string-ops-03.c b/20221017/string-ops-03.c
deleted file mode 100644
index dd05111f79e0573d616522593362f6f93beb89e7..0000000000000000000000000000000000000000
--- a/20221017/string-ops-03.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char hello[] = "Hello, world!\n";
-
- printf ("%s\n", hello);
- printf ("%zd\n", strlen (hello));
-
- printf ("%s\n", hello + 7);
- printf ("%zd\n", strlen (hello + 7));
-
- hello[5] = 0;
- printf ("%s\n", hello);
- printf ("%zd\n", strlen (hello));
-
- return 0;
-}
diff --git a/20221017/string-ops-04.c b/20221017/string-ops-04.c
deleted file mode 100644
index 99538d235b7958a12d169ae378bcc5c311c7830f..0000000000000000000000000000000000000000
--- a/20221017/string-ops-04.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *hello = "Hello, world!\n";
-
- printf ("%s\n", hello);
- printf ("%zd\n", strlen (hello));
-
- printf ("%s\n", hello + 7);
- printf ("%zd\n", strlen (hello + 7));
-
- hello[5] = 0;
- printf ("%s\n", hello);
- printf ("%zd\n", strlen (hello));
-
- return 0;
-}
diff --git a/20221017/string-ops-05.c b/20221017/string-ops-05.c
deleted file mode 100644
index 74e2143811efbe6c4d428a688f2a2e05aefe6b34..0000000000000000000000000000000000000000
--- a/20221017/string-ops-05.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *anton = "Anton";
- char *zacharias = "Zacharias";
-
- printf ("%d\n", strcmp (anton, zacharias));
- printf ("%d\n", strcmp (zacharias, anton));
- printf ("%d\n", strcmp (anton, anton));
-
- return 0;
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-}
diff --git a/20221017/string-ops-06.c b/20221017/string-ops-06.c
deleted file mode 100644
index 45a05920ade15e321a1f9942cd3aecafa6dab452..0000000000000000000000000000000000000000
--- a/20221017/string-ops-06.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *anton = "anton";
- char *zacharias = "Zacharias";
-
- printf ("%d\n", strcmp (anton, zacharias));
- printf ("%d\n", strcmp (zacharias, anton));
- printf ("%d\n", strcmp (anton, anton));
-
- return 0;
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-}
diff --git a/20221017/string-ops-07.c b/20221017/string-ops-07.c
deleted file mode 100644
index c164eba2a9a4871ae1c6ed5a2b9b365df58511ad..0000000000000000000000000000000000000000
--- a/20221017/string-ops-07.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *anton = "anton";
- char *Anton = "Anton";
- char *zacharias = "Zacharias";
-
- printf ("%d\n", strcasecmp (anton, zacharias));
- printf ("%d\n", strcasecmp (zacharias, anton));
- printf ("%d\n", strcasecmp (anton, Anton));
-
- return 0;
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-}
diff --git a/20221017/string-ops-08.c b/20221017/string-ops-08.c
deleted file mode 100644
index 87e2cf826d340393a5ce37a7eb3676a24a8040c3..0000000000000000000000000000000000000000
--- a/20221017/string-ops-08.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *anton = "anton";
- char *Bnton = "Bnton";
- char *zacharias = "Zacharias";
-
- printf ("%d\n", strcasecmp (Bnton, zacharias));
- printf ("%d\n", strcasecmp (zacharias, anton));
- printf ("%d\n", strcasecmp (anton, Bnton));
-
- return 0;
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-}
diff --git a/20221017/string-ops-09.c b/20221017/string-ops-09.c
deleted file mode 100644
index 6a803adb92c01db1a80b73321fa6646779b877e6..0000000000000000000000000000000000000000
--- a/20221017/string-ops-09.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *anton = "anton";
- char *aenton = "änton";
- char *zacharias = "Zacharias";
-
- printf ("%d\n", strcasecmp (aenton, zacharias));
- printf ("%d\n", strcasecmp (zacharias, anton));
- printf ("%d\n", strcasecmp (anton, aenton));
-
- return 0;
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-}
diff --git a/20221017/string-ops-10.c b/20221017/string-ops-10.c
deleted file mode 100644
index 0009a89d769500bc6c04abc09610baa31ff39cc2..0000000000000000000000000000000000000000
--- a/20221017/string-ops-10.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *anton = "Anton";
- char *zacharias = "Zacharias";
-
- if (anton < zacharias)
- printf ("Anton liegt weiter vorne im Alphabet.\n");
- else
- printf ("Zacharias liegt weiter vorne im Alphabet.\n");
-
- return 0;
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-}
diff --git a/20221017/string-ops-11.c b/20221017/string-ops-11.c
deleted file mode 100644
index fb4915dc48a83bcd8fab2997d4a8f73e3465cccb..0000000000000000000000000000000000000000
--- a/20221017/string-ops-11.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *anton = "Zbnton";
- char *zacharias = "Zacharias";
-
- if (anton < zacharias)
- printf ("Zbnton liegt weiter vorne im Alphabet.\n");
- else
- printf ("Zacharias liegt weiter vorne im Alphabet.\n");
-
- return 0;
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-}
diff --git a/20221017/string-ops-12.c b/20221017/string-ops-12.c
deleted file mode 100644
index 93f47f4729cca2f0d1801dfc583ad26648e115f6..0000000000000000000000000000000000000000
--- a/20221017/string-ops-12.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-char *anton = "Anton";
-char *zacharias = "Zacharias";
-
-int main (void)
-{
- if (anton < zacharias)
- printf ("Anton liegt weiter vorne im Alphabet.\n");
- else
- printf ("Zacharias liegt weiter vorne im Alphabet.\n");
-
- return 0;
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-}
diff --git a/20221017/string-ops-13.c b/20221017/string-ops-13.c
deleted file mode 100644
index 297c5bbb3638b6ce5ff8c3913970eab65c03fc08..0000000000000000000000000000000000000000
--- a/20221017/string-ops-13.c
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-char *anton = "Anton";
-char *zacharias = "Zacharias";
-
-int main (void)
-{
- if (anton < zacharias)
- printf ("Anton (%016zx) liegt weiter vorne im Alphabet ... äh ... Speicher als Zacharias (%016zx).\n",
- anton, zacharias);
- else
- printf ("Zacharias (%016zx) liegt weiter vorne im Alphabet ... äh ... Speicher als Anton (%016zx).\n",
- zacharias, anton);
-
- return 0;
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-}
diff --git a/20221017/string-ops-14.c b/20221017/string-ops-14.c
deleted file mode 100644
index 2f2271d3b6c73b7f0bec3cae078662184754a20a..0000000000000000000000000000000000000000
--- a/20221017/string-ops-14.c
+++ /dev/null
@@ -1,20 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *anton = "Anton";
- char *zacharias = "Zacharias";
- if (anton < zacharias)
- printf ("Anton (%016zx) liegt weiter vorne im Alphabet ... äh ... Speicher als Zacharias (%016zx).\n",
- anton, zacharias);
- else
- printf ("Zacharias (%016zx) liegt weiter vorne im Alphabet ... äh ... Speicher als Anton (%016zx).\n",
- zacharias, anton);
-
- return 0;
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-}
diff --git a/20221017/string-ops-15.c b/20221017/string-ops-15.c
deleted file mode 100644
index 6534185f01b2c478bb7fbe9da91155226ed4b944..0000000000000000000000000000000000000000
--- a/20221017/string-ops-15.c
+++ /dev/null
@@ -1,30 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *anton = "Anton";
- char *zacharias = "Zacharias";
- if (anton < zacharias)
- {
- printf ("Anton (%016zx) liegt weiter vorne im Speicher als Zacharias (%016zx).\n",
- anton, zacharias);
- for (int i = 0; i < 6 + 10; i++)
- printf ("%c", anton[i]);
- printf ("\n");
- }
- else
- {
- printf ("Zacharias (%016zx) liegt weiter vorne im Speicher als Anton (%016zx).\n",
- zacharias, anton);
- for (int i = 0; i < 6 + 10; i++)
- printf ("%c", zacharias[i]);
- printf ("\n");
- }
-
- return 0;
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-}
diff --git a/20221017/string-ops-15.txt b/20221017/string-ops-15.txt
deleted file mode 100644
index ed71965d6b30782d2a39eb29577e667b34435c6b..0000000000000000000000000000000000000000
--- a/20221017/string-ops-15.txt
+++ /dev/null
@@ -1,35 +0,0 @@
-cassini/home/peter/bo/2022ws/hp/20221017> cat string-ops-15.c
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *anton = "Anton";
- char *zacharias = "Zacharias";
- if (anton < zacharias)
- {
- printf ("Anton (%016zx) liegt weiter vorne im Speicher als Zacharias (%016zx).\n",
- anton, zacharias);
- for (int i = 0; i < 6 + 10; i++)
- printf ("%c", anton[i]);
- printf ("\n");
- }
- else
- {
- printf ("Zacharias (%016zx) liegt weiter vorne im Speicher als Anton (%016zx).\n",
- zacharias, anton);
- for (int i = 0; i < 6 + 10; i++)
- printf ("%c", zacharias[i]);
- printf ("\n");
- }
-
- return 0;
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-}
-cassini/home/peter/bo/2022ws/hp/20221017> ./string-ops-15
-Anton (000055954d678004) liegt weiter vorne im Speicher als Zacharias (000055954d67800a).
-AntonZacharias
-cassini/home/peter/bo/2022ws/hp/20221017>
diff --git a/20221017/string-ops-16.c b/20221017/string-ops-16.c
deleted file mode 100644
index ab1d9bbafd170d9a104482a6f26d6c21bc2f0b4b..0000000000000000000000000000000000000000
--- a/20221017/string-ops-16.c
+++ /dev/null
@@ -1,31 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-char *anton = "Anton";
-char *zacharias = "Zacharias";
-
-int main (void)
-{
- if (anton < zacharias)
- {
- printf ("Anton (%016zx) liegt weiter vorne im Speicher als Zacharias (%016zx).\n",
- anton, zacharias);
- for (int i = 0; i < 6 + 10; i++)
- printf ("%c", anton[i]);
- printf ("\n");
- }
- else
- {
- printf ("Zacharias (%016zx) liegt weiter vorne im Speicher als Anton (%016zx).\n",
- zacharias, anton);
- for (int i = 0; i < 6 + 10; i++)
- printf ("%c", zacharias[i]);
- printf ("\n");
- }
-
- return 0;
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-}
diff --git a/20221017/string-ops-17.c b/20221017/string-ops-17.c
deleted file mode 100644
index cd3a6272d0ddfe0c6f3d6f0144df40095a361549..0000000000000000000000000000000000000000
--- a/20221017/string-ops-17.c
+++ /dev/null
@@ -1,31 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-char *anton = "Zanton";
-char *zacharias = "Acharias";
-
-int main (void)
-{
- if (anton < zacharias)
- {
- printf ("Anton (%016zx) liegt weiter vorne im Speicher als Zacharias (%016zx).\n",
- anton, zacharias);
- for (int i = 0; i < 6 + 10; i++)
- printf ("%c", anton[i]);
- printf ("\n");
- }
- else
- {
- printf ("Zacharias (%016zx) liegt weiter vorne im Speicher als Anton (%016zx).\n",
- zacharias, anton);
- for (int i = 0; i < 6 + 10; i++)
- printf ("%c", zacharias[i]);
- printf ("\n");
- }
-
- return 0;
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-}
diff --git a/20221017/string-ops-18.c b/20221017/string-ops-18.c
deleted file mode 100644
index baf37b3e79e3057f17521efc31311189a830afbb..0000000000000000000000000000000000000000
--- a/20221017/string-ops-18.c
+++ /dev/null
@@ -1,31 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-char *anton = "Zanton";
-char *zacharias = "Acharias";
-
-int main (void)
-{
- if (anton < zacharias)
- {
- printf ("Anton (%016zx) liegt weiter vorne im Speicher als Zacharias (%016zx).\n",
- anton, zacharias);
- for (int i = 0; i < 6 + 10; i++)
- printf ("%c", zacharias[i]);
- printf ("\n");
- }
- else
- {
- printf ("Zacharias (%016zx) liegt weiter vorne im Speicher als Anton (%016zx).\n",
- zacharias, anton);
- for (int i = 0; i < 6 + 10; i++)
- printf ("%c", anton[i]);
- printf ("\n");
- }
-
- return 0;
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-}
diff --git a/20221017/string-ops-19.c b/20221017/string-ops-19.c
deleted file mode 100644
index 62a9f0df37321b5eec49a9de5d7661f9aa8d0021..0000000000000000000000000000000000000000
--- a/20221017/string-ops-19.c
+++ /dev/null
@@ -1,31 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-char *anton = "Zanton";
-char *zacharias = "Acharias";
-
-int main (void)
-{
- if (anton < zacharias)
- {
- printf ("Anton (%016zx) liegt weiter vorne im Speicher als Zacharias (%016zx).\n",
- anton, zacharias);
- for (int i = 0; i < 6 * 10; i++)
- printf ("%c", zacharias[i]);
- printf ("\n");
- }
- else
- {
- printf ("Zacharias (%016zx) liegt weiter vorne im Speicher als Anton (%016zx).\n",
- zacharias, anton);
- for (int i = 0; i < 6 * 10; i++)
- printf ("%c", anton[i]);
- printf ("\n");
- }
-
- return 0;
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-}
diff --git a/20221017/string-ops-20.c b/20221017/string-ops-20.c
deleted file mode 100644
index 03e024d01e5bf877fddeeb504e598fcdb41bc694..0000000000000000000000000000000000000000
--- a/20221017/string-ops-20.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-
-int main (void)
-{
- char *anton = "Anton";
- char *zacharias = "Zacharias";
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-
- return 0;
-}
diff --git a/20221017/string-ops-21.c b/20221017/string-ops-21.c
deleted file mode 100644
index 594601909cd8f0e260e3208cf5811d22b9d4122a..0000000000000000000000000000000000000000
--- a/20221017/string-ops-21.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-
-int main (void)
-{
- char *anton = "Anton";
-
- char buffer[100] = "Huber ";
- printf ("%s\n", buffer + anton);
-
- return 0;
-}
diff --git a/20221017/string-ops-22.c b/20221017/string-ops-22.c
deleted file mode 100644
index 7c0aacf68e3921750491f0465f6e29a1af05dadd..0000000000000000000000000000000000000000
--- a/20221017/string-ops-22.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-
-int main (void)
-{
- char *anton = "Anton";
-
- char buffer[100] = "Huber ";
- printf ("%s\n", buffer + (size_t) anton);
-
- return 0;
-}
diff --git a/20221017/string-ops-23.c b/20221017/string-ops-23.c
deleted file mode 100644
index fcc025bd59846119aef2c3d5b7ec83ea4c507e1b..0000000000000000000000000000000000000000
--- a/20221017/string-ops-23.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-
-int main (void)
-{
- char *anton = "Anton";
-
- char buffer[100] = "Huber ";
- printf ("%s\n", (char *) ((((size_t) buffer) + ((size_t) anton)) / 2));
-
- return 0;
-}
diff --git a/20221017/string-ops-24.c b/20221017/string-ops-24.c
deleted file mode 100644
index 9c3065113aece788f0461db4bd4707bcf8166ed4..0000000000000000000000000000000000000000
--- a/20221017/string-ops-24.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char anton[] = "Anton";
-
- char buffer[100] = "Huber ";
- printf ("%s\n", (char *) ((((size_t) buffer) + ((size_t) anton)) / 2));
-
- return 0;
-}
diff --git a/20221017/string-ops-25.c b/20221017/string-ops-25.c
deleted file mode 100644
index 45fdeeed2df23439397757af1817f12a743d5072..0000000000000000000000000000000000000000
--- a/20221017/string-ops-25.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char anton[] = "Anton";
-
- char buffer[] = "Huber ";
- printf ("%s\n", (char *) ((((size_t) buffer) + ((size_t) anton)) / 2));
-
- return 0;
-}
diff --git a/20221017/string-ops-26.c b/20221017/string-ops-26.c
deleted file mode 100644
index e0d2b837ea7e2f45395a76e4274e40917c0294b3..0000000000000000000000000000000000000000
--- a/20221017/string-ops-26.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char anton[] = "Anton";
- char buffer[] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-
- return 0;
-}
diff --git a/20221017/string-ops-27.c b/20221017/string-ops-27.c
deleted file mode 100644
index 26499716b01376b82f282494ff553a7f69674706..0000000000000000000000000000000000000000
--- a/20221017/string-ops-27.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char buffer[] = "Huber ";
- char anton[] = "Anton";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-
- return 0;
-}
diff --git a/20221017/string-ops-28.c b/20221017/string-ops-28.c
deleted file mode 100644
index 0b29dc578e3152bcee2524b1e0437dc1b9cb4fdd..0000000000000000000000000000000000000000
--- a/20221017/string-ops-28.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char buffer[] = "Huber ";
- char anton[] = "Anton";
- strncat (buffer, anton, sizeof (buffer));
- printf ("%s\n", buffer);
-
- return 0;
-}
diff --git a/20221017/strings-20.c b/20221017/strings-20.c
deleted file mode 100644
index 68227c25325d9699430cacc3d071c5dad629fb40..0000000000000000000000000000000000000000
--- a/20221017/strings-20.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char hello[] = "Hello, world!\n";
- printf ("%s", hello);
- return 0;
-}
diff --git a/20221017/strings-21.c b/20221017/strings-21.c
deleted file mode 100644
index c75e8485434dd0f3578ad93e7c574f466424e544..0000000000000000000000000000000000000000
--- a/20221017/strings-21.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char *hello = "Hello, world!\n";
- printf ("%s", hello);
- return 0;
-}
diff --git a/20221017/strings-22.c b/20221017/strings-22.c
deleted file mode 100644
index 73e417a3abe90db0bb6ce622d79eab3def11bcde..0000000000000000000000000000000000000000
--- a/20221017/strings-22.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char hello[] = "Hello!\n";
- hello[1] = 'a';
- printf ("%s", hello);
- return 0;
-}
diff --git a/20221017/strings-23.c b/20221017/strings-23.c
deleted file mode 100644
index 98bddafb3dea6ccefc966d7a6537a3df761d0953..0000000000000000000000000000000000000000
--- a/20221017/strings-23.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char *hello = "Hello!\n";
- hello[1] = 'a';
- printf ("%s", hello);
- return 0;
-}
diff --git a/20221017/strings-24.c b/20221017/strings-24.c
deleted file mode 100644
index 23d6aac897415e9f4f2e29eb6ab2c386acb2d911..0000000000000000000000000000000000000000
--- a/20221017/strings-24.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char *hello = "Hello!\n";
- hello = "Hallo!\n";
- printf ("%s", hello);
- return 0;
-}
diff --git a/20221017/strings-25.c b/20221017/strings-25.c
deleted file mode 100644
index 1c63f136d23cef03382cbde14b5e4144b009124b..0000000000000000000000000000000000000000
--- a/20221017/strings-25.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char hello[] = "Hello!\n";
- hello = "Hallo!\n";
- printf ("%s", hello);
- return 0;
-}
diff --git a/20221017/strings-26.c b/20221017/strings-26.c
deleted file mode 100644
index 281ee0463cf4c4172d942fcd02c3e9eba190c7b8..0000000000000000000000000000000000000000
--- a/20221017/strings-26.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char hello[] = "Hello!\n";
- strcpy (hello, "Hallo!\n");
- printf ("%s", hello);
- return 0;
-}
diff --git a/20221017/structs-01.c b/20221017/structs-01.c
deleted file mode 100644
index b0d790ead7b2e2dfb1e51d87547bc991e0919779..0000000000000000000000000000000000000000
--- a/20221017/structs-01.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- char day, month;
- int year;
-}
-date;
-
-int main (void)
-{
- date today = { 17, 10, 2022 };
- printf ("%d.%d.%d\n", today.day, today.month, today.year);
- return 0;
-}
diff --git a/20221017/structs-02.c b/20221017/structs-02.c
deleted file mode 100644
index 00e0bfecfc64464c668ba88e8a741481b919b574..0000000000000000000000000000000000000000
--- a/20221017/structs-02.c
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- char day, month;
- int year;
-}
-date;
-
-void set_date (date *d)
-{
- (*d).day = 17;
- (*d).month = 10;
- (*d).year = 2022;
-}
-
-int main (void)
-{
- date today;
- set_date (&today);
- printf ("%d.%d.%d\n", today.day, today.month, today.year);
- return 0;
-}
diff --git a/20221017/structs-03.c b/20221017/structs-03.c
deleted file mode 100644
index 7decf4b72015984f5c733873dfb6eb0c856f9f3b..0000000000000000000000000000000000000000
--- a/20221017/structs-03.c
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- char day, month;
- int year;
-}
-date;
-
-void set_date (date *d)
-{
- d->day = 17;
- d->month = 10;
- d->year = 2022;
-}
-
-int main (void)
-{
- date today;
- set_date (&today);
- printf ("%d.%d.%d\n", today.day, today.month, today.year);
- return 0;
-}
diff --git a/20221017/test-1.c b/20221017/test-1.c
deleted file mode 100644
index 9dcb8ff47664fe804b3c9973166afe0d28b53ade..0000000000000000000000000000000000000000
--- a/20221017/test-1.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- return
- printf ("Hello, world!\n"),
- 0;
-}
diff --git a/20221017/test-2.c b/20221017/test-2.c
deleted file mode 100644
index 216c924cde653228187b133b1a899765eb865584..0000000000000000000000000000000000000000
--- a/20221017/test-2.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 137;
- int b = 13 * a;
- if (b = 42)
- printf ("Die Antwort lautet: %d\n", b);
- else
- printf ("Die Antwort lautet: keine Ahnung\n");
- return 0;
-}
diff --git a/20221017/test-3.c b/20221017/test-3.c
deleted file mode 100644
index b8964c8308aec57ed4de30acae8c3e3d31b9fa38..0000000000000000000000000000000000000000
--- a/20221017/test-3.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 42;
- printf ("Die Antwort lautet: ");
- printf (a);
- return 0;
-}
diff --git a/20221017/uebung-20221010-aufgabe-4-01.c b/20221017/uebung-20221010-aufgabe-4-01.c
deleted file mode 100644
index b8b3de796fbef94bd4a86f944e1269b97e97982b..0000000000000000000000000000000000000000
--- a/20221017/uebung-20221010-aufgabe-4-01.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- for (int i = 10; i = 0; i - 1)
- printf ("%d\n", i);
- return 0;
-}
diff --git a/20221017/uebung-20221010-aufgabe-4-02.c b/20221017/uebung-20221010-aufgabe-4-02.c
deleted file mode 100644
index b62b1cbc67ca4edcee870b3643dbcff3780e0a6e..0000000000000000000000000000000000000000
--- a/20221017/uebung-20221010-aufgabe-4-02.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- for (int i = 10; i == 0; i - 1)
- printf ("%d\n", i);
- return 0;
-}
diff --git a/20221017/uebung-20221010-aufgabe-4-03.c b/20221017/uebung-20221010-aufgabe-4-03.c
deleted file mode 100644
index c5235c8dcbc8aac56b13aa0305b7cf49d84ed82f..0000000000000000000000000000000000000000
--- a/20221017/uebung-20221010-aufgabe-4-03.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- for (int i = 10; i >= 0; i - 1)
- printf ("%d\n", i);
- return 0;
-}
diff --git a/20221017/uebung-20221010-aufgabe-4-04.c b/20221017/uebung-20221010-aufgabe-4-04.c
deleted file mode 100644
index f27992d11dfbfb45702d23a8e7b21e1bbeef9518..0000000000000000000000000000000000000000
--- a/20221017/uebung-20221010-aufgabe-4-04.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- for (int i = 10; i >= 0; i = i - 1)
- printf ("%d\n", i);
- return 0;
-}
diff --git a/20221017/variables-01.c b/20221017/variables-01.c
deleted file mode 100644
index 141f046a673a4dbb0b09e0ee362eb98728d7d372..0000000000000000000000000000000000000000
--- a/20221017/variables-01.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-void foo (int a)
-{
- printf ("a = %d\n", a);
-}
-
-int main (void)
-{
- foo (137);
- foo ();
- return 0;
-}
diff --git a/20221017/variables-02.c b/20221017/variables-02.c
deleted file mode 100644
index 10b7d1e9bf4c08da4fff49614977f58135264506..0000000000000000000000000000000000000000
--- a/20221017/variables-02.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-
-void foo (a)
- int a;
-{
- printf ("a = %d\n", a);
-}
-
-int main (void)
-{
- foo (137);
- foo ();
- return 0;
-}
diff --git a/20221017/variables-03.c b/20221017/variables-03.c
deleted file mode 100644
index 99865a7759c4f30a6ca0a5f8e510529a9e303ffe..0000000000000000000000000000000000000000
--- a/20221017/variables-03.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-void foo (a)
- int a;
-{
- printf ("a = %d\n", a);
-}
-
-int main (void)
-{
- foo (137);
- printf ("Hallo?\n");
- foo ();
- return 0;
-}
diff --git a/20221017/void-01.c b/20221017/void-01.c
deleted file mode 100644
index 2daa2e6ad050466b49c9424736fabc415a2537ad..0000000000000000000000000000000000000000
--- a/20221017/void-01.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-int add_verbose (int a, int b)
-{
- printf ("%d + %d = %d\n", a, b, a + b);
- return a + b;
-}
-
-int main (void)
-{
- add_verbose (3, 7);
- return 0;
-}
diff --git a/20221017/void-02.c b/20221017/void-02.c
deleted file mode 100644
index 035859c89e3e3051d78deaf29178c72790d850dd..0000000000000000000000000000000000000000
--- a/20221017/void-02.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-void add_verbose (int a, int b)
-{
- printf ("%d + %d = %d\n", a, b, a + b);
-}
-
-int main (void)
-{
- int c = add_verbose (3, 7);
- printf ("c = %d \n", c);
- return 0;
-}
diff --git a/20221024/answer.c b/20221024/answer.c
deleted file mode 100644
index 65a1dc248becb3157f2a226fc7b30df2ffb82e00..0000000000000000000000000000000000000000
--- a/20221024/answer.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "answer.h"
-
-int answer (void)
-{
- return 23;
-}
diff --git a/20221024/answer.h b/20221024/answer.h
deleted file mode 100644
index b6777e8210983d315b3ac3424a61bd9c9f0437b1..0000000000000000000000000000000000000000
--- a/20221024/answer.h
+++ /dev/null
@@ -1 +0,0 @@
-extern int answer (void);
diff --git a/20221024/aufgabe-1.c b/20221024/aufgabe-1.c
deleted file mode 100644
index 632b4b796ae2f4060878a8870b9e7e55e5f064b9..0000000000000000000000000000000000000000
--- a/20221024/aufgabe-1.c
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <stdio.h>
-
-void f (int *s0, int *s1)
-{
- while (*s0 >= 0)
- {
- int *s = s1;
- while (*s >= 0)
- if (*s0 == *s++)
- printf ("%d ", *s0);
- s0++;
- }
- printf ("\n");
-}
-
-int main (void)
-{
- int a[] = { 10, 4, 3, 7, 12, 0, 1, -1 };
- int b[] = { 7, 14, 0, 8, 9, 22, 10, -1 };
- f (a, b);
- return 0;
-}
diff --git a/20221024/aufgabe-1c.c b/20221024/aufgabe-1c.c
deleted file mode 100644
index 9b6e7ab2ecfbddc16121acd229a13745182190c2..0000000000000000000000000000000000000000
--- a/20221024/aufgabe-1c.c
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <stdio.h>
-
-void f (int *s0, int *s1)
-{
- while (*s0 >= 0)
- {
- int *s = s1;
- while (*s >= 0)
- if (*s0 == *s++)
- printf ("%d ", *s0);
- s0++;
- }
- printf ("\n");
-}
-
-int main (void)
-{
- int a[] = { 10, 4, 3, 7, 12, 0, 1 };
- int b[] = { 7, 14, 0, 8, 9, 22, 10 };
- f (a, b);
- return 0;
-}
diff --git a/20221024/aufgabe-3.c b/20221024/aufgabe-3.c
deleted file mode 100644
index cd80c21b95b5a4c91a43a8b3e849f5e12db183c7..0000000000000000000000000000000000000000
--- a/20221024/aufgabe-3.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int n, i, divisors;
- for (n = 0; n < 100; n++)
- divisors = 0;
- for (i = 0; i < n; i++)
- if (n % i == 0)
- divisors++;
- if (divisors = 2)
- printf ("%d ist eine Primzahl.\n", n);
- return 0;
-}
diff --git a/20221024/constants-01.c b/20221024/constants-01.c
deleted file mode 100644
index 77c13753cad6cc9440b1e6fa76f2b0a4062e087a..0000000000000000000000000000000000000000
--- a/20221024/constants-01.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-
-#define N 5
-
-int main (void)
-{
- int prime[N] = { 2, 3, 5, 7, 11 };
- for (int i = 0; i < N; i++)
- printf ("%d\n", prime[i]);
- return 0;
-}
diff --git a/20221024/constants-02.c b/20221024/constants-02.c
deleted file mode 100644
index 19d92aed504318956e4b2a53cc85a525ba555257..0000000000000000000000000000000000000000
--- a/20221024/constants-02.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-
-const int N = 5;
-
-int main (void)
-{
- int prime[N] = { 2, 3, 5, 7, 11 };
- for (int i = 0; i < N; i++)
- printf ("%d\n", prime[i]);
- return 0;
-}
diff --git a/20221024/constants-02.txt b/20221024/constants-02.txt
deleted file mode 100644
index bf36ca587d37fe813d8d3cb0c8794b2401764e6a..0000000000000000000000000000000000000000
--- a/20221024/constants-02.txt
+++ /dev/null
@@ -1,44 +0,0 @@
-#include <stdio.h>
-
-const int N = 5;
-
-int main (void)
-{
- int prime[N] = { 2, 3, 5, 7, 11 };
- for (int i = 0; i < N; i++)
- printf ("%d\n", prime[i]);
- return 0;
-}
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O constants-02.c -o constants-02
-constants-02.c: In function ‘main’:
-constants-02.c:7:3: error: variable-sized object may not be initialized
- int prime[N] = { 2, 3, 5, 7, 11 };
- ^~~
-constants-02.c:7:20: warning: excess elements in array initializer
- int prime[N] = { 2, 3, 5, 7, 11 };
- ^
-constants-02.c:7:20: note: (near initialization for ‘prime’)
-constants-02.c:7:23: warning: excess elements in array initializer
- int prime[N] = { 2, 3, 5, 7, 11 };
- ^
-constants-02.c:7:23: note: (near initialization for ‘prime’)
-constants-02.c:7:26: warning: excess elements in array initializer
- int prime[N] = { 2, 3, 5, 7, 11 };
- ^
-constants-02.c:7:26: note: (near initialization for ‘prime’)
-constants-02.c:7:29: warning: excess elements in array initializer
- int prime[N] = { 2, 3, 5, 7, 11 };
- ^
-constants-02.c:7:29: note: (near initialization for ‘prime’)
-constants-02.c:7:32: warning: excess elements in array initializer
- int prime[N] = { 2, 3, 5, 7, 11 };
- ^~
-constants-02.c:7:32: note: (near initialization for ‘prime’)
-cassini/home/peter/bo/2022ws/hp/20221024> g++ -Wall -O constants-02.c -o constants-02
-cassini/home/peter/bo/2022ws/hp/20221024> ./constants-02
-2
-3
-5
-7
-11
-cassini/home/peter/bo/2022ws/hp/20221024>
diff --git a/20221024/gtk-01.c b/20221024/gtk-01.c
deleted file mode 100644
index 884a14ea528431e54f8391c801958a6e494dfe43..0000000000000000000000000000000000000000
--- a/20221024/gtk-01.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <gtk/gtk.h>
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- gtk_widget_show (window);
- gtk_main ();
- return 0;
-}
diff --git a/20221024/gtk-01.txt b/20221024/gtk-01.txt
deleted file mode 100644
index 330b209772656a51091cb317945ee7a8754b4439..0000000000000000000000000000000000000000
--- a/20221024/gtk-01.txt
+++ /dev/null
@@ -1,28 +0,0 @@
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O $(pkg-config --cflags gtk+-3.0) gtk-01.c -o gtk-01
-/usr/bin/ld: /tmp/ccgTelwD.o: in function `main':
-gtk-01.c:(.text+0x16): undefined reference to `gtk_init'
-/usr/bin/ld: gtk-01.c:(.text+0x20): undefined reference to `gtk_window_new'
-/usr/bin/ld: gtk-01.c:(.text+0x28): undefined reference to `gtk_window_get_type'
-/usr/bin/ld: gtk-01.c:(.text+0x33): undefined reference to `g_type_check_instance_cast'
-/usr/bin/ld: gtk-01.c:(.text+0x42): undefined reference to `gtk_window_set_title'
-/usr/bin/ld: gtk-01.c:(.text+0x4a): undefined reference to `gtk_widget_show'
-/usr/bin/ld: gtk-01.c:(.text+0x4f): undefined reference to `gtk_main'
-collect2: error: ld returned 1 exit status
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O $(pkg-config --cflags gtk+-3.0) gtk-01.c -c
-cassini/home/peter/bo/2022ws/hp/20221024> ./gtk-01
-bash: ./gtk-01: Datei oder Verzeichnis nicht gefunden
-cassini/home/peter/bo/2022ws/hp/20221024> ls -l gtk-01*
--rw-r--r-- 1 peter peter 256 Jan 4 2021 gtk-01.c
--rw-r--r-- 1 peter peter 2024 Okt 31 11:43 gtk-01.o
-cassini/home/peter/bo/2022ws/hp/20221024> gcc gtk-01.o -o gtek-01
-/usr/bin/ld: gtk-01.o: in function `main':
-gtk-01.c:(.text+0x16): undefined reference to `gtk_init'
-/usr/bin/ld: gtk-01.c:(.text+0x20): undefined reference to `gtk_window_new'
-/usr/bin/ld: gtk-01.c:(.text+0x28): undefined reference to `gtk_window_get_type'
-/usr/bin/ld: gtk-01.c:(.text+0x33): undefined reference to `g_type_check_instance_cast'
-/usr/bin/ld: gtk-01.c:(.text+0x42): undefined reference to `gtk_window_set_title'
-/usr/bin/ld: gtk-01.c:(.text+0x4a): undefined reference to `gtk_widget_show'
-/usr/bin/ld: gtk-01.c:(.text+0x4f): undefined reference to `gtk_main'
-collect2: error: ld returned 1 exit status
-cassini/home/peter/bo/2022ws/hp/20221024> gcc gtk-01.o $(pkg-config --libs gtk+-3.0) -o gtk-01
-cassini/home/peter/bo/2022ws/hp/20221024> ./gtk-01
\ No newline at end of file
diff --git a/20221024/gtk-02.c b/20221024/gtk-02.c
deleted file mode 100644
index c5db19f8d7e859ff12b08ffd6425b84deab35d07..0000000000000000000000000000000000000000
--- a/20221024/gtk-02.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <gtk/gtk.h>
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
-}
diff --git a/20221024/gtk-03.c b/20221024/gtk-03.c
deleted file mode 100644
index 26fcdd9bf83023b4f3e704a93218134149829f83..0000000000000000000000000000000000000000
--- a/20221024/gtk-03.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <gtk/gtk.h>
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (window), button);
- gtk_widget_show (button);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
-}
diff --git a/20221024/hello-01.E b/20221024/hello-01.E
deleted file mode 100644
index edf9f9fc1f6cf4f61af8edc584f3ea270ddc27b6..0000000000000000000000000000000000000000
--- a/20221024/hello-01.E
+++ /dev/null
@@ -1,815 +0,0 @@
-# 1 "hello-01.c"
-# 1 "<built-in>"
-# 1 "<command-line>"
-# 31 "<command-line>"
-# 1 "/usr/include/stdc-predef.h" 1 3 4
-# 32 "<command-line>" 2
-# 1 "hello-01.c"
-# 1 "/usr/include/stdio.h" 1 3 4
-# 27 "/usr/include/stdio.h" 3 4
-# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
-# 33 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 3 4
-# 1 "/usr/include/features.h" 1 3 4
-# 424 "/usr/include/features.h" 3 4
-# 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4
-# 442 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
-# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
-# 443 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
-# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4
-# 444 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
-# 425 "/usr/include/features.h" 2 3 4
-# 448 "/usr/include/features.h" 3 4
-# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 1 3 4
-# 10 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 3 4
-# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs-64.h" 1 3 4
-# 11 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4
-# 449 "/usr/include/features.h" 2 3 4
-# 34 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 2 3 4
-# 28 "/usr/include/stdio.h" 2 3 4
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-linux-gnu/8/include/stddef.h" 1 3 4
-# 216 "/usr/lib/gcc/x86_64-linux-gnu/8/include/stddef.h" 3 4
-
-# 216 "/usr/lib/gcc/x86_64-linux-gnu/8/include/stddef.h" 3 4
-typedef long unsigned int size_t;
-# 34 "/usr/include/stdio.h" 2 3 4
-
-
-# 1 "/usr/lib/gcc/x86_64-linux-gnu/8/include/stdarg.h" 1 3 4
-# 40 "/usr/lib/gcc/x86_64-linux-gnu/8/include/stdarg.h" 3 4
-typedef __builtin_va_list __gnuc_va_list;
-# 37 "/usr/include/stdio.h" 2 3 4
-
-# 1 "/usr/include/x86_64-linux-gnu/bits/types.h" 1 3 4
-# 27 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
-# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
-# 28 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
-
-
-typedef unsigned char __u_char;
-typedef unsigned short int __u_short;
-typedef unsigned int __u_int;
-typedef unsigned long int __u_long;
-
-
-typedef signed char __int8_t;
-typedef unsigned char __uint8_t;
-typedef signed short int __int16_t;
-typedef unsigned short int __uint16_t;
-typedef signed int __int32_t;
-typedef unsigned int __uint32_t;
-
-typedef signed long int __int64_t;
-typedef unsigned long int __uint64_t;
-
-
-
-
-
-
-typedef __int8_t __int_least8_t;
-typedef __uint8_t __uint_least8_t;
-typedef __int16_t __int_least16_t;
-typedef __uint16_t __uint_least16_t;
-typedef __int32_t __int_least32_t;
-typedef __uint32_t __uint_least32_t;
-typedef __int64_t __int_least64_t;
-typedef __uint64_t __uint_least64_t;
-
-
-
-typedef long int __quad_t;
-typedef unsigned long int __u_quad_t;
-
-
-
-
-
-
-
-typedef long int __intmax_t;
-typedef unsigned long int __uintmax_t;
-# 140 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
-# 1 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 1 3 4
-# 141 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
-
-
-typedef unsigned long int __dev_t;
-typedef unsigned int __uid_t;
-typedef unsigned int __gid_t;
-typedef unsigned long int __ino_t;
-typedef unsigned long int __ino64_t;
-typedef unsigned int __mode_t;
-typedef unsigned long int __nlink_t;
-typedef long int __off_t;
-typedef long int __off64_t;
-typedef int __pid_t;
-typedef struct { int __val[2]; } __fsid_t;
-typedef long int __clock_t;
-typedef unsigned long int __rlim_t;
-typedef unsigned long int __rlim64_t;
-typedef unsigned int __id_t;
-typedef long int __time_t;
-typedef unsigned int __useconds_t;
-typedef long int __suseconds_t;
-
-typedef int __daddr_t;
-typedef int __key_t;
-
-
-typedef int __clockid_t;
-
-
-typedef void * __timer_t;
-
-
-typedef long int __blksize_t;
-
-
-
-
-typedef long int __blkcnt_t;
-typedef long int __blkcnt64_t;
-
-
-typedef unsigned long int __fsblkcnt_t;
-typedef unsigned long int __fsblkcnt64_t;
-
-
-typedef unsigned long int __fsfilcnt_t;
-typedef unsigned long int __fsfilcnt64_t;
-
-
-typedef long int __fsword_t;
-
-typedef long int __ssize_t;
-
-
-typedef long int __syscall_slong_t;
-
-typedef unsigned long int __syscall_ulong_t;
-
-
-
-typedef __off64_t __loff_t;
-typedef char *__caddr_t;
-
-
-typedef long int __intptr_t;
-
-
-typedef unsigned int __socklen_t;
-
-
-
-
-typedef int __sig_atomic_t;
-# 39 "/usr/include/stdio.h" 2 3 4
-# 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 1 3 4
-
-
-
-
-# 1 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 1 3 4
-# 13 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 3 4
-typedef struct
-{
- int __count;
- union
- {
- unsigned int __wch;
- char __wchb[4];
- } __value;
-} __mbstate_t;
-# 6 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 2 3 4
-
-
-
-
-typedef struct _G_fpos_t
-{
- __off_t __pos;
- __mbstate_t __state;
-} __fpos_t;
-# 40 "/usr/include/stdio.h" 2 3 4
-# 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 1 3 4
-# 10 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 3 4
-typedef struct _G_fpos64_t
-{
- __off64_t __pos;
- __mbstate_t __state;
-} __fpos64_t;
-# 41 "/usr/include/stdio.h" 2 3 4
-# 1 "/usr/include/x86_64-linux-gnu/bits/types/__FILE.h" 1 3 4
-
-
-
-struct _IO_FILE;
-typedef struct _IO_FILE __FILE;
-# 42 "/usr/include/stdio.h" 2 3 4
-# 1 "/usr/include/x86_64-linux-gnu/bits/types/FILE.h" 1 3 4
-
-
-
-struct _IO_FILE;
-
-
-typedef struct _IO_FILE FILE;
-# 43 "/usr/include/stdio.h" 2 3 4
-# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h" 1 3 4
-# 35 "/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h" 3 4
-struct _IO_FILE;
-struct _IO_marker;
-struct _IO_codecvt;
-struct _IO_wide_data;
-
-
-
-
-typedef void _IO_lock_t;
-
-
-
-
-
-struct _IO_FILE
-{
- int _flags;
-
-
- char *_IO_read_ptr;
- char *_IO_read_end;
- char *_IO_read_base;
- char *_IO_write_base;
- char *_IO_write_ptr;
- char *_IO_write_end;
- char *_IO_buf_base;
- char *_IO_buf_end;
-
-
- char *_IO_save_base;
- char *_IO_backup_base;
- char *_IO_save_end;
-
- struct _IO_marker *_markers;
-
- struct _IO_FILE *_chain;
-
- int _fileno;
- int _flags2;
- __off_t _old_offset;
-
-
- unsigned short _cur_column;
- signed char _vtable_offset;
- char _shortbuf[1];
-
- _IO_lock_t *_lock;
-
-
-
-
-
-
-
- __off64_t _offset;
-
- struct _IO_codecvt *_codecvt;
- struct _IO_wide_data *_wide_data;
- struct _IO_FILE *_freeres_list;
- void *_freeres_buf;
- size_t __pad5;
- int _mode;
-
- char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
-};
-# 44 "/usr/include/stdio.h" 2 3 4
-# 52 "/usr/include/stdio.h" 3 4
-typedef __gnuc_va_list va_list;
-# 63 "/usr/include/stdio.h" 3 4
-typedef __off_t off_t;
-# 77 "/usr/include/stdio.h" 3 4
-typedef __ssize_t ssize_t;
-
-
-
-
-
-
-typedef __fpos_t fpos_t;
-# 133 "/usr/include/stdio.h" 3 4
-# 1 "/usr/include/x86_64-linux-gnu/bits/stdio_lim.h" 1 3 4
-# 134 "/usr/include/stdio.h" 2 3 4
-
-
-
-extern FILE *stdin;
-extern FILE *stdout;
-extern FILE *stderr;
-
-
-
-
-
-
-extern int remove (const char *__filename) __attribute__ ((__nothrow__ , __leaf__));
-
-extern int rename (const char *__old, const char *__new) __attribute__ ((__nothrow__ , __leaf__));
-
-
-
-extern int renameat (int __oldfd, const char *__old, int __newfd,
- const char *__new) __attribute__ ((__nothrow__ , __leaf__));
-# 173 "/usr/include/stdio.h" 3 4
-extern FILE *tmpfile (void) ;
-# 187 "/usr/include/stdio.h" 3 4
-extern char *tmpnam (char *__s) __attribute__ ((__nothrow__ , __leaf__)) ;
-
-
-
-
-extern char *tmpnam_r (char *__s) __attribute__ ((__nothrow__ , __leaf__)) ;
-# 204 "/usr/include/stdio.h" 3 4
-extern char *tempnam (const char *__dir, const char *__pfx)
- __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) ;
-
-
-
-
-
-
-
-extern int fclose (FILE *__stream);
-
-
-
-
-extern int fflush (FILE *__stream);
-# 227 "/usr/include/stdio.h" 3 4
-extern int fflush_unlocked (FILE *__stream);
-# 246 "/usr/include/stdio.h" 3 4
-extern FILE *fopen (const char *__restrict __filename,
- const char *__restrict __modes) ;
-
-
-
-
-extern FILE *freopen (const char *__restrict __filename,
- const char *__restrict __modes,
- FILE *__restrict __stream) ;
-# 279 "/usr/include/stdio.h" 3 4
-extern FILE *fdopen (int __fd, const char *__modes) __attribute__ ((__nothrow__ , __leaf__)) ;
-# 292 "/usr/include/stdio.h" 3 4
-extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
- __attribute__ ((__nothrow__ , __leaf__)) ;
-
-
-
-
-extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __attribute__ ((__nothrow__ , __leaf__)) ;
-
-
-
-
-
-extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
-
-
-
-extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
- int __modes, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
-
-
-
-
-extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
- size_t __size) __attribute__ ((__nothrow__ , __leaf__));
-
-
-extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
-
-
-
-
-
-
-
-extern int fprintf (FILE *__restrict __stream,
- const char *__restrict __format, ...);
-
-
-
-
-extern int printf (const char *__restrict __format, ...);
-
-extern int sprintf (char *__restrict __s,
- const char *__restrict __format, ...) __attribute__ ((__nothrow__));
-
-
-
-
-
-extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
- __gnuc_va_list __arg);
-
-
-
-
-extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
-
-extern int vsprintf (char *__restrict __s, const char *__restrict __format,
- __gnuc_va_list __arg) __attribute__ ((__nothrow__));
-
-
-
-extern int snprintf (char *__restrict __s, size_t __maxlen,
- const char *__restrict __format, ...)
- __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));
-
-extern int vsnprintf (char *__restrict __s, size_t __maxlen,
- const char *__restrict __format, __gnuc_va_list __arg)
- __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0)));
-# 379 "/usr/include/stdio.h" 3 4
-extern int vdprintf (int __fd, const char *__restrict __fmt,
- __gnuc_va_list __arg)
- __attribute__ ((__format__ (__printf__, 2, 0)));
-extern int dprintf (int __fd, const char *__restrict __fmt, ...)
- __attribute__ ((__format__ (__printf__, 2, 3)));
-
-
-
-
-
-
-
-extern int fscanf (FILE *__restrict __stream,
- const char *__restrict __format, ...) ;
-
-
-
-
-extern int scanf (const char *__restrict __format, ...) ;
-
-extern int sscanf (const char *__restrict __s,
- const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__));
-# 409 "/usr/include/stdio.h" 3 4
-extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf")
-
- ;
-extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf")
- ;
-extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) __asm__ ("" "__isoc99_sscanf") __attribute__ ((__nothrow__ , __leaf__))
-
- ;
-# 434 "/usr/include/stdio.h" 3 4
-extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
- __gnuc_va_list __arg)
- __attribute__ ((__format__ (__scanf__, 2, 0))) ;
-
-
-
-
-
-extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
- __attribute__ ((__format__ (__scanf__, 1, 0))) ;
-
-
-extern int vsscanf (const char *__restrict __s,
- const char *__restrict __format, __gnuc_va_list __arg)
- __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__scanf__, 2, 0)));
-# 457 "/usr/include/stdio.h" 3 4
-extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf")
-
-
-
- __attribute__ ((__format__ (__scanf__, 2, 0))) ;
-extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf")
-
- __attribute__ ((__format__ (__scanf__, 1, 0))) ;
-extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vsscanf") __attribute__ ((__nothrow__ , __leaf__))
-
-
-
- __attribute__ ((__format__ (__scanf__, 2, 0)));
-# 491 "/usr/include/stdio.h" 3 4
-extern int fgetc (FILE *__stream);
-extern int getc (FILE *__stream);
-
-
-
-
-
-extern int getchar (void);
-
-
-
-
-
-
-extern int getc_unlocked (FILE *__stream);
-extern int getchar_unlocked (void);
-# 516 "/usr/include/stdio.h" 3 4
-extern int fgetc_unlocked (FILE *__stream);
-# 527 "/usr/include/stdio.h" 3 4
-extern int fputc (int __c, FILE *__stream);
-extern int putc (int __c, FILE *__stream);
-
-
-
-
-
-extern int putchar (int __c);
-# 543 "/usr/include/stdio.h" 3 4
-extern int fputc_unlocked (int __c, FILE *__stream);
-
-
-
-
-
-
-
-extern int putc_unlocked (int __c, FILE *__stream);
-extern int putchar_unlocked (int __c);
-
-
-
-
-
-
-extern int getw (FILE *__stream);
-
-
-extern int putw (int __w, FILE *__stream);
-
-
-
-
-
-
-
-extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
- ;
-# 609 "/usr/include/stdio.h" 3 4
-extern __ssize_t __getdelim (char **__restrict __lineptr,
- size_t *__restrict __n, int __delimiter,
- FILE *__restrict __stream) ;
-extern __ssize_t getdelim (char **__restrict __lineptr,
- size_t *__restrict __n, int __delimiter,
- FILE *__restrict __stream) ;
-
-
-
-
-
-
-
-extern __ssize_t getline (char **__restrict __lineptr,
- size_t *__restrict __n,
- FILE *__restrict __stream) ;
-
-
-
-
-
-
-
-extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
-
-
-
-
-
-extern int puts (const char *__s);
-
-
-
-
-
-
-extern int ungetc (int __c, FILE *__stream);
-
-
-
-
-
-
-extern size_t fread (void *__restrict __ptr, size_t __size,
- size_t __n, FILE *__restrict __stream) ;
-
-
-
-
-extern size_t fwrite (const void *__restrict __ptr, size_t __size,
- size_t __n, FILE *__restrict __s);
-# 679 "/usr/include/stdio.h" 3 4
-extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
- size_t __n, FILE *__restrict __stream) ;
-extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
- size_t __n, FILE *__restrict __stream);
-
-
-
-
-
-
-
-extern int fseek (FILE *__stream, long int __off, int __whence);
-
-
-
-
-extern long int ftell (FILE *__stream) ;
-
-
-
-
-extern void rewind (FILE *__stream);
-# 713 "/usr/include/stdio.h" 3 4
-extern int fseeko (FILE *__stream, __off_t __off, int __whence);
-
-
-
-
-extern __off_t ftello (FILE *__stream) ;
-# 737 "/usr/include/stdio.h" 3 4
-extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
-
-
-
-
-extern int fsetpos (FILE *__stream, const fpos_t *__pos);
-# 763 "/usr/include/stdio.h" 3 4
-extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
-
-extern int feof (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
-
-extern int ferror (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
-
-
-
-extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
-extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
-extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
-
-
-
-
-
-
-
-extern void perror (const char *__s);
-
-
-
-
-
-# 1 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 1 3 4
-# 26 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 3 4
-extern int sys_nerr;
-extern const char *const sys_errlist[];
-# 788 "/usr/include/stdio.h" 2 3 4
-
-
-
-
-extern int fileno (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
-
-
-
-
-extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
-# 806 "/usr/include/stdio.h" 3 4
-extern FILE *popen (const char *__command, const char *__modes) ;
-
-
-
-
-
-extern int pclose (FILE *__stream);
-
-
-
-
-
-extern char *ctermid (char *__s) __attribute__ ((__nothrow__ , __leaf__));
-# 846 "/usr/include/stdio.h" 3 4
-extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
-
-
-
-extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
-
-
-extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
-# 864 "/usr/include/stdio.h" 3 4
-extern int __uflow (FILE *);
-extern int __overflow (FILE *, int);
-
-
-
-
-# 1 "/usr/include/x86_64-linux-gnu/bits/stdio.h" 1 3 4
-# 38 "/usr/include/x86_64-linux-gnu/bits/stdio.h" 3 4
-extern __inline __attribute__ ((__gnu_inline__)) int
-vprintf (const char *__restrict __fmt, __gnuc_va_list __arg)
-{
- return vfprintf (stdout, __fmt, __arg);
-}
-
-
-
-extern __inline __attribute__ ((__gnu_inline__)) int
-getchar (void)
-{
- return getc (stdin);
-}
-
-
-
-
-extern __inline __attribute__ ((__gnu_inline__)) int
-fgetc_unlocked (FILE *__fp)
-{
- return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
-}
-
-
-
-
-
-extern __inline __attribute__ ((__gnu_inline__)) int
-getc_unlocked (FILE *__fp)
-{
- return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
-}
-
-
-extern __inline __attribute__ ((__gnu_inline__)) int
-getchar_unlocked (void)
-{
- return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
-}
-
-
-
-
-extern __inline __attribute__ ((__gnu_inline__)) int
-putchar (int __c)
-{
- return putc (__c, stdout);
-}
-
-
-
-
-extern __inline __attribute__ ((__gnu_inline__)) int
-fputc_unlocked (int __c, FILE *__stream)
-{
- return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
-}
-
-
-
-
-
-extern __inline __attribute__ ((__gnu_inline__)) int
-putc_unlocked (int __c, FILE *__stream)
-{
- return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
-}
-
-
-extern __inline __attribute__ ((__gnu_inline__)) int
-putchar_unlocked (int __c)
-{
- return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
-}
-# 127 "/usr/include/x86_64-linux-gnu/bits/stdio.h" 3 4
-extern __inline __attribute__ ((__gnu_inline__)) int
-__attribute__ ((__nothrow__ , __leaf__)) feof_unlocked (FILE *__stream)
-{
- return (((__stream)->_flags & 0x0010) != 0);
-}
-
-
-extern __inline __attribute__ ((__gnu_inline__)) int
-__attribute__ ((__nothrow__ , __leaf__)) ferror_unlocked (FILE *__stream)
-{
- return (((__stream)->_flags & 0x0020) != 0);
-}
-# 871 "/usr/include/stdio.h" 2 3 4
-# 879 "/usr/include/stdio.h" 3 4
-
-# 2 "hello-01.c" 2
-
-
-# 3 "hello-01.c"
-int main (void)
-{
- printf ("Hello, world!\n");
- return 0;
-}
diff --git a/20221024/hello-01.EP b/20221024/hello-01.EP
deleted file mode 100644
index af4f56a1620eea8ac018f34a7e4a8021b467ed10..0000000000000000000000000000000000000000
--- a/20221024/hello-01.EP
+++ /dev/null
@@ -1,325 +0,0 @@
-
-typedef long unsigned int size_t;
-typedef __builtin_va_list __gnuc_va_list;
-typedef unsigned char __u_char;
-typedef unsigned short int __u_short;
-typedef unsigned int __u_int;
-typedef unsigned long int __u_long;
-typedef signed char __int8_t;
-typedef unsigned char __uint8_t;
-typedef signed short int __int16_t;
-typedef unsigned short int __uint16_t;
-typedef signed int __int32_t;
-typedef unsigned int __uint32_t;
-typedef signed long int __int64_t;
-typedef unsigned long int __uint64_t;
-typedef __int8_t __int_least8_t;
-typedef __uint8_t __uint_least8_t;
-typedef __int16_t __int_least16_t;
-typedef __uint16_t __uint_least16_t;
-typedef __int32_t __int_least32_t;
-typedef __uint32_t __uint_least32_t;
-typedef __int64_t __int_least64_t;
-typedef __uint64_t __uint_least64_t;
-typedef long int __quad_t;
-typedef unsigned long int __u_quad_t;
-typedef long int __intmax_t;
-typedef unsigned long int __uintmax_t;
-typedef unsigned long int __dev_t;
-typedef unsigned int __uid_t;
-typedef unsigned int __gid_t;
-typedef unsigned long int __ino_t;
-typedef unsigned long int __ino64_t;
-typedef unsigned int __mode_t;
-typedef unsigned long int __nlink_t;
-typedef long int __off_t;
-typedef long int __off64_t;
-typedef int __pid_t;
-typedef struct { int __val[2]; } __fsid_t;
-typedef long int __clock_t;
-typedef unsigned long int __rlim_t;
-typedef unsigned long int __rlim64_t;
-typedef unsigned int __id_t;
-typedef long int __time_t;
-typedef unsigned int __useconds_t;
-typedef long int __suseconds_t;
-typedef int __daddr_t;
-typedef int __key_t;
-typedef int __clockid_t;
-typedef void * __timer_t;
-typedef long int __blksize_t;
-typedef long int __blkcnt_t;
-typedef long int __blkcnt64_t;
-typedef unsigned long int __fsblkcnt_t;
-typedef unsigned long int __fsblkcnt64_t;
-typedef unsigned long int __fsfilcnt_t;
-typedef unsigned long int __fsfilcnt64_t;
-typedef long int __fsword_t;
-typedef long int __ssize_t;
-typedef long int __syscall_slong_t;
-typedef unsigned long int __syscall_ulong_t;
-typedef __off64_t __loff_t;
-typedef char *__caddr_t;
-typedef long int __intptr_t;
-typedef unsigned int __socklen_t;
-typedef int __sig_atomic_t;
-typedef struct
-{
- int __count;
- union
- {
- unsigned int __wch;
- char __wchb[4];
- } __value;
-} __mbstate_t;
-typedef struct _G_fpos_t
-{
- __off_t __pos;
- __mbstate_t __state;
-} __fpos_t;
-typedef struct _G_fpos64_t
-{
- __off64_t __pos;
- __mbstate_t __state;
-} __fpos64_t;
-struct _IO_FILE;
-typedef struct _IO_FILE __FILE;
-struct _IO_FILE;
-typedef struct _IO_FILE FILE;
-struct _IO_FILE;
-struct _IO_marker;
-struct _IO_codecvt;
-struct _IO_wide_data;
-typedef void _IO_lock_t;
-struct _IO_FILE
-{
- int _flags;
- char *_IO_read_ptr;
- char *_IO_read_end;
- char *_IO_read_base;
- char *_IO_write_base;
- char *_IO_write_ptr;
- char *_IO_write_end;
- char *_IO_buf_base;
- char *_IO_buf_end;
- char *_IO_save_base;
- char *_IO_backup_base;
- char *_IO_save_end;
- struct _IO_marker *_markers;
- struct _IO_FILE *_chain;
- int _fileno;
- int _flags2;
- __off_t _old_offset;
- unsigned short _cur_column;
- signed char _vtable_offset;
- char _shortbuf[1];
- _IO_lock_t *_lock;
- __off64_t _offset;
- struct _IO_codecvt *_codecvt;
- struct _IO_wide_data *_wide_data;
- struct _IO_FILE *_freeres_list;
- void *_freeres_buf;
- size_t __pad5;
- int _mode;
- char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
-};
-typedef __gnuc_va_list va_list;
-typedef __off_t off_t;
-typedef __ssize_t ssize_t;
-typedef __fpos_t fpos_t;
-extern FILE *stdin;
-extern FILE *stdout;
-extern FILE *stderr;
-extern int remove (const char *__filename) __attribute__ ((__nothrow__ , __leaf__));
-extern int rename (const char *__old, const char *__new) __attribute__ ((__nothrow__ , __leaf__));
-extern int renameat (int __oldfd, const char *__old, int __newfd,
- const char *__new) __attribute__ ((__nothrow__ , __leaf__));
-extern FILE *tmpfile (void) ;
-extern char *tmpnam (char *__s) __attribute__ ((__nothrow__ , __leaf__)) ;
-extern char *tmpnam_r (char *__s) __attribute__ ((__nothrow__ , __leaf__)) ;
-extern char *tempnam (const char *__dir, const char *__pfx)
- __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) ;
-extern int fclose (FILE *__stream);
-extern int fflush (FILE *__stream);
-extern int fflush_unlocked (FILE *__stream);
-extern FILE *fopen (const char *__restrict __filename,
- const char *__restrict __modes) ;
-extern FILE *freopen (const char *__restrict __filename,
- const char *__restrict __modes,
- FILE *__restrict __stream) ;
-extern FILE *fdopen (int __fd, const char *__modes) __attribute__ ((__nothrow__ , __leaf__)) ;
-extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
- __attribute__ ((__nothrow__ , __leaf__)) ;
-extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __attribute__ ((__nothrow__ , __leaf__)) ;
-extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
-extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
- int __modes, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
-extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
- size_t __size) __attribute__ ((__nothrow__ , __leaf__));
-extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
-extern int fprintf (FILE *__restrict __stream,
- const char *__restrict __format, ...);
-extern int printf (const char *__restrict __format, ...);
-extern int sprintf (char *__restrict __s,
- const char *__restrict __format, ...) __attribute__ ((__nothrow__));
-extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
- __gnuc_va_list __arg);
-extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
-extern int vsprintf (char *__restrict __s, const char *__restrict __format,
- __gnuc_va_list __arg) __attribute__ ((__nothrow__));
-extern int snprintf (char *__restrict __s, size_t __maxlen,
- const char *__restrict __format, ...)
- __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));
-extern int vsnprintf (char *__restrict __s, size_t __maxlen,
- const char *__restrict __format, __gnuc_va_list __arg)
- __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0)));
-extern int vdprintf (int __fd, const char *__restrict __fmt,
- __gnuc_va_list __arg)
- __attribute__ ((__format__ (__printf__, 2, 0)));
-extern int dprintf (int __fd, const char *__restrict __fmt, ...)
- __attribute__ ((__format__ (__printf__, 2, 3)));
-extern int fscanf (FILE *__restrict __stream,
- const char *__restrict __format, ...) ;
-extern int scanf (const char *__restrict __format, ...) ;
-extern int sscanf (const char *__restrict __s,
- const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__));
-extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf") ;
-extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf") ;
-extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) __asm__ ("" "__isoc99_sscanf") __attribute__ ((__nothrow__ , __leaf__));
-extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
- __gnuc_va_list __arg)
- __attribute__ ((__format__ (__scanf__, 2, 0))) ;
-extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
- __attribute__ ((__format__ (__scanf__, 1, 0))) ;
-extern int vsscanf (const char *__restrict __s,
- const char *__restrict __format, __gnuc_va_list __arg)
- __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__scanf__, 2, 0)));
-extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf")
- __attribute__ ((__format__ (__scanf__, 2, 0))) ;
-extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf")
- __attribute__ ((__format__ (__scanf__, 1, 0))) ;
-extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vsscanf") __attribute__ ((__nothrow__ , __leaf__))
- __attribute__ ((__format__ (__scanf__, 2, 0)));
-extern int fgetc (FILE *__stream);
-extern int getc (FILE *__stream);
-extern int getchar (void);
-extern int getc_unlocked (FILE *__stream);
-extern int getchar_unlocked (void);
-extern int fgetc_unlocked (FILE *__stream);
-extern int fputc (int __c, FILE *__stream);
-extern int putc (int __c, FILE *__stream);
-extern int putchar (int __c);
-extern int fputc_unlocked (int __c, FILE *__stream);
-extern int putc_unlocked (int __c, FILE *__stream);
-extern int putchar_unlocked (int __c);
-extern int getw (FILE *__stream);
-extern int putw (int __w, FILE *__stream);
-extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
- ;
-extern __ssize_t __getdelim (char **__restrict __lineptr,
- size_t *__restrict __n, int __delimiter,
- FILE *__restrict __stream) ;
-extern __ssize_t getdelim (char **__restrict __lineptr,
- size_t *__restrict __n, int __delimiter,
- FILE *__restrict __stream) ;
-extern __ssize_t getline (char **__restrict __lineptr,
- size_t *__restrict __n,
- FILE *__restrict __stream) ;
-extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
-extern int puts (const char *__s);
-extern int ungetc (int __c, FILE *__stream);
-extern size_t fread (void *__restrict __ptr, size_t __size,
- size_t __n, FILE *__restrict __stream) ;
-extern size_t fwrite (const void *__restrict __ptr, size_t __size,
- size_t __n, FILE *__restrict __s);
-extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
- size_t __n, FILE *__restrict __stream) ;
-extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
- size_t __n, FILE *__restrict __stream);
-extern int fseek (FILE *__stream, long int __off, int __whence);
-extern long int ftell (FILE *__stream) ;
-extern void rewind (FILE *__stream);
-extern int fseeko (FILE *__stream, __off_t __off, int __whence);
-extern __off_t ftello (FILE *__stream) ;
-extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
-extern int fsetpos (FILE *__stream, const fpos_t *__pos);
-extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
-extern int feof (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
-extern int ferror (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
-extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
-extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
-extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
-extern void perror (const char *__s);
-extern int sys_nerr;
-extern const char *const sys_errlist[];
-extern int fileno (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
-extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
-extern FILE *popen (const char *__command, const char *__modes) ;
-extern int pclose (FILE *__stream);
-extern char *ctermid (char *__s) __attribute__ ((__nothrow__ , __leaf__));
-extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
-extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
-extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
-extern int __uflow (FILE *);
-extern int __overflow (FILE *, int);
-extern __inline __attribute__ ((__gnu_inline__)) int
-vprintf (const char *__restrict __fmt, __gnuc_va_list __arg)
-{
- return vfprintf (stdout, __fmt, __arg);
-}
-extern __inline __attribute__ ((__gnu_inline__)) int
-getchar (void)
-{
- return getc (stdin);
-}
-extern __inline __attribute__ ((__gnu_inline__)) int
-fgetc_unlocked (FILE *__fp)
-{
- return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
-}
-extern __inline __attribute__ ((__gnu_inline__)) int
-getc_unlocked (FILE *__fp)
-{
- return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
-}
-extern __inline __attribute__ ((__gnu_inline__)) int
-getchar_unlocked (void)
-{
- return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
-}
-extern __inline __attribute__ ((__gnu_inline__)) int
-putchar (int __c)
-{
- return putc (__c, stdout);
-}
-extern __inline __attribute__ ((__gnu_inline__)) int
-fputc_unlocked (int __c, FILE *__stream)
-{
- return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
-}
-extern __inline __attribute__ ((__gnu_inline__)) int
-putc_unlocked (int __c, FILE *__stream)
-{
- return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
-}
-extern __inline __attribute__ ((__gnu_inline__)) int
-putchar_unlocked (int __c)
-{
- return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
-}
-extern __inline __attribute__ ((__gnu_inline__)) int
-__attribute__ ((__nothrow__ , __leaf__)) feof_unlocked (FILE *__stream)
-{
- return (((__stream)->_flags & 0x0010) != 0);
-}
-extern __inline __attribute__ ((__gnu_inline__)) int
-__attribute__ ((__nothrow__ , __leaf__)) ferror_unlocked (FILE *__stream)
-{
- return (((__stream)->_flags & 0x0020) != 0);
-}
-
-int main (void)
-{
- printf ("Hello, world!\n");
- return 0;
-}
diff --git a/20221024/hello-01.c b/20221024/hello-01.c
deleted file mode 100644
index b19d80e9bd0bd7c5ed8f54b20c6a50d9166f03ac..0000000000000000000000000000000000000000
--- a/20221024/hello-01.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Hello, world!\n");
- return 0;
-}
diff --git a/20221024/hello-01.s b/20221024/hello-01.s
deleted file mode 100644
index cb01acba7d1f0e09cf72a12a32af03fc5c685059..0000000000000000000000000000000000000000
--- a/20221024/hello-01.s
+++ /dev/null
@@ -1,24 +0,0 @@
- .file "hello-01.c"
- .text
- .section .rodata.str1.1,"aMS",@progbits,1
-.LC0:
- .string "Hello, world!"
- .text
- .globl main
- .type main, @function
-main:
-.LFB11:
- .cfi_startproc
- subq $8, %rsp
- .cfi_def_cfa_offset 16
- leaq .LC0(%rip), %rdi
- call puts@PLT
- movl $0, %eax
- addq $8, %rsp
- .cfi_def_cfa_offset 8
- ret
- .cfi_endproc
-.LFE11:
- .size main, .-main
- .ident "GCC: (Debian 8.3.0-6) 8.3.0"
- .section .note.GNU-stack,"",@progbits
diff --git a/20221024/hello-01.txt b/20221024/hello-01.txt
deleted file mode 100644
index 31f96669f3ea83924355a1c5f97b63bceaaf7c43..0000000000000000000000000000000000000000
--- a/20221024/hello-01.txt
+++ /dev/null
@@ -1,41 +0,0 @@
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O hello-01.c -o hello-01
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -v -Wall -O hello-01.c -o hello-01
-Using built-in specs.
-COLLECT_GCC=gcc
-COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/8/lto-wrapper
-OFFLOAD_TARGET_NAMES=nvptx-none
-OFFLOAD_TARGET_DEFAULT=1
-Target: x86_64-linux-gnu
-Configured with: ../src/configure -v --with-pkgversion='Debian 8.3.0-6' --with-bugurl=file:///usr/share/doc/gcc-8/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++ --prefix=/usr --with-gcc-major-version-only --program-suffix=-8 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-libmpx --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
-Thread model: posix
-gcc version 8.3.0 (Debian 8.3.0-6)
-COLLECT_GCC_OPTIONS='-v' '-Wall' '-O' '-o' 'hello-01' '-mtune=generic' '-march=x86-64'
- /usr/lib/gcc/x86_64-linux-gnu/8/cc1 -quiet -v -imultiarch x86_64-linux-gnu hello-01.c -quiet -dumpbase hello-01.c -mtune=generic -march=x86-64 -auxbase hello-01 -O -Wall -version -o /tmp/ccgLD8oO.s
-GNU C17 (Debian 8.3.0-6) version 8.3.0 (x86_64-linux-gnu)
- compiled by GNU C version 8.3.0, GMP version 6.1.2, MPFR version 4.0.2, MPC version 1.1.0, isl version isl-0.20-GMP
-
-GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
-ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"
-ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/8/../../../../x86_64-linux-gnu/include"
-#include "..." search starts here:
-#include <...> search starts here:
- /usr/lib/gcc/x86_64-linux-gnu/8/include
- /usr/local/include
- /usr/lib/gcc/x86_64-linux-gnu/8/include-fixed
- /usr/include/x86_64-linux-gnu
- /usr/include
-End of search list.
-GNU C17 (Debian 8.3.0-6) version 8.3.0 (x86_64-linux-gnu)
- compiled by GNU C version 8.3.0, GMP version 6.1.2, MPFR version 4.0.2, MPC version 1.1.0, isl version isl-0.20-GMP
-
-GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
-Compiler executable checksum: 694977f912fd7ca2c14d66a7306be21c
-COLLECT_GCC_OPTIONS='-v' '-Wall' '-O' '-o' 'hello-01' '-mtune=generic' '-march=x86-64'
- as -v --64 -o /tmp/cc0fYgdQ.o /tmp/ccgLD8oO.s
-GNU assembler version 2.31.1 (x86_64-linux-gnu) using BFD version (GNU Binutils for Debian) 2.31.1
-COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/
-LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../:/lib/:/usr/lib/
-COLLECT_GCC_OPTIONS='-v' '-Wall' '-O' '-o' 'hello-01' '-mtune=generic' '-march=x86-64'
- /usr/lib/gcc/x86_64-linux-gnu/8/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/8/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/8/lto-wrapper -plugin-opt=-fresolution=/tmp/cc2nIv2R.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o hello-01 /usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/8/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/8 -L/usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/8/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/8/../../.. /tmp/cc0fYgdQ.o -lgcc --push-state --as-needed -lgcc_s --pop-state -lc -lgcc --push-state --as-needed -lgcc_s --pop-state /usr/lib/gcc/x86_64-linux-gnu/8/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/crtn.o
-COLLECT_GCC_OPTIONS='-v' '-Wall' '-O' '-o' 'hello-01' '-mtune=generic' '-march=x86-64'
-cassini/home/peter/bo/2022ws/hp/20221024>
diff --git a/20221024/hello-02.c b/20221024/hello-02.c
deleted file mode 100644
index 304452b8c501faf03fbd0afaa267e6ef0172807e..0000000000000000000000000000000000000000
--- a/20221024/hello-02.c
+++ /dev/null
@@ -1,7 +0,0 @@
-extern int printf (const char *__restrict __format, ...);
-
-int main (void)
-{
- printf ("Hello, world!\n");
- return 0;
-}
diff --git a/20221024/hello-02.s b/20221024/hello-02.s
deleted file mode 100644
index d1d17acda44e10d9d3f6902227b9d82b970b35c0..0000000000000000000000000000000000000000
--- a/20221024/hello-02.s
+++ /dev/null
@@ -1,24 +0,0 @@
- .file "hello-02.c"
- .text
- .section .rodata.str1.1,"aMS",@progbits,1
-.LC0:
- .string "Hello, world!"
- .text
- .globl main
- .type main, @function
-main:
-.LFB0:
- .cfi_startproc
- subq $8, %rsp
- .cfi_def_cfa_offset 16
- leaq .LC0(%rip), %rdi
- call puts@PLT
- movl $0, %eax
- addq $8, %rsp
- .cfi_def_cfa_offset 8
- ret
- .cfi_endproc
-.LFE0:
- .size main, .-main
- .ident "GCC: (Debian 8.3.0-6) 8.3.0"
- .section .note.GNU-stack,"",@progbits
diff --git a/20221024/hello-gtk.c b/20221024/hello-gtk.c
deleted file mode 100644
index 016867d41e42de57390a21653de467c061e5ded0..0000000000000000000000000000000000000000
--- a/20221024/hello-gtk.c
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <gtk/gtk.h>
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
- gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
- GtkWidget *label = gtk_label_new ("Hello, world!");
- gtk_container_add (GTK_CONTAINER (vbox), label);
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
- gtk_widget_show (button);
- gtk_widget_show (label);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
-}
diff --git a/20221024/hello-gtk.txt b/20221024/hello-gtk.txt
deleted file mode 100644
index 26f616a6eda80c7ef47fa961d9f1110bdc0ae227..0000000000000000000000000000000000000000
--- a/20221024/hello-gtk.txt
+++ /dev/null
@@ -1,92 +0,0 @@
-#include <gtk/gtk.h>
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
- gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
- GtkWidget *label = gtk_label_new ("Hello, world!");
- gtk_container_add (GTK_CONTAINER (vbox), label);
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
- gtk_widget_show (button);
- gtk_widget_show (label);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
-}
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O hello-gtk.c -o hello-gtk
-hello-gtk.c:1:10: fatal error: gtk/gtk.h: Datei oder Verzeichnis nicht gefunden
- #include <gtk/gtk.h>
- ^~~~~~~~~~~
-compilation terminated.
-cassini/home/peter/bo/2022ws/hp/20221024> locate gtk.h
-/usr/include/gtk-2.0/gtk/gtk.h
-/usr/include/gtk-3.0/gtk/gtk.h
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -I /usr/include/gtk-3.0 -Wall -O hello-gtk.c -o hello-gtk
-In file included from /usr/include/gtk-3.0/gdk/gdk.h:30,
- from /usr/include/gtk-3.0/gtk/gtk.h:30,
- from hello-gtk.c:1:
-/usr/include/gtk-3.0/gdk/gdkconfig.h:13:10: fatal error: glib.h: Datei oder Verzeichnis nicht gefunden
- #include <glib.h>
- ^~~~~~~~
-compilation terminated.
-cassini/home/peter/bo/2022ws/hp/20221024> locate glib.h
-/home/peter/bo/2012ws/rtech/material/usbstick/fdos/source/command/command/suppl/msglib.h
-/usr/include/jpeglib.h
-/usr/include/dbus-1.0/dbus/dbus-glib.h
-/usr/include/glib-2.0/glib.h
-/usr/include/harfbuzz/hb-glib.h
-/usr/include/reglib/reglib.h
-/usr/src/linux-headers-4.19.0-21-amd64/include/config/blk/dev/bsglib.h
-/usr/src/linux-headers-4.19.0-22-amd64/include/config/blk/dev/bsglib.h
-/usr/src/linux-headers-4.19.0-8-amd64/include/config/blk/dev/bsglib.h
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -I /usr/include/glib-2.0 -I /usr/include/gtk-3.0 -Wall -O hello-gtk.c -o hello-gtk
-In file included from /usr/include/glib-2.0/glib/galloca.h:32,
- from /usr/include/glib-2.0/glib.h:30,
- from /usr/include/gtk-3.0/gdk/gdkconfig.h:13,
- from /usr/include/gtk-3.0/gdk/gdk.h:30,
- from /usr/include/gtk-3.0/gtk/gtk.h:30,
- from hello-gtk.c:1:
-/usr/include/glib-2.0/glib/gtypes.h:32:10: fatal error: glibconfig.h: Datei oder Verzeichnis nicht gefunden
- #include <glibconfig.h>
- ^~~~~~~~~~~~~~
-compilation terminated.
-cassini/home/peter/bo/2022ws/hp/20221024>
-cassini/home/peter/bo/2022ws/hp/20221024> pkg-config
-Must specify package names on the command line
-cassini/home/peter/bo/2022ws/hp/20221024> pkg-config gtk+-3.0
-cassini/home/peter/bo/2022ws/hp/20221024> pkg-config --cflags gtk+-3.0
--pthread -I/usr/include/gtk-3.0 -I/usr/include/at-spi2-atk/2.0 -I/usr/include/at-spi-2.0 -I/usr/include/dbus-1.0 -I/usr/lib/x86_64-linux-gnu/dbus-1.0/include -I/usr/include/gtk-3.0 -I/usr/include/gio-unix-2.0 -I/usr/include/cairo -I/usr/include/libdrm -I/usr/include/pango-1.0 -I/usr/include/harfbuzz -I/usr/include/pango-1.0 -I/usr/include/fribidi -I/usr/include/atk-1.0 -I/usr/include/cairo -I/usr/include/pixman-1 -I/usr/include/freetype2 -I/usr/include/libpng16 -I/usr/include/gdk-pixbuf-2.0 -I/usr/include/libmount -I/usr/include/blkid -I/usr/include/uuid -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include
-cassini/home/peter/bo/2022ws/hp/20221024> pkg-config --libs gtk+-3.0
--lgtk-3 -lgdk-3 -lpangocairo-1.0 -lpango-1.0 -latk-1.0 -lcairo-gobject -lcairo -lgdk_pixbuf-2.0 -lgio-2.0 -lgobject-2.0 -lglib-2.0
-cassini/home/peter/bo/2022ws/hp/20221024> pkg-config --cflags --libs gtk+-3.0
--pthread -I/usr/include/gtk-3.0 -I/usr/include/at-spi2-atk/2.0 -I/usr/include/at-spi-2.0 -I/usr/include/dbus-1.0 -I/usr/lib/x86_64-linux-gnu/dbus-1.0/include -I/usr/include/gtk-3.0 -I/usr/include/gio-unix-2.0 -I/usr/include/cairo -I/usr/include/libdrm -I/usr/include/pango-1.0 -I/usr/include/harfbuzz -I/usr/include/pango-1.0 -I/usr/include/fribidi -I/usr/include/atk-1.0 -I/usr/include/cairo -I/usr/include/pixman-1 -I/usr/include/freetype2 -I/usr/include/libpng16 -I/usr/include/gdk-pixbuf-2.0 -I/usr/include/libmount -I/usr/include/blkid -I/usr/include/uuid -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -lgtk-3 -lgdk-3 -lpangocairo-1.0 -lpango-1.0 -latk-1.0 -lcairo-gobject -lcairo -lgdk_pixbuf-2.0 -lgio-2.0 -lgobject-2.0 -lglib-2.0
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O -pthread -I/usr/include/gtk-3.0 -I/usr/include/at-spi2-atk/2.0 -I/usr/include/at-spi-2.0 -I/usr/include/dbus-1.0 -I/usr/lib/x86_64-linux-gnu/dbus-1.0/include -I/usr/include/gtk-3.0 -I/usr/include/gio-unix-2.0 -I/usr/include/cairo -I/usr/include/libdrm -I/usr/include/pango-1.0 -I/usr/include/harfbuzz -I/usr/include/pango-1.0 -I/usr/include/fribidi -I/usr/include/atk-1.0 -I/usr/include/cairo -I/usr/include/pixman-1 -I/usr/include/freetype2 -I/usr/include/libpng16 -I/usr/include/gdk-pixbuf-2.0 -I/usr/include/libmount -I/usr/include/blkid -I/usr/include/uuid -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -lgtk-3 -lgdk-3 -lpangocairo-1.0 -lpango-1.0 -latk-1.0 -lcairo-gobject -lcairo -lgdk_pixbuf-2.0 -lgio-2.0 -lgobject-2.0 -lglib-2.0 hello-
-hello-01 hello-01.E hello-01.s hello-02 hello-02.s hello-gtk.txt
-hello-01.c hello-01.EP hello-01.txt hello-02.c hello-gtk.c
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O -pthread -I/usr/include/gtk-3.0 -I/usr/include/at-spi2-atk/2.0 -I/usr/include/at-spi-2.0 -I/usr/include/dbus-1.0 -I/usr/lib/x86_64-linux-gnu/dbus-1.0/include -I/usr/include/gtk-3.0 -I/usr/include/gio-unix-2.0 -I/usr/include/cairo -I/usr/include/libdrm -I/usr/include/pango-1.0 -I/usr/include/harfbuzz -I/usr/include/pango-1.0 -I/usr/include/fribidi -I/usr/include/atk-1.0 -I/usr/include/cairo -I/usr/include/pixman-1 -I/usr/include/freetype2 -I/usr/include/libpng16 -I/usr/include/gdk-pixbuf-2.0 -I/usr/include/libmount -I/usr/include/blkid -I/usr/include/uuid -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -lgtk-3 -lgdk-3 -lpangocairo-1.0 -lpango-1.0 -latk-1.0 -lcairo-gobject -lcairo -lgdk_pixbuf-2.0 -lgio-2.0 -lgobject-2.0 -lglib-2.0 hello-
-hello-01 hello-01.E hello-01.s hello-02 hello-02.s hello-gtk.txt
-hello-01.c hello-01.EP hello-01.txt hello-02.c hello-gtk.c
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O -pthread -I/usr/include/gtk-3.0 -I/usr/include/at-spi2-atk/2.0 -I/usr/include/at-spi-2.0 -I/usr/include/dbus-1.0 -I/usr/lib/x86_64-linux-gnu/dbus-1.0/include -I/usr/include/gtk-3.0 -I/usr/include/gio-unix-2.0 -I/usr/include/cairo -I/usr/include/libdrm -I/usr/include/pango-1.0 -I/usr/include/harfbuzz -I/usr/include/pango-1.0 -I/usr/include/fribidi -I/usr/include/atk-1.0 -I/usr/include/cairo -I/usr/include/pixman-1 -I/usr/include/freetype2 -I/usr/include/libpng16 -I/usr/include/gdk-pixbuf-2.0 -I/usr/include/libmount -I/usr/include/blkid -I/usr/include/uuid -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -lgtk-3 -lgdk-3 -lpangocairo-1.0 -lpango-1.0 -latk-1.0 -lcairo-gobject -lcairo -lgdk_pixbuf-2.0 -lgio-2.0 -lgobject-2.0 -lglib-2.0 hello-
-hello-01 hello-01.E hello-01.s hello-02 hello-02.s hello-gtk.txt
-hello-01.c hello-01.EP hello-01.txt hello-02.c hello-gtk.c
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O -pthread -I/usr/include/gtk-3.0 -I/usr/include/at-spi2-atk/2.0 -I/usr/include/at-spi-2.0 -I/usr/include/dbus-1.0 -I/usr/lib/x86_64-linux-gnu/dbus-1.0/include -I/usr/include/gtk-3.0 -I/usr/include/gio-unix-2.0 -I/usr/include/cairo -I/usr/include/libdrm -I/usr/include/pango-1.0 -I/usr/include/harfbuzz -I/usr/include/pango-1.0 -I/usr/include/fribidi -I/usr/include/atk-1.0 -I/usr/include/cairo -I/usr/include/pixman-1 -I/usr/include/freetype2 -I/usr/include/libpng16 -I/usr/include/gdk-pixbuf-2.0 -I/usr/include/libmount -I/usr/include/blkid -I/usr/include/uuid -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -lgtk-3 -lgdk-3 -lpangocairo-1.0 -lpango-1.0 -latk-1.0 -lcairo-gobject -lcairo -lgdk_pixbuf-2.0 -lgio-2.0 -lgobject-2.0 -lglib-2.0 hello-gtk.c -o hello-gtk
-cassini/home/peter/bo/2022ws/hp/20221024> ./hello-gtk
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O $(pkg-config --cflags --libs gtk+-2.0) -o hello-gtk /usr/bin/ld: /usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/Scrt1.o: in function `_start': (.text+0x20): undefined reference to `main' collect2: error: ld returned 1 exit status cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O $(pkg-config --cflags --libs gtk+-2.0) hello-gtk.c -o hello-gtk hello-gtk.c: In function ‘main’: hello-gtk.c:9:21: warning: implicit declaration of function ‘gtk_box_new’; did you mean ‘gtk_hbox_new’? [-Wimplicit-function-declaration]
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- ^~~~~~~~~~~
- gtk_hbox_new
-hello-gtk.c:9:21: warning: initialization of ‘GtkWidget *’ {aka ‘struct _GtkWidget *’} from int’ makes pointer from integer without a cast [-Wint-conversion]
-/usr/bin/ld: /tmp/ccxhf5CJ.o: in function `main':
-hello-gtk.c:(.text+0x89): undefined reference to `gtk_box_new'
-collect2: error: ld returned 1 exit status
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O $(pkg-config --cflags --libs gtk+-3.0) hello-gtk.c -o hello-gtk
-cassini/home/peter/bo/2022ws/hp/20221024> ./hello-gtk
-cassini/home/peter/bo/2022ws/hp/20221024>
diff --git a/20221024/hexe.h b/20221024/hexe.h
deleted file mode 100644
index 2b98e2bb0231a5114084d64430290fea93281edc..0000000000000000000000000000000000000000
--- a/20221024/hexe.h
+++ /dev/null
@@ -1 +0,0 @@
-eine kleine Hexe.
diff --git a/20221024/higher-math-01.c b/20221024/higher-math-01.c
deleted file mode 100644
index 0d1a61a7f3f115e878707bf9ab97d8536e46e9bb..0000000000000000000000000000000000000000
--- a/20221024/higher-math-01.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-#define VIER 4
-
-int main (void)
-{
- printf ("2 + 2 = %d\n", VIER);
- return 0;
-}
diff --git a/20221024/higher-math-02.c b/20221024/higher-math-02.c
deleted file mode 100644
index 4f8bfec89f2f1d3a82ee0911dadee9d3955bed50..0000000000000000000000000000000000000000
--- a/20221024/higher-math-02.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-
-#define wuppdich printf
-#define holla main
-#define pruzzel return
-#define VIER 4
-
-int holla (void)
-{
- wuppdich ("2 + 2 = %d\n", VIER);
- pruzzel 0;
-}
diff --git a/20221024/higher-math-03.c b/20221024/higher-math-03.c
deleted file mode 100644
index 0774461371a771e36ef4682648194a3161f4e1b6..0000000000000000000000000000000000000000
--- a/20221024/higher-math-03.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-#define VIER 2 + 2
-
-int main (void)
-{
- printf ("2 + 3 * 4 = %d\n", 2 + 3 * VIER);
- return 0;
-}
diff --git a/20221024/higher-math-04.c b/20221024/higher-math-04.c
deleted file mode 100644
index 66907e2c7865f7e345f31376748ebfd62134fa43..0000000000000000000000000000000000000000
--- a/20221024/higher-math-04.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-#define VIER (2 + 2)
-
-int main (void)
-{
- printf ("2 + 3 * 4 = %d\n", 2 + 3 * VIER);
- return 0;
-}
diff --git a/20221024/higher-math-05.c b/20221024/higher-math-05.c
deleted file mode 100644
index 77a4e4ccc520044f3be85c473f440f313ac9f0fa..0000000000000000000000000000000000000000
--- a/20221024/higher-math-05.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-#define VIER (2 + 2));
-
-int main (void)
-{
- printf ("2 + 3 * 4 = %d\n", 2 + 3 * VIER
- return 0;
-}
diff --git a/20221024/hp-20221024.pdf b/20221024/hp-20221024.pdf
deleted file mode 100644
index c3030d4513a8e4e1273c0ac21740553139c5ff65..0000000000000000000000000000000000000000
Binary files a/20221024/hp-20221024.pdf and /dev/null differ
diff --git a/20221024/hp-20221024.tex b/20221024/hp-20221024.tex
deleted file mode 100644
index 78a5ebadb425e463c5e0f9a94ca4288bef1b686c..0000000000000000000000000000000000000000
--- a/20221024/hp-20221024.tex
+++ /dev/null
@@ -1,889 +0,0 @@
-% hp-20221024.pdf - Lecture Slides on Low-Level Programming
-% Copyright (C) 2012, 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Bibliotheken
-
-\documentclass[10pt,t]{beamer}
-
-\usepackage{pgslides}
-\usepackage{pdftricks}
-\usepackage{tikz}
-
-\begin{psinputs}
- \usepackage[utf8]{inputenc}
- \usepackage[german]{babel}
- \usepackage[T1]{fontenc}
- \usepackage{helvet}
- \renewcommand*\familydefault{\sfdefault}
- \usepackage{pstricks,pst-grad}
-\end{psinputs}
-
-\newcommand{\redurl}[1]{\href{#1}{\color{red}\nolinkurl{#1}}}
-
-\title{Hardwarenahe Programmierung}
-\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
-\date{24.\ Oktober 2022}
-
-\begin{document}
-
-\maketitleframe
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \begin{itemize}
- \vspace*{-\smallskipamount}
- \item[\dots]
- \item[2.10] Zeiger
- \item[2.11] Arrays und Strings
- \color{medgreen}
- \item[2.12] Strukturen
- \item[2.13] Dateien und Fehlerbehandlung
- \item[2.14] Parameter des Hauptprogramms
- \color{orange}
- \item[2.15] String-Operationen
- \end{itemize}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \begin{itemize}
- \color{red}
- \item[3.1] Der Präprozessor
- \item[3.2] Bibliotheken einbinden
- \item[3.3] Bibliotheken verwenden
- \color{black}
- \item[3.4] Projekt organisieren: make
- \end{itemize}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \item[\textbf{5}] \textbf{Algorithmen}
- \vspace*{-\smallskipamount}
- \item[\textbf{\dots}]
- \end{itemize}
-
-\end{frame}
-
-\setcounter{section}{1}
-\section{Einführung in C}
-\setcounter{subsection}{11}
-\subsection{Strukturen}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{lstlisting}
- #include <stdio.h>
-
- typedef struct
- {
- char day, month;
- int year;
- }
- date;
-
- int main (void)
- {
- date today = { 24, 10, 2022 };
- printf ("%d.%d.%d\n", today.day, today.month, today.year);
- return 0;
- }
- \end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \vspace*{0.9mm}
- \begin{minipage}[b]{6cm}
- \begin{lstlisting}[gobble=6]
- ¡#include <stdio.h>
-
- typedef struct
- {
- char day, month;
- int year;
- }
- date;
-
- void set_date (date *d)
- {
- (*d).day = 24;
- (*d).month = 10;
- (*d).year = 2022;
- }¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[b]{6cm}
- \begin{lstlisting}[gobble=6]
- ¡int main (void)
- {
- date today;
- set_date (&today);
- printf ("%d.%d.%d\n", today.day,
- today.month, today.year);
- return 0;
- }¿
- \end{lstlisting}
- \end{minipage}
-\end{frame}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \vspace*{0.9mm}
- \begin{minipage}[b]{6cm}
- \begin{lstlisting}[gobble=6]
- ¡#include <stdio.h>
-
- typedef struct
- {
- char day, month;
- int year;
- }
- date;
-
- void set_date (date *d)
- {
- d->day = 24;
- d->month = 10;
- d->year = 2022;
- }¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[b]{6cm}
- \hspace*{-1cm}%
- \lstinline{foo->bar}
- ist Abkürzung für
- \lstinline{(*foo).bar}
-
- \bigskip
-
- \visible<2->{%
- \hspace*{-1cm}%
- Eine Funktion, die mit einem \lstinline{struct} arbeitet,\\
- \hspace*{-1cm}%
- kann man eine \newterm{Methode\/} des \lstinline{struct} nennen.}
-
- \bigskip
- \bigskip
-
- \begin{lstlisting}[gobble=6]
- ¡int main (void)
- {
- date today;
- set_date (&today);
- printf ("%d.%d.%d\n", today.day,
- today.month, today.year);
- return 0;
- }¿
- \end{lstlisting}
- \end{minipage}
-
-\end{frame}
-
-\subsection{Dateien und Fehlerbehandlung}
-
-\begin{frame}[fragile]
- \showsubsection
- \vspace*{-0.2925cm}
- \begin{minipage}[t]{6cm}
- \begin{onlyenv}<1>
- \begin{lstlisting}[gobble=8]
- ¡#include <stdio.h>
-
- int main (void)
- {
- FILE *f = fopen ("fhello.txt", "w");
- fprintf (f, "Hello, world!\n");
- fclose (f);
- return 0;
- }¿
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<2>
- \begin{lstlisting}[gobble=8]
- ¡#include <stdio.h>
-
- int main (void)
- {
- FILE *f = fopen ("fhello.txt", "w");
- if (f)
- {
- fprintf (f, "Hello, world!\n");
- fclose (f);
- }
- return 0;
- }¿
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<3>
- \begin{lstlisting}[gobble=8]
- ¡#include <stdio.h>
- #include <errno.h>
-
- int main (void)
- {
- FILE *f = fopen ("fhello.txt", "w");
- if (f)
- {
- fprintf (f, "Hello, world!\n");
- fclose (f);
- }
- else
- fprintf (stderr, "error #%d\n", errno);
- return 0;
- }¿
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<4>
- \begin{lstlisting}[gobble=8]
- ¡#include <stdio.h>
- #include <errno.h>
- #include <string.h>
-
- int main (void)
- {
- FILE *f = fopen ("fhello.txt", "w");
- if (f)
- {
- fprintf (f, "Hello, world!\n");
- fclose (f);
- }
- else
- {
- char *msg = strerror (errno);
- fprintf (stderr, "%s\n", msg);
- }
- return 0;
- }¿
- \end{lstlisting}
- \vspace*{-1cm}
- \end{onlyenv}
- \begin{onlyenv}<5->
- \begin{lstlisting}[gobble=8]
- ¡#include <stdio.h>
- #include <errno.h>
- #include <er¡ror.h>
-
- int main (void)
- {
- FILE *f = fopen ("fhello.txt", "w");
- if (!f)
- error (errno, errno, "cannot open file");
- fprintf (f, "Hello, world!\n");
- fclose (f);
- return 0;
- }
- \end{lstlisting}
- \end{onlyenv}
- \end{minipage}\pause\hspace*{-1.5cm}%
- \begin{minipage}[t]{8.5cm}
- \bigskip
- \only<3->{\bigskip}
- \begin{itemize}
- \item
- Wenn die Datei nicht geöffnet werden kann,\\
- gibt \lstinline{fopen()} den Wert \lstinline{NULL} zurück.
- \pause
- \medskip
- \item
- \addtolength{\leftskip}{1cm}
- Die globale Variable \lstinline{int errno}\\
- enthält dann die Nummer des Fehlers.\\
- Benötigt: \lstinline{#include <errno.h>}
- \pause
- \medskip
- \only<5->{\bigskip}
- \item
- Die Funktion \lstinline{strerror()} wandelt \lstinline{errno}\\
- in einen Fehlermeldungstext um.\\
- Benötigt: \lstinline{#include <string.h>}
- \pause
- \medskip
- \item
- \addtolength{\leftskip}{-1.5cm}
- Die Funktion \lstinline{error()} gibt eine Fehlermeldung aus\\
- und beendet das Programm.\\
- Benötigt: \lstinline{#include <er¡¿ror.h>}
- \pause
- \medskip
- \item
- \textbf{Niemals Fehler einfach ignorieren!}
- \end{itemize}
- \addtolength{\leftskip}{0.5cm}
- \end{minipage}
-\end{frame}
-
-\subsection{Parameter des Hauptprogramms}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{lstlisting}
- #include <stdio.h>
-
- int main (int argc, char **argv)
- {
- printf ("argc = %d\n", argc);
- for (int i = 0; i < argc; i++)
- printf ("argv[%d] = \"%s\"\n", i, argv[i]);
- return 0;
- }
- \end{lstlisting}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{lstlisting}
- #include <stdio.h>
-
- int main (int argc, char **argv)
- {
- printf ("argc = %d\n", argc);
- for (int i = 0; *argv; i++, argv++)
- printf ("argv[%d] = \"%s\"\n", i, *argv);
- return 0;
- }
- \end{lstlisting}
-
-\end{frame}
-
-\subsection{String-Operationen}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \vspace*{-0.4cm}
- \begin{lstlisting}
- #include <stdio.h>
- #include <string.h>
-
- int main (void)
- {
- char hello[] = "Hello, world!\n";
-
- printf ("%s\n", hello);
- printf ("%zd\n", strlen (hello));
-
- printf ("%s\n", hello + 7);
- printf ("%zd\n", strlen (hello + 7));
-
- hello[5] = 0;
- printf ("%s\n", hello);
- printf ("%zd\n", strlen (hello));
-
- return 0;
- }
- \end{lstlisting}
- \vspace*{-1cm}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \vspace*{-0.4cm}
- \begin{lstlisting}
- #include <stdio.h>
- #include <string.h>
-
- int main (void)
- {
- char *anton = "Anton";
- char *zacharias = "Zacharias";
-
- printf ("%d\n", strcmp (anton, zacharias));
- printf ("%d\n", strcmp (zacharias, anton));
- printf ("%d\n", strcmp (anton, anton));
-
- char buffer[100] = "Huber ";
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-
- return 0;
- }
- \end{lstlisting}
- \vspace*{-1cm}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \vspace*{-0.4cm}
- \begin{lstlisting}
- #include <stdio.h>
- #include <string.h>
-
- int main (void)
- {
- char *anton = "Anton";
- char *huber ="Huber";
-
- int size = strlen (huber) + strlen (" ") + strlen (anton) + 1;
- char buffer[size];
- buffer[0] = 0;
- strcat (buffer, huber);
- strcat (buffer, " ");
- strcat (buffer, anton);
- printf ("%s\n", buffer);
-
- return 0;
- }
- \end{lstlisting}
- \vspace*{-1cm}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \vspace*{-0.4cm}
- \begin{lstlisting}
- #include <stdio.h>
- #include <string.h>
-
- int main (void)
- {
- char buffer[100] = "";
- sprintf (buffer, "Die Antwort lautet: %d", 42);
- printf ("%s\n", buffer);
-
- char *answer = strstr (buffer, "Antwort");
- printf ("%s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- return 0;
- }
- \end{lstlisting}
- \vspace*{-1cm}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \vspace*{-0.4cm}
- \begin{lstlisting}
- #include <stdio.h>
- #include <string.h>
-
- int main (void)
- {
- char buffer[100] = "";
- snprintf (buffer, 100, "Die Antwort lautet: %d", 42);
- printf ("%s\n", buffer);
-
- char *answer = strstr (buffer, "Antwort");
- printf ("%s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- return 0;
- }
- \end{lstlisting}
-
-\end{frame}
-
-\begin{frame}
-
- \showsection
-
- Sprachelemente weitgehend komplett
-
- \bigskip
- Es fehlen:
- \begin{itemize}
- \item
- Ergänzungen (z.\,B.\ ternärer Operator, \lstinline{union}, \lstinline{unsigned}, \lstinline{volatile})
- \item
- Bibliotheksfunktionen (z.\,B.\ \lstinline{malloc()})
- \arrowitem
- werden eingeführt, wenn wir sie brauchen
- \bigskip
- \item
- Konzepte (z.\,B.\ rekursive Datenstrukturen, Klassen selbst bauen)
- \arrowitem
- werden eingeführt, wenn wir sie brauchen, oder:
- \arrowitem
- Literatur\\[\smallskipamount]
- (z.\,B.\ Wikibooks: C-Programmierung,\\
- Dokumentation zu Compiler und Bibliotheken)
- \bigskip
- \item
- Praxiserfahrung
- \arrowitem
- Übung und Praktikum: nur Einstieg
- \arrowitem
- selbständig arbeiten
- \end{itemize}
-\end{frame}
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \begin{itemize}
- \vspace*{-\smallskipamount}
- \item[\dots]
- \item[2.10] Zeiger
- \item[2.11] Arrays und Strings
- \item[2.12] Strukturen
- \item[2.13] Dateien und Fehlerbehandlung
- \item[2.14] Parameter des Hauptprogramms
- \color{medgreen}
- \item[2.15] String-Operationen
- \end{itemize}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \begin{itemize}
- \color{red}
- \item[3.1] Der Präprozessor
- \item[3.2] Bibliotheken einbinden
- \item[3.3] Bibliotheken verwenden
- \color{black}
- \item[3.4] Projekt organisieren: make
- \end{itemize}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \item[\textbf{5}] \textbf{Algorithmen}
- \vspace*{-\smallskipamount}
- \item[\textbf{\dots}]
- \end{itemize}
-
-\end{frame}
-
-\section{Bibliotheken}
-\subsection{Der Präprozessor}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \lstinline{#include}: %\pause:
- Text einbinden
- \begin{itemize}
- \pause
- \item
- \lstinline{#include <stdio.h>}: Standard-Verzeichnisse -- Standard-Header
- \pause
- \item
- \lstinline{#include "answer.h"}: auch aktuelles Verzeichnis -- eigene Header
- \end{itemize}
-
- \pause
- \bigskip
-
- \lstinline{#define SIX 6}: Text ersetzen lassen -- Konstante definieren
- \begin{itemize}
- \pause
- \item
- Kein Semikolon!
- \pause
- \item
- Berechnungen in Klammern setzen:\\
- \lstinline{#define SIX (1 + 5)}
- \pause
- \item
- Konvention: Großbuchstaben
- \end{itemize}
-
-\end{frame}
-
-\subsection{Bibliotheken einbinden}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- Inhalt der Header-Datei: externe Deklarationen
-
- \pause
- \smallskip
- \lstinline{extern int answer (void);}
-
- \pause
- \smallskip
- \lstinline{extern int printf (__const char *__restrict __format, ...);}
-
- \pause
- \bigskip
- Funktion wird "`anderswo"' definiert
- \begin{itemize}
- \pause
- \item
- separater C-Quelltext: mit an \lstinline[style=terminal]{gcc} übergeben
- \pause
- \item
- Zusammenfügen zu ausführbarem Programm durch den \newterm{Linker}
- \pause
- \item
- vorcompilierte Bibliothek: \lstinline[style=terminal]{-lfoo}\\
- \pause
- = Datei \file{libfoo.a} in Standard-Verzeichnis
- \end{itemize}
-
-\end{frame}
-
-\subsection{Bibliothek verwenden (Beispiel: GTK+)}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{itemize}
- \item
- \lstinline{#include <gtk/gtk.h>}
- \pause
- \smallskip
- \item
- Mit \lstinline[style=cmd]{pkg-config --cflags --libs} erfährt man,\\
- welche Optionen und Bibliotheken man an \lstinline[style=cmd]{gcc}
- übergeben muß\alt<4->{.}{:}
- \pause
- \begin{onlyenv}<3>
- \begin{lstlisting}[style=terminal,gobble=10]
- $ ¡pkg-config --cflags --libs gtk+-3.0¿
- -pthread -I/usr/include/gtk-3.0 -I/usr/include/at-spi2-
- atk/2.0 -I/usr/include/at-spi-2.0 -I/usr/include/dbus-1
- .0 -I/usr/lib/x86_64-linux-gnu/dbus-1.0/include -I/usr/
- include/gtk-3.0 -I/usr/include/gio-unix-2.0/ -I/usr/inc
- lude/cairo -I/usr/include/pango-1.0 -I/usr/include/harf
- buzz -I/usr/include/pango-1.0 -I/usr/include/atk-1.0 -I
- /usr/include/cairo -I/usr/include/pixman-1 -I/usr/inclu
- de/freetype2 -I/usr/include/libpng16 -I/usr/include/gdk
- -pixbuf-2.0 -I/usr/include/libpng16 -I/usr/include/glib
- -2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -lgtk
- -3 -lgdk-3 -lpangocairo-1.0 -lpango-1.0 -latk-1.0 -lcai
- ro-gobject -lcairo -lgdk_pixbuf-2.0 -lgio-2.0 -lgobject
- -2.0 -lglib-2.0
- \end{lstlisting}
- \vspace*{-3cm}
- \end{onlyenv}
- \pause
- \arrowitem
- Compiler-Aufruf:
- \begin{onlyenv}<4>
- \begin{lstlisting}[style=terminal,gobble=10]
- $ ¡gcc -Wall -O hello-gtk.c -pthread -I/usr/include/gtk-
- 3.0 -I/usr/include/at-spi2-atk/2.0 -I/usr/include/at-sp
- i-2.0 -I/usr/include/dbus-1.0 -I/usr/lib/x86_64-linux-g
- nu/dbus-1.0/include -I/usr/include/gtk-3.0 -I/usr/inclu
- de/gio-unix-2.0/ -I/usr/include/cairo -I/usr/include/pa
- ngo-1.0 -I/usr/include/harfbuzz -I/usr/include/pango-1.
- 0 -I/usr/include/atk-1.0 -I/usr/include/cairo -I/usr/in
- clude/pixman-1 -I/usr/include/freetype2 -I/usr/include/
- libpng16 -I/usr/include/gdk-pixbuf-2.0 -I/usr/include/l
- ibpng16 -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux
- -gnu/glib-2.0/include -lgtk-3 -lgdk-3 -lpangocairo-1.0
- -lpango-1.0 -latk-1.0 -lcairo-gobject -lcairo -lgdk_pix
- buf-2.0 -lgio-2.0 -lgobject-2.0 -lglib-2.0 -o hello-gtk¿
- \end{lstlisting}
- \vspace*{-2cm}
- \end{onlyenv}
- \begin{onlyenv}<5->
- \begin{lstlisting}[style=terminal,gobble=10]
- $ ¡gcc -Wall -O hello-gtk.c $(pkg-config --cflags --libs
- gtk+-3.0) -o hello-gtk¿
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<5>
- \begin{picture}(0,0)(0.3,0.3)
- \color{red}
- \put(6.6,-0.6){\makebox(0,0)[bl]{\tikz{\draw[-latex](0,0)--(3,1.5);}}}
- \put(6.3,-0.7){\makebox(0,0)[t]{\shortstack{\strut Optionen:\\
- \strut u.\,a.\ viele Include-Verzeichnisse:\\
- \lstinline[style=cmd]{-I/usr/include/gtk-3.0}}}}
- \put(10.0,-2.1){\makebox(0,0)[bl]{\tikz{\draw[-latex](0,0)--(1.5,3);}}}
- \put(10.3,-2.2){\makebox(0,0)[t]{\shortstack{\strut Bibliotheken:\\
- \strut u.\,a.\ \lstinline[style=cmd]{-lgtk-3 -lcairo}~~~\strut}}}
- \end{picture}
- \end{onlyenv}
- \pause
- \pause
- \item
- Auf manchen Plattformen kommt es auf die Reihenfolge an:
- \begin{lstlisting}[style=terminal,gobble=8]
- $ ¡gcc -Wall -O $(pkg-config --cflags gtk+-3.0) \
- hello-gtk.c $(pkg-config --libs gtk+-3.0) \
- -o hello-gtk¿
- \end{lstlisting}
- (Backslash = "`Es geht in der nächsten Zeile weiter."')
- \end{itemize}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Selbst geschriebene Funktion übergeben: \newterm{Callback}
-
- \bigskip
-
- \begin{lstlisting}[xleftmargin=1em]
- gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
- {
- /* Zeichenbefehle */
- ...
-
- return FALSE;
- }
-
- ...
-
- g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
- \end{lstlisting}
-
- \medskip
-
- \begin{itemize}
- \arrowitem
- GTK+ ruft immer dann, wenn es etwas zu zeichnen gibt,\\
- die Funktion \lstinline{draw} auf.
- \end{itemize}
-
- \pause
- \begin{picture}(0,0)(-0.07,0.2)
- \color{red}
- \put(5.3,4.8){\makebox(0,0)[bl]{\tikz{\draw[-latex](0,0)--(1.90,1.15);}}}
- \put(5.0,4.7){\makebox(0,0)[t]{\shortstack{\strut repräsentiert den\\
- \strut Bildschirm, auf den\\
- \strut gezeichnet werden soll}}}
- \pause
- \put(9.7,5.1){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-0.2,0.85);}}}
- \put(9.7,5.0){\makebox(0,0)[t]{\shortstack{\strut optionale Zusatzinformationen\\
- \strut für draw(), typischerweise\\
- \strut ein Zeiger auf ein struct}}}
- \put(10.0,3.5){\makebox(0,0)[tl]{\tikz{\draw[-latex](0,0)--(0.6,-1.25);}}}
- \end{picture}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Selbst geschriebene Funktion übergeben: \newterm{Callback}
-
- \bigskip
-
- \begin{lstlisting}[xleftmargin=1em]
- gboolean timer (GtkWidget *widget)
- {
- /* Rechenbefehle */
- ...
-
- gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
- }
-
- ...
-
- g_timeout_add (50, (GSourceFunc) timer, drawing_area);
- \end{lstlisting}
-
- \medskip
-
- \begin{itemize}
- \arrowitem
- GTK+ ruft nach 50 Millisekunden
- die Funktion \lstinline{timer} auf.
- \end{itemize}
-
- \pause
- \begin{picture}(0,0)(-0.07,0.2)
- \color{red}
- \put(9.7,6.7){\makebox(0,0)[t]{\shortstack{\strut Dieser Bereich soll\\
- \strut neu gezeichnet werden.}}}
- \put(9.7,5.7){\makebox(0,0)[tr]{\tikz{\draw[-latex](0,0)--(-0.6,-0.8);}}}
- \pause
- \put(4.3,3.2){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-0.7,0.6);}}}
- \put(4.3,3.1){\makebox(0,0)[t]{\shortstack{\strut In weiteren 50 Millisekunden soll\\
- \strut die Funktion erneut aufgerufen werden.}}}
- \pause
- \put(9.3,2.9){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-3.3,0.9);}}}
- \put(9.8,2.8){\makebox(0,0)[t]{\shortstack{\strut Explizite Typumwandlung\\
- \strut eines Zeigers (später)}}}
- \end{picture}
-
-\end{frame}
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \begin{itemize}
- \vspace*{-\smallskipamount}
- \item[\dots]
- \item[2.10] Zeiger
- \item[2.11] Arrays und Strings
- \item[2.12] Strukturen
- \item[2.13] Dateien und Fehlerbehandlung
- \item[2.14] Parameter des Hauptprogramms
- \color{medgreen}
- \item[2.15] String-Operationen
- \end{itemize}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \begin{itemize}
- \color{medgreen}
- \item[3.1] Der Präprozessor
- \item[3.2] Bibliotheken einbinden
- \color{orange}
- \item[3.3] Bibliotheken verwenden
- \color{red}
- \item[3.4] Projekt organisieren: make
- \end{itemize}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \item[\textbf{5}] \textbf{Algorithmen}
- \vspace*{-\smallskipamount}
- \item[\textbf{\dots}]
- \end{itemize}
-
-\end{frame}
-
-\end{document}
diff --git a/20221024/hp-musterloesung-20221024.pdf b/20221024/hp-musterloesung-20221024.pdf
deleted file mode 100644
index 480cde67b2698b1b57bd60ffc5042be2c1bf9fa2..0000000000000000000000000000000000000000
Binary files a/20221024/hp-musterloesung-20221024.pdf and /dev/null differ
diff --git a/20221024/hp-musterloesung-20221024.tex b/20221024/hp-musterloesung-20221024.tex
deleted file mode 100644
index 2865fb9a300ff3b66a71acfdf1ffd38963f64195..0000000000000000000000000000000000000000
--- a/20221024/hp-musterloesung-20221024.tex
+++ /dev/null
@@ -1,347 +0,0 @@
-% hp-musterloesung-20221024.pdf - Solutions to the Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Arrays mit Zahlen, Datum-Bibliothek, fehlerhaftes Primzahl-Programm
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\begin{document}
-
- \section*{Hardwarenahe Programmierung\\
- Musterlösung zu den Übungsaufgaben -- 24.\ Oktober 2022}
-
- \exercise{Arrays mit Zahlen}
-
- \begin{minipage}[t]{0.4\textwidth}
- Wir betrachten das folgende Programm\\
- (Datei: \gitfile{hp}{2022ws/20221024}{aufgabe-1.c}):
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- void f (int *s0, int *s1)
- {
- while (*s0 >= 0)
- {
- int *s = s1;
- while (*s >= 0)
- if (*s0 == *s++)
- printf ("%d ", *s0);
- s0++;
- }
- printf ("\n");
- }
-
- int main (void)
- {
- int a[] = { 10, 4, 3, 7, 12, 0, 1, -1 };
- int b[] = { 7, 14, 0, 8, 9, 22, 10, -1 };
- f (a, b);
- return 0;
- }
- \end{lstlisting}
- \end{minipage}\hfill
- \begin{minipage}[t]{0.55\textwidth}
- \vspace*{-\bigskipamount}
- \begin{enumerate}[\quad(a)]
- \item
- Was bewirkt die Funktion \lstinline{f},\\
- und wie funktioniert sie?
- \points{4}
-% \item
-% Von welcher Ordnung (Landau-Symbol) ist die Funktion?
-% Begründen Sie Ihre Antwort.
-%
-% Wir beziehen uns hierbei auf die Anzahl der Vergleiche
-% in Abhängigkeit von der Länge der Eingabedaten \lstinline{s0} und \lstinline{s1}.
-% Für die Rechnung dürfen Sie beide Längen mit $n$ gleichsetzen,
-% obwohl sie normalerweise nicht gleich sind.
-% \points{2}
- \item
- Was passiert, wenn Sie beim Aufruf der Funktion für einen der
- Parameter den Wert \lstinline{NULL} übergeben?
- Begründen Sie Ihre Antwort.
- \points{2}
- \item
- Was kann passieren, wenn Sie das Hauptprogramm wie folgt abändern
- (\gitfile{hp}{2022ws/20221024}{aufgabe-1c.c})?
- Begründen Sie Ihre Antwort.
- \begin{lstlisting}[gobble=8]
- int main (void)
- {
- int a[] = { 10, 4, 3, 7, 12, 0, 1 };
- int b[] = { 7, 14, 0, 8, 9, 22, 10 };
- f (a, b);
- return 0;
- }
- \end{lstlisting}
- \points{2}
-% \item
-% Beschreiben Sie -- in Worten und/oder als C-Quelltext --, wie
-% sich die Funktion \lstinline{f} effizienter gestalten läßt,
-% wenn man die ihr übergebenen Arrays \lstinline{s0} und
-% \lstinline{s1} als sortiert voraussetzt.
-% \points{5}
-%
-% Hinweis: Wie würden Sie als Mensch die Aufgabe erledigen?
-% \item
-% Von welcher
-% Ordnung (Landau-Symbol) ist Ihre effizientere Version der Funktion und warum?
-% \points{2}
- \end{enumerate}
- \end{minipage}
-
- \solution
-
- \begin{enumerate}[\quad(a)]
- \item
- \textbf{Was bewirkt die Funktion \lstinline{f}, und wie funktioniert sie?}
-
- Die Funktion gibt alle Zahlen aus, die sowohl im Array \lstinline{s0}
- als auch im Array \lstinline{s1} vorkommen (Schnittmenge).
-
- Dies geschieht, indem der Zeiger \lstinline{s0} das gesamte Array durchläuft
- (äußere Schleife).
- Für jedes Element des ersten Arrays durchläuft der Zeiger \lstinline{s}
- das gesamte zweite Array (innere Schleife).
- Auf diese Weise wird jedes Element von \lstinline{s0}
- mit jedem von \lstinline{s1} verglichen und bei Gleichheit ausgegeben.
-
- Um die Schleifen abbrechen zu können, enthalten beide Arrays
- als Ende-Markierung eine negative Zahl (\lstinline{-1}).
-
- \item
- \textbf{Was passiert, wenn Sie beim Aufruf der Funktion für einen der
- Parameter den Wert \lstinline{NULL} übergeben?
- Begründen Sie Ihre Antwort.}
-
- In dem Moment, wo auf den jeweiligen Parameter-Zeiger zugegriffen wird
- (\lstinline{while (*s0 >= 0)} für \lstinline{s0} bzw.\
- \lstinline{int *s = s1; while (*s >= 0)} für \lstinline{s1}),
- kommt es zu einem Absturz (Speicherzugriffsfehler).
- Die Dereferenzierung eines Zeigers mit dem Wert \lstinline{NULL}
- ist nicht zulässig.
-
- \item
- \textbf{Was kann passieren, wenn Sie das Hauptprogramm wie folgt abändern
- (\gitfile{hp}{2022ws/20221024}{aufgabe-1c.c})?
- Begründen Sie Ihre Antwort.}
-
- \begin{minipage}{0.35\textwidth}
- \begin{lstlisting}[gobble=10]
- int main (void)
- {
- int a[] = { 10, 4, 3, 7, 12, 0, 1 };
- int b[] = { 7, 14, 0, 8, 9, 22, 10 };
- f (a, b);
- return 0;
- }
- \end{lstlisting}
- \end{minipage}\hfill
- \begin{minipage}{0.575\textwidth}
- Durch die fehlenden Ende-Markierungen der Arrays
- laufen die Schleifen immer weiter,
- bis sie irgendwann zufällig auf Speicherzellen stoßen,
- die sich als Ende-Markierungen interpretieren lassen (negative Zahlen).
- Dadurch kann es zu einem Lesezugriff auf Speicher kommen,
- für den das Programm kein Lesezugriffsrecht hat,
- also zu einem Absturz (Speicherzugriffsfehler).
- \end{minipage}
- \end{enumerate}
-
- \exercise{Datum-Bibliothek}
-
- Schreiben Sie eine Bibliothek (\file{.c}-Datei und \file{.h}-Datei)
- zur Behandlung von Datumsangaben.
-
- Diese soll enthalten:
- \begin{itemize}
- \item
- einen \lstinline{struct}-Datentyp \lstinline{date},
- der eine Datumsangabe speichert,
- \item
- eine Funktion \lstinline{void date_print (date *d)}, die ein Datum ausgibt,
- \item
- eine Funktion \lstinline{int date_set (date *d, int day, int month, int year)},
- die ein Datum auf einen gegebenen Tag setzt
- und zurückgibt, ob es sich um ein gültiges Datum handelt (0 = nein, 1 = ja),
- \item
- eine Funktion \lstinline{void date_next (date *d)},
- die ein Datum auf den nächsten Tag vorrückt.
- \end{itemize}
-
- Schreiben Sie auch ein Programm, das die o.\,a.\ Funktionen testet.
-
- \solution
-
- Die Dateien \gitfile{hp}{2022ws/20221024}{loesung-2.c},
- \gitfile{hp}{2022ws/20221024}{loesung-2.h}
- und \gitfile{hp}{2022ws/20221024}{loesung-2-test.c}
- enthalten die Bibliothek und das Test-Programm.
-
- Eine detaillierte Anleitung,
- wie man auf die Funktion \lstinline{date_next()} kommt,
- finden Sie im Skript zur Lehrveranstaltung,
- Datei \gitfile{hp}{2022ws/script/hp-2022ws.pdf}{hp-2022ws.pdf},
- ab Seite 29.
-
- \exercise{Fehlerhaftes Primzahl-Programm}
-
- \begin{minipage}[t]{5.5cm}
- Das nebenstehende Primzahlsuchprogramm (Datei: \gitfile{hp}{2022ws/20221024}{aufgabe-3.c})
- soll Zahlen ausgeben, die genau zwei Teiler haben, ist aber fehlerhaft.
-
- \smallskip
-
- Korrigieren Sie das Programm derart, daß ein Programm entsteht,
- welches alle Primzahlen kleiner 100 ausgibt.% \points 5
- \end{minipage}\hfill
- \begin{minipage}[t]{9cm}
- \vspace*{-0.5cm}
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- int n, i, divisors;
- for (n = 0; n < 100; n++)
- divisors = 0;
- for (i = 0; i < n; i++)
- if (n % i == 0)
- divisors++;
- if (divisors = 2)
- printf ("%d ist eine Primzahl.\n", n);
- return 0;
- }
- \end{lstlisting}
- \end{minipage}
-
- \solution
-
- Beim Compilieren des Beispiel-Programms mit
- \lstinline[style=cmd]{gcc -Wall} erhalten wir die folgende Warnung:
- \begin{lstlisting}[style=terminal]
- aufgabe-2.c:11:5: warning: suggest parentheses around assignment
- used as truth value [-Wparentheses]
- \end{lstlisting}
- Beim Ausführen gibt das Programm die folgende (falsche) Behauptung aus:
- \begin{lstlisting}[style=terminal]
- 100 ist eine Primzahl.
- \end{lstlisting}
-
- Einen ersten Hinweis auf den Fehler im Programm liefert die Warnung.
- Die Bedingung \lstinline{if (divisors = 2)} in Zeile 11
- steht \emph{nicht\/} für einen Vergleich
- der Variablen \lstinline{divisors} mit der Zahl 2,
- sondern für eine Zuweisung der Zahl 2 an die Variable \lstinline{divisors}.
- Neben dem \emph{Seiteneffekt\/} der Zuweisung gibt \lstinline{divisors = 2}
- den Wert \lstinline{2} zurück.
- Als Bedingung interpretiert, hat \lstinline{2} den Wahrheitswert "`wahr"' ("`true"');
- die \lstinline{printf()}-Anweisung wird daher in jedem Fall ausgeführt.
-
- Korrektur dieses Fehlers: \lstinline{if (divisors == 2)}
- -- siehe die Datei \gitfile{hp}{2022ws/20221024}{loesung-2-1.c}.
-
- \bigskip
-
- Nach der Korrektur dieses Fehlers compiliert das Programm ohne Warnung,
- gibt aber beim Ausführen die folgende Fehlermeldung aus:
- \begin{lstlisting}[style=terminal]
- Gleitkomma-Ausnahme
- \end{lstlisting}
- (Bemerkung: Bei ausgeschalteter Optimierung
- -- \lstinline[style=cmd]{gcc} ohne \lstinline[style=cmd]{-O} --
- kommt diese Fehlermeldung bereits beim ersten Versuch, das Programm auszuführen.
- Der Grund für dieses Verhalten ist, daß bei eingeschalteter Optimierung
- irrelevante Teile des Programms entfernt und gar nicht ausgeführt werden,
- so daß der Fehler nicht zum Tragen kommt.
- In diesem Fall wurde die Berechnung von \lstinline{divisors} komplett wegoptimiert,
- da der Wert dieser Variablen nirgendwo abgefragt,
- sondern durch die Zuweisung \lstinline{if (divisors = 2)}
- sofort wieder überschrieben wurde.)
-
- Die Fehlermeldung "`\lstinline[style=terminal]{Gleitkomma-Ausnahme}"'
- ist insofern irreführend, als daß hier gar keine Gleitkommazahlen im Spiel sind;
- andererseits deutet sie auf einen Rechenfehler hin, was auch tatsächlich zutrifft.
- Durch Untersuchen aller Rechenoperationen
- -- z.\,B.\ durch das Einfügen zusätzlicher \lstinline{printf()} --
- finden wir den Fehler in Zeile 9:
- Die Modulo-Operation \lstinline{n % i} ist eine Division,
- die dann fehlschlägt, wenn der Divisor \lstinline{i} den Wert 0 hat.
- Die Fehlerursache ist die bei 0 beginnende \lstinline{for}-Schleife in Zeile 8:
- \lstinline{for (i = 0; i < n; i++)}.
-
- Korrektur dieses Fehlers: Beginn der Schleife mit \lstinline{i = 1}
- statt \lstinline{i = 0} -- siehe die Datei \gitfile{hp}{2022ws/20221024}{loesung-2-2.c}.
-
- \bigskip
-
- Nach der Korrektur dieses Fehlers gibt das Programm überhaupt nichts mehr aus.
-
- Durch Untersuchen des Verhaltens des Programms
- -- z.\,B.\ durch das Einfügen zusätzlicher \lstinline{printf()} --
- stellen wir fest, daß die Zeilen 8 bis 12 des Programms nur einmal ausgeführt werden
- und nicht, wie die \lstinline{for}-Schleife in Zeile 6 vermuten ließe, 100mal.
- Der Grund dafür ist, daß sich die \lstinline{for}-Schleife
- nur auf die unmittelbar folgende Anweisung \lstinline{divisors = 0} bezieht.
- Nur diese Zuweisung wird 100mal ausgeführt;
- alles andere befindet sich außerhalb der \lstinline{for}-Schleife.
- (Die Einrückung hat in C keine inhaltliche Bedeutung,
- sondern dient nur zur Verdeutlichung der Struktur des Programms.
- In diesem Fall entsprach die tatsächliche Struktur nicht der beabsichtigten.)
-
- Korrektur dieses Fehlers:
- geschweifte Klammern um den Inhalt der äußeren \lstinline{for}-Schleife
- -- siehe die Datei \gitfile{hp}{2022ws/20221024}{loesung-2-3.c}.
-
- \bigskip
-
- Nach der Korrektur dieses Fehlers gibt das Programm folgendes aus:
- \begin{lstlisting}[style=terminal]
- 4 ist eine Primzahl.
- 9 ist eine Primzahl.
- 25 ist eine Primzahl.
- 49 ist eine Primzahl.
- \end{lstlisting}
- Diese Zahlen sind keine Primzahlen (mit zwei Teilern),
- sondern sie haben drei Teiler.
- Demnach findet das Programm einen Teiler zu wenig.
- (Um diesen Fehler zu finden, kann man sich zu jeder Zahl
- die gefundene Anzahl der Teiler \lstinline{divisors} ausgeben lassen.)
-
- Der nicht gefundene Teiler ist jeweils die Zahl selbst.
- Dies kommt daher, daß die Schleife
- \lstinline{for (i = 1; i < n; i++)} nur bis \lstinline{n - 1} geht,
- also keine Division durch \lstinline{n} stattfindet.
-
- Korrektur dieses Fehlers: Schleifenbedingung \lstinline{i <= n}
- statt \lstinline{i < n}
- -- siehe die Datei \gitfile{hp}{2022ws/20221024}{loesung-2-4.c}.
-
- \bigskip
-
- Nach der Korrektur dieses Fehlers verhält sich das Programm korrekt.
-
- Die Datei \gitfile{hp}{2022ws/20221024}{loesung-2-4.c} enthält somit das korrigierte Programm.
-
-\end{document}
diff --git a/20221024/hp-uebung-20221024.pdf b/20221024/hp-uebung-20221024.pdf
deleted file mode 100644
index 76b61cf781c6008d26dc8e85bf8e2b75dad23d1a..0000000000000000000000000000000000000000
Binary files a/20221024/hp-uebung-20221024.pdf and /dev/null differ
diff --git a/20221024/hp-uebung-20221024.tex b/20221024/hp-uebung-20221024.tex
deleted file mode 100644
index e05ad70d1580a93fc873231ea33c9474d0ed5012..0000000000000000000000000000000000000000
--- a/20221024/hp-uebung-20221024.tex
+++ /dev/null
@@ -1,181 +0,0 @@
-% hp-uebung-20221024.pdf - Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Arrays mit Zahlen, Datum-Bibliothek, fehlerhaftes Primzahl-Programm
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\begin{document}
-
- \thispagestyle{empty}
-
- \section*{Hardwarenahe Programmierung\\
- Übungsaufgaben -- 24.\ Oktober 2022}
-
- Diese Übung enthält Punkteangaben wie in einer Klausur.
- Um zu "`bestehen"', müssen Sie innerhalb von 60 Minuten
- unter Verwendung ausschließlich zugelassener Hilfsmittel
- 10 Punkte (von insgesamt \totalpoints) erreichen.
-
- \exercise{Arrays mit Zahlen}
-
- \begin{minipage}[t]{0.4\textwidth}
- Wir betrachten das folgende Programm\\
- (Datei: \gitfile{hp}{2022ws/20221024}{aufgabe-1.c}):
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- void f (int *s0, int *s1)
- {
- while (*s0 >= 0)
- {
- int *s = s1;
- while (*s >= 0)
- if (*s0 == *s++)
- printf ("%d ", *s0);
- s0++;
- }
- printf ("\n");
- }
-
- int main (void)
- {
- int a[] = { 10, 4, 3, 7, 12, 0, 1, -1 };
- int b[] = { 7, 14, 0, 8, 9, 22, 10, -1 };
- f (a, b);
- return 0;
- }
- \end{lstlisting}
- \end{minipage}\hfill
- \begin{minipage}[t]{0.55\textwidth}
- \vspace*{-\bigskipamount}
- \begin{enumerate}[\quad(a)]
- \item
- Was bewirkt die Funktion \lstinline{f},\\
- und wie funktioniert sie?
- \points{4}
-% \item
-% Von welcher Ordnung (Landau-Symbol) ist die Funktion?
-% Begründen Sie Ihre Antwort.
-%
-% Wir beziehen uns hierbei auf die Anzahl der Vergleiche
-% in Abhängigkeit von der Länge der Eingabedaten \lstinline{s0} und \lstinline{s1}.
-% Für die Rechnung dürfen Sie beide Längen mit $n$ gleichsetzen,
-% obwohl sie normalerweise nicht gleich sind.
-% \points{2}
- \item
- Was passiert, wenn Sie beim Aufruf der Funktion für einen der
- Parameter den Wert \lstinline{NULL} übergeben?
- Begründen Sie Ihre Antwort.
- \points{2}
- \item
- Was kann passieren, wenn Sie das Hauptprogramm wie folgt abändern
- (\gitfile{hp}{2022ws/20221024}{aufgabe-1c.c})?
- Begründen Sie Ihre Antwort.
- \begin{lstlisting}[gobble=8]
- int main (void)
- {
- int a[] = { 10, 4, 3, 7, 12, 0, 1 };
- int b[] = { 7, 14, 0, 8, 9, 22, 10 };
- f (a, b);
- return 0;
- }
- \end{lstlisting}
- \points{2}
-% \item
-% Beschreiben Sie -- in Worten und/oder als C-Quelltext --, wie
-% sich die Funktion \lstinline{f} effizienter gestalten läßt,
-% wenn man die ihr übergebenen Arrays \lstinline{s0} und
-% \lstinline{s1} als sortiert voraussetzt.
-% \points{5}
-%
-% Hinweis: Wie würden Sie als Mensch die Aufgabe erledigen?
-% \item
-% Von welcher
-% Ordnung (Landau-Symbol) ist Ihre effizientere Version der Funktion und warum?
-% \points{2}
- \end{enumerate}
- \end{minipage}
-
- \exercise{Datum-Bibliothek}
-
- Schreiben Sie eine Bibliothek (\file{.c}-Datei und \file{.h}-Datei)
- zur Behandlung von Datumsangaben.
-
- Diese soll enthalten:
- \begin{itemize}
- \item
- einen \lstinline{struct}-Datentyp \lstinline{date},
- der eine Datumsangabe speichert,
- \item
- eine Funktion \lstinline{void date_print (date *d)}, die ein Datum ausgibt,
- \item
- eine Funktion \lstinline{int date_set (date *d, int day, int month, int year)},
- die ein Datum auf einen gegebenen Tag setzt
- und zurückgibt, ob es sich um ein gültiges Datum handelt (0 = nein, 1 = ja),
- \item
- eine Funktion \lstinline{void date_next (date *d)},
- die ein Datum auf den nächsten Tag vorrückt.
- \end{itemize}
-
- Schreiben Sie auch ein Programm, das die o.\,a.\ Funktionen testet.
-
- \points{8}
-
- \exercise{Fehlerhaftes Primzahl-Programm}
-
- \begin{minipage}[t]{5.5cm}
- Das nebenstehende Primzahlsuchprogramm (Datei: \gitfile{hp}{2022ws/20221024}{aufgabe-3.c})
- soll Zahlen ausgeben, die genau zwei Teiler haben, ist aber fehlerhaft.
-
- \smallskip
-
- Korrigieren Sie das Programm derart, daß ein Programm entsteht,
- welches alle Primzahlen kleiner 100 ausgibt. \points 5
- \end{minipage}\hfill
- \begin{minipage}[t]{9cm}
- \vspace*{-0.5cm}
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- int main (void)
- {
- int n, i, divisors;
- for (n = 0; n < 100; n++)
- divisors = 0;
- for (i = 0; i < n; i++)
- if (n % i == 0)
- divisors++;
- if (divisors = 2)
- printf ("%d ist eine Primzahl.\n", n);
- return 0;
- }
- \end{lstlisting}
- \end{minipage}
-
- \makeatletter
- \immediate\write\@mainaux{\string\gdef\string\totalpoints{\arabic{points}}}
- \makeatother
-
-\end{document}
diff --git a/20221024/loesung-2-test.c b/20221024/loesung-2-test.c
deleted file mode 100644
index 7947ae0afe7221e20f66fed108c900c3964ccfc0..0000000000000000000000000000000000000000
--- a/20221024/loesung-2-test.c
+++ /dev/null
@@ -1,42 +0,0 @@
-#include <stdio.h>
-#include "loesung-2.h"
-
-void check (char day, char month, int year)
-{
- date d;
- if (date_set (&d, day, month, year))
- {
- date_print (&d);
- printf (" --> ");
- date_next (&d);
- date_print (&d);
- printf ("\n");
- }
- else
- printf ("%02d.%02d.%04d: invalid date\n", day, month, year);
-}
-
-int main (void)
-{
- check (6, 11, 2018);
- check (29, 11, 2018);
- check (30, 11, 2018);
- check (31, 11, 2018);
- check (29, 12, 2018);
- check (30, 12, 2018);
- check (31, 12, 2018);
- check (28, 2, 2016);
- check (29, 2, 2016);
- check (30, 2, 2016);
- check (28, 2, 2015);
- check (29, 2, 2015);
- check (30, 2, 2015);
- check (31, 12, 2008);
- check (28, 2, 2000);
- check (29, 2, 2000);
- check (30, 2, 2000);
- check (28, 2, 1900);
- check (29, 2, 1900);
- check (30, 2, 1900);
- return 0;
-}
diff --git a/20221024/loesung-2.c b/20221024/loesung-2.c
deleted file mode 100644
index 9ce7f9da4be532c884be6a463dfcaeec32c4e134..0000000000000000000000000000000000000000
--- a/20221024/loesung-2.c
+++ /dev/null
@@ -1,62 +0,0 @@
-#include "loesung-2.h"
-
-int is_leap_year (int year)
-{
- if (year % 4 == 0)
- if (year % 100 == 0)
- if (year % 400 == 0)
- return 1;
- else
- return 0;
- else
- return 1;
- else
- return 0;
-}
-
-int days_in_month (int month, int year)
-{
- if (month == 2)
- if (is_leap_year (year))
- return 29;
- else
- return 28;
- else if (month == 4 || month == 6 || month == 9 || month == 11)
- return 30;
- else
- return 31;
-}
-
-void date_print (date *d)
-{
- printf ("%02d.%02d.%04d", d->day, d->month, d->year);
-}
-
-int date_set (date *d, char day, char month, int year)
-{
- d->year = year;
- if (month > 0 && month <= 12)
- d->month = month;
- else
- return 0;
- if (day > 0 && day <= days_in_month (month, year))
- d->day = day;
- else
- return 0;
- return 1;
-}
-
-void date_next (date *d)
-{
- d->day++;
- if (d->day > days_in_month (d->month, d->year))
- {
- d->month++;
- d->day = 1;
- if (d->month > 12)
- {
- d->year++;
- d->month = 1;
- }
- }
-}
diff --git a/20221024/loesung-2.h b/20221024/loesung-2.h
deleted file mode 100644
index f0d8f5991518d851931ffe06a13387f57cef1905..0000000000000000000000000000000000000000
--- a/20221024/loesung-2.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- char day, month;
- int year;
-}
-date;
-
-extern int is_leap_year (int year);
-extern int days_in_month (int month, int year);
-extern void date_print (date *d);
-extern int date_set (date *d, char day, char month, int year);
-extern void date_next (date *d);
diff --git a/20221024/loesung-3-1.c b/20221024/loesung-3-1.c
deleted file mode 100644
index 248883b772ca68d498ae4dc080e83899eb715570..0000000000000000000000000000000000000000
--- a/20221024/loesung-3-1.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int n, i, divisors;
- for (n = 0; n < 100; n++)
- divisors = 0;
- for (i = 0; i < n; i++)
- if (n % i == 0)
- divisors++;
- if (divisors == 2)
- printf ("%d ist eine Primzahl.\n", n);
- return 0;
-}
diff --git a/20221024/loesung-3-2.c b/20221024/loesung-3-2.c
deleted file mode 100644
index 0cc3db639099eab0040c568acbd46987eb599645..0000000000000000000000000000000000000000
--- a/20221024/loesung-3-2.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int n, i, divisors;
- for (n = 0; n < 100; n++)
- divisors = 0;
- for (i = 1; i < n; i++)
- if (n % i == 0)
- divisors++;
- if (divisors == 2)
- printf ("%d ist eine Primzahl.\n", n);
- return 0;
-}
diff --git a/20221024/loesung-3-3.c b/20221024/loesung-3-3.c
deleted file mode 100644
index af2694c1ad2f710d79d7913b9dcfc7348be96115..0000000000000000000000000000000000000000
--- a/20221024/loesung-3-3.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int n, i, divisors;
- for (n = 0; n < 100; n++)
- {
- divisors = 0;
- for (i = 1; i < n; i++)
- if (n % i == 0)
- divisors++;
- if (divisors == 2)
- printf ("%d ist eine Primzahl.\n", n);
- }
- return 0;
-}
diff --git a/20221024/loesung-3-4.c b/20221024/loesung-3-4.c
deleted file mode 100644
index 770d92706cc68f64147e5efd443880ac3d875495..0000000000000000000000000000000000000000
--- a/20221024/loesung-3-4.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int n, i, divisors;
- for (n = 0; n < 100; n++)
- {
- divisors = 0;
- for (i = 1; i <= n; i++)
- if (n % i == 0)
- divisors++;
- if (divisors == 2)
- printf ("%d ist eine Primzahl.\n", n);
- }
- return 0;
-}
diff --git a/20221024/logo-hochschule-bochum-cvh-text-v2.pdf b/20221024/logo-hochschule-bochum-cvh-text-v2.pdf
deleted file mode 120000
index 4aa99b8f81061aca6dcaf43eed2d9efef40555f8..0000000000000000000000000000000000000000
--- a/20221024/logo-hochschule-bochum-cvh-text-v2.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
diff --git a/20221024/logo-hochschule-bochum.pdf b/20221024/logo-hochschule-bochum.pdf
deleted file mode 120000
index b6b9491e370e499c9276918182cdb82cb311bcd1..0000000000000000000000000000000000000000
--- a/20221024/logo-hochschule-bochum.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20221024/maerchen.c b/20221024/maerchen.c
deleted file mode 100644
index 5c2716e85205136d406ad2e20285c18ddc967c07..0000000000000000000000000000000000000000
--- a/20221024/maerchen.c
+++ /dev/null
@@ -1,4 +0,0 @@
-Vor langer, langer Zeit
-gab es einmal
-#include "hexe.h"
-Die lebte in einem Wald.
diff --git a/20221024/maerchen.txt b/20221024/maerchen.txt
deleted file mode 100644
index 1ed8f3fc48aaf0ca6cfe59e6ad4e80b19d758339..0000000000000000000000000000000000000000
--- a/20221024/maerchen.txt
+++ /dev/null
@@ -1,34 +0,0 @@
-cassini/home/peter/bo/2022ws/hp/20221024> cat maerchen.c
-Vor langer, langer Zeit
-gab es einmal
-#include "hexe.h"
-Die lebte in einem Wald.
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O maerchen.c -o maerchen
-maerchen.c:1:1: error: unknown type name ‘Vor’
- Vor langer, langer Zeit
- ^~~
-maerchen.c:1:20: error: expected ‘=’, ‘,’, ‘;’, ‘asm’ or ‘__attribute__’ before ‘Zeit’
- Vor langer, langer Zeit
- ^~~~
-cassini/home/peter/bo/2022ws/hp/20221024> cat hexe.h
-eine kleine Hexe.
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O maerchen.c -E
-# 1 "maerchen.c"
-# 1 "<built-in>"
-# 1 "<command-line>"
-# 31 "<command-line>"
-# 1 "/usr/include/stdc-predef.h" 1 3 4
-# 32 "<command-line>" 2
-# 1 "maerchen.c"
-Vor langer, langer Zeit
-gab es einmal
-# 1 "hexe.h" 1
-eine kleine Hexe.
-# 4 "maerchen.c" 2
-Die lebte in einem Wald.
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O maerchen.c -E -P
-Vor langer, langer Zeit
-gab es einmal
-eine kleine Hexe.
-Die lebte in einem Wald.
-cassini/home/peter/bo/2022ws/hp/20221024>
diff --git a/20221024/pgscript.sty b/20221024/pgscript.sty
deleted file mode 120000
index 95c888478c99ea7fda0fd11ccf669ae91be7178b..0000000000000000000000000000000000000000
--- a/20221024/pgscript.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgscript.sty
\ No newline at end of file
diff --git a/20221024/pgslides.sty b/20221024/pgslides.sty
deleted file mode 120000
index 5be1416f4216f076aa268901f52a15d775e43f64..0000000000000000000000000000000000000000
--- a/20221024/pgslides.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgslides.sty
\ No newline at end of file
diff --git a/20221024/philosophy-01.txt b/20221024/philosophy-01.txt
deleted file mode 100644
index a232d84cae0080e821abb7972c50b677c183d20b..0000000000000000000000000000000000000000
--- a/20221024/philosophy-01.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-cassini/home/peter/bo/2022ws/hp/20221024> cat philosophy.c
-#include <stdio.h>
-#include "answer.h"
-
-int main (void)
-{
- printf ("The answer is %d.\n", answer ());
- return 0;
-}
-cassini/home/peter/bo/2022ws/hp/20221024> cat answer.h
-extern int answer (void);
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O philosophy.c -o philosophy
-/usr/bin/ld: /tmp/cc2KFjiS.o: in function `main':
-philosophy.c:(.text+0x5): undefined reference to `answer'
-collect2: error: ld returned 1 exit status
-cassini/home/peter/bo/2022ws/hp/20221024> cat answer.c
-#include "answer.h"
-
-int answer (void)
-{
- return 23;
-}
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O philosophy.c answer.c -o philosophy
-cassini/home/peter/bo/2022ws/hp/20221024> ./philosophy
-The answer is 23.
-cassini/home/peter/bo/2022ws/hp/20221024>
diff --git a/20221024/philosophy-02.txt b/20221024/philosophy-02.txt
deleted file mode 100644
index aeb445c994e232e3ec5b6556cccfaefa567e4b6e..0000000000000000000000000000000000000000
--- a/20221024/philosophy-02.txt
+++ /dev/null
@@ -1,27 +0,0 @@
-cassini/home/peter/bo/2022ws/hp/20221024> cat philosophy.c
-#include <stdio.h>
-#include "answer.h"
-
-int main (void)
-{
- printf ("The answer is %d.\n", answer ());
- return 0;
-}
-cassini/home/peter/bo/2022ws/hp/20221024> cat answer.h
-extern int answer (void);
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O philosophy.c -c
-cassini/home/peter/bo/2022ws/hp/20221024> cat answer.c
-#include "answer.h"
-
-int answer (void)
-{
- return 23;
-}
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O answer.c -c
-cassini/home/peter/bo/2022ws/hp/20221024> ls -l *.o
--rw-r--r-- 1 peter peter 1208 Okt 24 14:19 answer.o
--rw-r--r-- 1 peter peter 1632 Okt 24 14:19 philosophy.o
-cassini/home/peter/bo/2022ws/hp/20221024> gcc philosophy.o answer.o -o philosophy
-cassini/home/peter/bo/2022ws/hp/20221024> ./philosophy
-The answer is 23.
-cassini/home/peter/bo/2022ws/hp/20221024>
diff --git a/20221024/philosophy-03.txt b/20221024/philosophy-03.txt
deleted file mode 100644
index 0478bee33106bc904058cd2ec11ec23154f0c90d..0000000000000000000000000000000000000000
--- a/20221024/philosophy-03.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O philosophy.c -lanswer -o philosophy
-/usr/bin/ld: -lanswer kann nicht gefunden werden
-collect2: error: ld returned 1 exit status
-cassini/home/peter/bo/2022ws/hp/20221024> gcc -Wall -O philosophy.c -L . -lanswer -o philosophy
-cassini/home/peter/bo/2022ws/hp/20221024> ./philosophy
-The answer is 23.
-cassini/home/peter/bo/2022ws/hp/20221024> ls -l *answer*
--rw-r--r-- 1 peter peter 56 Nov 21 2013 answer.c
--rw-r--r-- 1 peter peter 26 Nov 22 2012 answer.h
--rw-r--r-- 1 peter peter 1208 Okt 24 14:19 answer.o
--rw-r--r-- 1 peter peter 1352 Okt 24 14:24 libanswer.a
-cassini/home/peter/bo/2022ws/hp/20221024>
diff --git a/20221024/philosophy.c b/20221024/philosophy.c
deleted file mode 100644
index e9f508a501d9ec66d02e0636a9f6c71f2c7a8594..0000000000000000000000000000000000000000
--- a/20221024/philosophy.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-#include "answer.h"
-
-int main (void)
-{
- printf ("The answer is %d.\n", answer ());
- return 0;
-}
diff --git a/20221024/string-ops-29.c b/20221024/string-ops-29.c
deleted file mode 100644
index 52bad3372f3fe29acd4cff1513d97011e6d65bd3..0000000000000000000000000000000000000000
--- a/20221024/string-ops-29.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char buffer[100] = "";
- sprintf (buffer, "Die Antwort lautet: %d", 42);
- printf ("%s\n", buffer);
-
- return 0;
-
- char *answer = strstr (buffer, "Antwort");
- printf ("%s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-}
diff --git a/20221024/string-ops-30.c b/20221024/string-ops-30.c
deleted file mode 100644
index 7598955bfd6adddaddb9fea4adb91883a4107bad..0000000000000000000000000000000000000000
--- a/20221024/string-ops-30.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char buffer[100] = "";
- snprintf (buffer, 100, "Die Antwort lautet: %d", 42);
- printf ("%s\n", buffer);
-
- return 0;
-
- char *answer = strstr (buffer, "Antwort");
- printf ("%s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-}
diff --git a/20221024/string-ops-31.c b/20221024/string-ops-31.c
deleted file mode 100644
index ba6cba525ef34bd29c7b9ca1c42c983261eabf48..0000000000000000000000000000000000000000
--- a/20221024/string-ops-31.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char buffer[20] = "";
- snprintf (buffer, 20, "Die Antwort lautet: %d", 42);
- printf ("%s\n", buffer);
-
- return 0;
-
- char *answer = strstr (buffer, "Antwort");
- printf ("%s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-}
diff --git a/20221024/string-ops-32.c b/20221024/string-ops-32.c
deleted file mode 100644
index 1e019e9380d0e5905d7ba0df4e7fc99ae52ed689..0000000000000000000000000000000000000000
--- a/20221024/string-ops-32.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char buffer[20] = "";
- snprintf (buffer, 20, "Die Antwort lautet: %d", 42);
- printf ("%s\n", buffer);
-
- for (int i = 0; i < 20; i++)
- printf ("%d ", buffer[i]);
- printf ("\n");
-
- return 0;
-
- char *answer = strstr (buffer, "Antwort");
- printf ("%s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-}
diff --git a/20221024/string-ops-33.c b/20221024/string-ops-33.c
deleted file mode 100644
index e1c1e84fba7eade92c2a0c818104de31b24c5f61..0000000000000000000000000000000000000000
--- a/20221024/string-ops-33.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char buffer[100] = "";
- snprintf (buffer, 100, "Die Antwort lautet: %d", 42);
- printf ("%s\n", buffer);
-
- char *answer = strstr (buffer, "Antwort");
- printf ("%s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- return 0;
-}
diff --git a/20221024/string-ops-34.c b/20221024/string-ops-34.c
deleted file mode 100644
index 6ebc6462291daa9e03981a89cf769e14610e781b..0000000000000000000000000000000000000000
--- a/20221024/string-ops-34.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *buffer = "Wie lautet die Antwort aller Antworten?";
-
- char *answer = strstr (buffer, "Antwort");
- printf ("%s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- return 0;
-}
diff --git a/20221024/string-ops-35.c b/20221024/string-ops-35.c
deleted file mode 100644
index f4fe37ff52dcd147ec15e491ad1fd61e0e2636ca..0000000000000000000000000000000000000000
--- a/20221024/string-ops-35.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *buffer = "Wie lautet die Antwort aller Antworten?";
-
- char *answer = strstr (buffer, "Antwort");
- while (answer)
- {
- printf ("%s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- buffer = answer;
- }
-
- return 0;
-}
diff --git a/20221024/string-ops-36.c b/20221024/string-ops-36.c
deleted file mode 100644
index 5ffbb840d2fa41e69380f70836eb23979abd4e83..0000000000000000000000000000000000000000
--- a/20221024/string-ops-36.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *buffer = "Wie lautet die Antwort aller Antworten?";
-
- char *answer = strstr (buffer, "Antwort");
- while (answer)
- {
- printf ("%s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- buffer = answer + strlen ("Antwort");
- }
-
- return 0;
-}
diff --git a/20221024/string-ops-37.c b/20221024/string-ops-37.c
deleted file mode 100644
index 42272e0cf7323af7042fc3bc6b2cae2cd462e2bb..0000000000000000000000000000000000000000
--- a/20221024/string-ops-37.c
+++ /dev/null
@@ -1,20 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *buffer = "Wie lautet die Antwort aller Antworten?";
-
- char *answer;
- do
- {
- answer = strstr (buffer, "Antwort");
- printf ("%s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- buffer = answer + strlen ("Antwort");
- }
- while (answer);
-
- return 0;
-}
diff --git a/20221024/string-ops-38.c b/20221024/string-ops-38.c
deleted file mode 100644
index 4716dc12e45cc141001359283ae8015b48fcf729..0000000000000000000000000000000000000000
--- a/20221024/string-ops-38.c
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *buffer = "Wie lautet die Antwort aller Antworten?";
-
- char *answer;
- do
- {
- answer = strstr (buffer, "Antwort");
- printf ("%s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- if (strlen (answer) > strlen ("Antwort"))
- buffer = answer + strlen ("Antwort");
- }
- while (answer);
-
- return 0;
-}
diff --git a/20221024/string-ops-39.c b/20221024/string-ops-39.c
deleted file mode 100644
index 63599c10f8067200a09623add6bc65698979d2c0..0000000000000000000000000000000000000000
--- a/20221024/string-ops-39.c
+++ /dev/null
@@ -1,24 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *buffer = "Wie lautet die Antwort aller Antworten?";
-
- char *answer;
- do
- {
- printf ("am Anfang der Schleife\n");
- answer = strstr (buffer, "Antwort");
- printf ("%s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- if (strlen (answer) > strlen ("Antwort"))
- buffer = answer + strlen ("Antwort");
-
- printf ("am Ende der Schleife\n");
- }
- while (answer);
-
- return 0;
-}
diff --git a/20221024/string-ops-40.c b/20221024/string-ops-40.c
deleted file mode 100644
index 4b9382ea1db7cb190411df65b274b0a5e3b5743f..0000000000000000000000000000000000000000
--- a/20221024/string-ops-40.c
+++ /dev/null
@@ -1,24 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *buffer = "Wie lautet die Antwort aller Antworten?";
-
- char *answer;
- do
- {
- printf ("am Anfang der Schleife\n");
- answer = strstr (buffer, "Antwort");
- printf ("answer = %s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- if (strlen (answer) > strlen ("Antwort"))
- buffer = answer + strlen ("Antwort");
-
- printf ("am Ende der Schleife\n");
- }
- while (answer);
-
- return 0;
-}
diff --git a/20221024/string-ops-41.c b/20221024/string-ops-41.c
deleted file mode 100644
index b0ab057b396413ce38b2909efb59dad9887ca562..0000000000000000000000000000000000000000
--- a/20221024/string-ops-41.c
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *buffer = "Wie lautet die Antwort aller Antworten?";
-
- char *answer;
- do
- {
- printf ("am Anfang der Schleife\n");
- answer = strstr (buffer, "Antwort");
- if (answer)
- {
- printf ("answer = %s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- if (strlen (answer) > strlen ("Antwort"))
- buffer = answer + strlen ("Antwort");
- }
- printf ("am Ende der Schleife\n");
- }
- while (answer);
-
- return 0;
-}
diff --git a/20221024/string-ops-42.c b/20221024/string-ops-42.c
deleted file mode 100644
index 5611152af6d81f0e43e7852ef1515f0ff202b50b..0000000000000000000000000000000000000000
--- a/20221024/string-ops-42.c
+++ /dev/null
@@ -1,24 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *buffer = "Wie lautet die Antwort aller Antworten?";
-
- char *answer;
- do
- {
- answer = strstr (buffer, "Antwort");
- if (answer)
- {
- printf ("answer = %s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- if (strlen (answer) > strlen ("Antwort"))
- buffer = answer + strlen ("Antwort");
- }
- }
- while (answer);
-
- return 0;
-}
diff --git a/20221024/string-ops-43.c b/20221024/string-ops-43.c
deleted file mode 100644
index 3393165d283fc91a147d7bd68414fa3638b7fec5..0000000000000000000000000000000000000000
--- a/20221024/string-ops-43.c
+++ /dev/null
@@ -1,24 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *buffer = "Wie lautet die Antwort aller Antworten?";
-
- char *answer;
- do
- {
- answer = strstr (buffer, "Antwort");
- if (!answer)
- break;
-
- printf ("answer = %s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- if (strlen (answer) > strlen ("Antwort"))
- buffer = answer + strlen ("Antwort");
- }
- while (answer);
-
- return 0;
-}
diff --git a/20221024/string-ops-44.c b/20221024/string-ops-44.c
deleted file mode 100644
index 9090e72f4db4d932fe3189652a9e7376c2495ffd..0000000000000000000000000000000000000000
--- a/20221024/string-ops-44.c
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *buffer = "Wie lautet die Antwort aller Antworten?";
-
- char *answer = strstr (buffer, "Antwort");
- while (answer)
- {
- printf ("answer = %s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- if (strlen (answer) > strlen ("Antwort"))
- buffer = answer + strlen ("Antwort");
-
- answer = strstr (buffer, "Antwort");
- }
-
- return 0;
-}
diff --git a/20221024/string-ops-45.c b/20221024/string-ops-45.c
deleted file mode 100644
index e9241d19b9b813d0a4ca249994218306551e27e4..0000000000000000000000000000000000000000
--- a/20221024/string-ops-45.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *buffer = "Wie lautet die Antwort aller Antworten?";
-
- while (char *answer = strstr (buffer, "Antwort"))
- {
- printf ("answer = %s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- if (strlen (answer) > strlen ("Antwort"))
- buffer = answer + strlen ("Antwort");
- }
-
- return 0;
-}
diff --git a/20221024/string-ops-46.c b/20221024/string-ops-46.c
deleted file mode 100644
index c5a455ed55ed22c8c4f204117cff04aa66f1cca2..0000000000000000000000000000000000000000
--- a/20221024/string-ops-46.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *buffer = "Wie lautet die Antwort aller Antworten?";
-
- char *answer;
- while (answer = strstr (buffer, "Antwort"))
- {
- printf ("answer = %s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- if (strlen (answer) > strlen ("Antwort"))
- buffer = answer + strlen ("Antwort");
- }
-
- return 0;
-}
diff --git a/20221024/string-ops-47.c b/20221024/string-ops-47.c
deleted file mode 100644
index ecfdf79dcded01dd158df7c5291c0574e26da47f..0000000000000000000000000000000000000000
--- a/20221024/string-ops-47.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int main (void)
-{
- char *buffer = "Wie lautet die Antwort aller Antworten?";
-
- char *answer;
- while ((answer = strstr (buffer, "Antwort")) != NULL)
- {
- printf ("answer = %s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- if (strlen (answer) > strlen ("Antwort"))
- buffer = answer + strlen ("Antwort");
- }
-
- return 0;
-}
diff --git a/20221024/string-ops-48.c b/20221024/string-ops-48.c
deleted file mode 100644
index 2e06ed6d679f5fb42f844accde21a370531972fc..0000000000000000000000000000000000000000
--- a/20221024/string-ops-48.c
+++ /dev/null
@@ -1,27 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-void search (char *buffer, char **answer)
-{
- *answer = strstr (buffer, "Antwort");
-}
-
-int main (void)
-{
- char *buffer = "Wie lautet die Antwort aller Antworten?";
-
- char *answer;
- search (buffer, &answer);
- while (answer)
- {
- printf ("answer = %s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- if (strlen (answer) > strlen ("Antwort"))
- buffer = answer + strlen ("Antwort");
-
- search (buffer, &answer);
- }
-
- return 0;
-}
diff --git a/20221024/test-01.c b/20221024/test-01.c
deleted file mode 100644
index 111d08bdce2ab333aeadf8b07071df27d38f8ef8..0000000000000000000000000000000000000000
--- a/20221024/test-01.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Test 1\n");
- return 0;
-}
diff --git a/20221024/test-02.c b/20221024/test-02.c
deleted file mode 100644
index ce558a8f73682af3aac928e0557f2554c3482704..0000000000000000000000000000000000000000
--- a/20221024/test-02.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Test 2\n");
- return 0;
-}
diff --git a/20221024/test-03.c b/20221024/test-03.c
deleted file mode 100644
index e7af02664293d81a715f1faf6d368cbb695a0d4e..0000000000000000000000000000000000000000
--- a/20221024/test-03.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Test 3\n");
- return 0;
-}
diff --git a/20221024/test-04.c b/20221024/test-04.c
deleted file mode 100644
index 21cb955281ea2d5027b797447668e599ca600668..0000000000000000000000000000000000000000
--- a/20221024/test-04.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Test 4\n");
- return 0;
-}
diff --git a/20221024/test-05.c b/20221024/test-05.c
deleted file mode 100644
index 8e0ca62231d8fddd26225fdf9f7a0b61d91608fc..0000000000000000000000000000000000000000
--- a/20221024/test-05.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Test 5\n");
- return 0;
-}
diff --git a/20221024/test-06.c b/20221024/test-06.c
deleted file mode 100644
index 35c63e10ed5dbed1f9160292ee112dc8e77ad0f4..0000000000000000000000000000000000000000
--- a/20221024/test-06.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Test 6\n");
- return 0;
-}
diff --git a/20221024/test-07.c b/20221024/test-07.c
deleted file mode 100644
index fbf6b08327d7f8a14b3cfe08a3fe7d4f63aac617..0000000000000000000000000000000000000000
--- a/20221024/test-07.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Test 7\n");
- return 0;
-}
diff --git a/20221024/test-08.c b/20221024/test-08.c
deleted file mode 100644
index f429e361f7a51a1ff568e1503fee0512b2c30440..0000000000000000000000000000000000000000
--- a/20221024/test-08.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Test 8\n");
- return 0;
-}
diff --git a/20221024/test-09.c b/20221024/test-09.c
deleted file mode 100644
index 9ff9c2a4d01d4264d908cd084a08a6bebc8d1b7c..0000000000000000000000000000000000000000
--- a/20221024/test-09.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Test 9\n");
- return 0;
-}
diff --git a/20221024/test-10.c b/20221024/test-10.c
deleted file mode 100644
index c9c0edb469c65011fad2da980df2141df25512b8..0000000000000000000000000000000000000000
--- a/20221024/test-10.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Test 10\n");
- return 0;
-}
diff --git a/20221031/400_points_breadboard.jpg b/20221031/400_points_breadboard.jpg
deleted file mode 100644
index 8ba048255851581a84db16c4d5a50802f7521486..0000000000000000000000000000000000000000
Binary files a/20221031/400_points_breadboard.jpg and /dev/null differ
diff --git a/20221031/Makefile b/20221031/Makefile
deleted file mode 100644
index 7ae33df99f68fcf460324cfbb008f3f7a3863638..0000000000000000000000000000000000000000
--- a/20221031/Makefile
+++ /dev/null
@@ -1,8 +0,0 @@
-%.elf: %.c
- avr-gcc -Wall -Os -mmcu=atmega328p $< -o $@
-
-%.hex: %.elf
- avr-objcopy -O ihex $< $@
-
-download:
- ./download.sh
diff --git a/20221031/Makefile-1 b/20221031/Makefile-1
deleted file mode 100644
index bfc1b10a929f22a8c2f4f0cf0368c78db14ad0b0..0000000000000000000000000000000000000000
--- a/20221031/Makefile-1
+++ /dev/null
@@ -1,8 +0,0 @@
-philosophy: philosophy.o answer.o
- gcc philosophy.o answer.o -o philosophy
-
-answer.o: answer.c answer.h
- gcc -Wall -O answer.c -c
-
-philosophy.o: philosophy.c answer.h
- gcc -Wall -O philosophy.c -c
diff --git a/20221031/Makefile-2 b/20221031/Makefile-2
deleted file mode 100644
index 60aab7c7d51b28879c41e8590ab422e9edfadee5..0000000000000000000000000000000000000000
--- a/20221031/Makefile-2
+++ /dev/null
@@ -1,16 +0,0 @@
-TARGET = philosophy
-OBJECTS = philosophy.o answer.o
-HEADERS = answer.h
-CFLAGS = -Wall -O
-
-$(TARGET): $(OBJECTS)
- gcc $(OBJECTS) -o $(TARGET)
-
-answer.o: answer.c $(HEADERS)
- gcc $(CFLAGS) answer.c -c
-
-philosophy.o: philosophy.c $(HEADERS)
- gcc $(CFLAGS) philosophy.c -c
-
-clean:
- rm -f $(OBJECTS) $(TARGET)
diff --git a/20221031/Makefile-3 b/20221031/Makefile-3
deleted file mode 100644
index 0ac355bfddfd237fe0f1b5062c5a242ab0d3e97e..0000000000000000000000000000000000000000
--- a/20221031/Makefile-3
+++ /dev/null
@@ -1,13 +0,0 @@
-TARGET = philosophy
-OBJECTS = philosophy.o answer.o
-HEADERS = answer.h
-CFLAGS = -Wall -O
-
-$(TARGET): $(OBJECTS)
- gcc $(OBJECTS) -o $(TARGET)
-
-%.o: %.c $(HEADERS)
- gcc $(CFLAGS) $< -c
-
-clean:
- rm -f $(OBJECTS) $(TARGET)
diff --git a/20221031/answer.c b/20221031/answer.c
deleted file mode 100644
index 65a1dc248becb3157f2a226fc7b30df2ffb82e00..0000000000000000000000000000000000000000
--- a/20221031/answer.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "answer.h"
-
-int answer (void)
-{
- return 23;
-}
diff --git a/20221031/answer.h b/20221031/answer.h
deleted file mode 100644
index b6777e8210983d315b3ac3424a61bd9c9f0437b1..0000000000000000000000000000000000000000
--- a/20221031/answer.h
+++ /dev/null
@@ -1 +0,0 @@
-extern int answer (void);
diff --git a/20221031/aufgabe-2.c b/20221031/aufgabe-2.c
deleted file mode 100644
index 1afa7b1260506cb307aff5f929c6357c7bdcb708..0000000000000000000000000000000000000000
--- a/20221031/aufgabe-2.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <avr/io.h>
-
-int main (void)
-{
- DDRA = 0xff;
- DDRB = 0xff;
- DDRC = 0xff;
- DDRD = 0xff;
- PORTA = 0x1f;
- PORTB = 0x10;
- PORTD = 0x10;
- PORTC = 0xfc;
- while (1);
- return 0;
-}
diff --git a/20221031/aufgabe-3.c b/20221031/aufgabe-3.c
deleted file mode 100644
index 9ae72941b931c04f3c380cb3bbcd64bec7f08c20..0000000000000000000000000000000000000000
--- a/20221031/aufgabe-3.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-void insert_into_string (char src, char *target, int pos)
-{
- int len = strlen (target);
- for (int i = pos; i < len; i++)
- target[i+1] = target[i];
- target[pos] = src;
-}
-
-int main (void)
-{
- char test[100] = "Hochshule Bochum";
- insert_into_string ('c', test, 5);
- printf ("%s\n", test);
- return 0;
-}
diff --git a/20221031/bit-operations-01.txt b/20221031/bit-operations-01.txt
deleted file mode 100644
index 755e818c94957694eef920f7b158f2c1d18803ae..0000000000000000000000000000000000000000
--- a/20221031/bit-operations-01.txt
+++ /dev/null
@@ -1,46 +0,0 @@
-
- A = 0011 1010 ein Bit auf 1 setzen
- | 0000 0100 bitweise Oder-Verknüpfung mit "Maske" (oder "Bitmaske")
- ---------
- 0011 1110
-
- A = 0011 1010 ein Bit auf 1 setzen
- | 0000 1000 bitweise Oder-Verknüpfung mit "Maske" (oder "Bitmaske")
- ---------
- 0011 1010
-
- A = 0011 1010 ein Bit auf 0 setzen
- & 1111 0111 bitweise Und-Verknüpfung mit "Maske" (oder "Bitmaske")
- ---------
- 0011 0010
-
-Maske für Und = Einerkomplement der Maske für Oder (und umgekehrt)
-
-In C:
-
- Oder-Verknüpfung: C = A | B A |= B
- Und-Verknüpfung: C = A & B A &= B
- Einerkomplement: C = ~A
-
-Erzeugen einer Oder-Maske: Bit-Verschiebung einer 1 nach links
-
- 0000 0001 << 2 = 0000 0100 Sprechweise: "Bit 2"
- 0000 0001 << 0 = 0000 0001 Sprechweise: "Bit 0"
-
- Durchnumerierung der Bits: von rechts, beginnend mit 0
-
-Erzeugen einer Und-Maske: Einerkomplement einer Oder-Maske
-
- ~(0000 0001 << 2) = 1111 1011 Sprechweise: "Bit 2"
- ~(0000 0001 << 0) = 1111 1110 Sprechweise: "Bit 0"
-
-
- A = 0011 1010 ein Bit umklappen
- ^ 0000 1000 bitweise Exklusiv-Oder-Verknüpfung mit "Maske" (oder "Bitmaske")
- ---------
- 0011 0010
-
- A = 0011 1010 ein Bit abfragen
- & 0000 1000 bitweise Und-Verknüpfung mit Oder-Maske
- ---------
- 0000 1000 != 0 Ergebnis ungleich 0 bedeutet: Bit ist gesetzt
diff --git a/20221031/blink-0.c b/20221031/blink-0.c
deleted file mode 100644
index b0022c681fd1482ed0a6d9fded7bb0a54699de32..0000000000000000000000000000000000000000
--- a/20221031/blink-0.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <avr/io.h>
-
-int main (void)
-{
- DDRD = 0x40; /* binär: 0100 0000 */
- PORTD = 0x40; /* binär: 0100 0000 */
- while (1);
- return 0;
-}
diff --git a/20221031/blink-0.hex b/20221031/blink-0.hex
deleted file mode 100644
index 6a05b7db67b71fe56b83474cab2ab278834e3777..0000000000000000000000000000000000000000
--- a/20221031/blink-0.hex
+++ /dev/null
@@ -1,10 +0,0 @@
-:100000000C9434000C943E000C943E000C943E0082
-:100010000C943E000C943E000C943E000C943E0068
-:100020000C943E000C943E000C943E000C943E0058
-:100030000C943E000C943E000C943E000C943E0048
-:100040000C943E000C943E000C943E000C943E0038
-:100050000C943E000C943E000C943E000C943E0028
-:100060000C943E000C943E0011241FBECFEFD8E04C
-:10007000DEBFCDBF0E9440000C9444000C940000F1
-:0C00800080E48AB98BB9FFCFF894FFCF61
-:00000001FF
diff --git a/20221031/blink-0.txt b/20221031/blink-0.txt
deleted file mode 100644
index e6c0b93daa66a274edeb47e355ca87175f609715..0000000000000000000000000000000000000000
--- a/20221031/blink-0.txt
+++ /dev/null
@@ -1,79 +0,0 @@
-cassini/home/peter/bo/2022ws/hp/20221031> cat blink-0.c
-#include <avr/io.h>
-
-int main (void)
-{
- DDRD = 0x40; /* binär: 0100 0000 */
- PORTD = 0x40; /* binär: 0100 0000 */
- while (1);
- return 0;
-}
-cassini/home/peter/bo/2022ws/hp/20221031> gcc -Wall -O blink-0.c -o blink-0
-blink-0.c:1:10: fatal error: avr/io.h: Datei oder Verzeichnis nicht gefunden
- #include <avr/io.h>
- ^~~~~~~~~~
-compilation terminated.
-cassini/home/peter/bo/2022ws/hp/20221031> cat Makefile
-%.elf: %.c
- avr-gcc -Wall -Os -mmcu=atmega328p $< -o $@
-
-%.hex: %.elf
- avr-objcopy -O ihex $< $@
-
-download:
- ./download.sh
-cassini/home/peter/bo/2022ws/hp/20221031> avr-gcc -Wall -Os -mmcu=atmega328p blink-0.c -o blink-0.elf
-cassini/home/peter/bo/2022ws/hp/20221031> ls -l blink-0.*
--rw-r--r-- 1 peter peter 148 Jan 4 2021 blink-0.c
--rwxr-xr-x 1 peter peter 6360 Okt 31 15:01 blink-0.elf
-cassini/home/peter/bo/2022ws/hp/20221031> ./blink-0.elf
-bash: ./blink-0.elf: Kann die Binärdatei nicht ausführen: Fehler im Format der Programmdatei
-cassini/home/peter/bo/2022ws/hp/20221031> avr-objcopy -O ihex blink-0.elf blink-0.hex
-cassini/home/peter/bo/2022ws/hp/20221031> cat blink-0.hex
-:100000000C9434000C943E000C943E000C943E0082
-:100010000C943E000C943E000C943E000C943E0068
-:100020000C943E000C943E000C943E000C943E0058
-:100030000C943E000C943E000C943E000C943E0048
-:100040000C943E000C943E000C943E000C943E0038
-:100050000C943E000C943E000C943E000C943E0028
-:100060000C943E000C943E0011241FBECFEFD8E04C
-:10007000DEBFCDBF0E9440000C9444000C940000F1
-:0C00800080E48AB98BB9FFCFF894FFCF61
-:00000001FF
-cassini/home/peter/bo/2022ws/hp/20221031> cat download.sh
-port=$(ls -rt /dev/ttyACM* | tail -1)
-echo avrdude -P $port -c arduino -p m328p -U flash:w:$(ls -rt *.hex | tail -1)
-avrdude -P $port -c arduino -p m328p -U flash:w:$(ls -rt *.hex | tail -1) 2>/dev/null
-cassini/home/peter/bo/2022ws/hp/20221031> avrdude -P /dev/ttyACM0 -c arduino -p m328p -U flash:w:blink-0.hex
-
-avrdude: AVR device initialized and ready to accept instructions
-
-Reading | ################################################## | 100% 0.00s
-
-avrdude: Device signature = 0x1e950f (probably m328p)
-avrdude: NOTE: "flash" memory has been specified, an erase cycle will be performed
- To disable this feature, specify the -D option.
-avrdude: erasing chip
-avrdude: reading input file "blink-0.hex"
-avrdude: input file blink-0.hex auto detected as Intel Hex
-avrdude: writing flash (140 bytes):
-
-Writing | ################################################## | 100% 0.04s
-
-avrdude: 140 bytes of flash written
-avrdude: verifying flash memory against blink-0.hex:
-avrdude: load data flash data from input file blink-0.hex:
-avrdude: input file blink-0.hex auto detected as Intel Hex
-avrdude: input file blink-0.hex contains 140 bytes
-avrdude: reading on-chip flash data:
-
-Reading | ################################################## | 100% 0.03s
-
-avrdude: verifying ...
-avrdude: 140 bytes of flash verified
-
-avrdude: safemode: Fuses OK (E:00, H:00, L:00)
-
-avrdude done. Thank you.
-
-cassini/home/peter/bo/2022ws/hp/20221031>
diff --git a/20221031/blink-0a.c b/20221031/blink-0a.c
deleted file mode 100644
index 7093fa4cbf094be60a9ae35117c84be13258235c..0000000000000000000000000000000000000000
--- a/20221031/blink-0a.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <avr/io.h>
-
-int main (void)
-{
- DDRD = 0x40; /* binär: 0100 0000 */
- PORTD = 0x00; /* binär: 0000 0000 */
- while (1);
- return 0;
-}
diff --git a/20221031/blink-1.c b/20221031/blink-1.c
deleted file mode 100644
index 6d28dce84f94375094c98479c30a54ace1b2a9d9..0000000000000000000000000000000000000000
--- a/20221031/blink-1.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <avr/io.h>
-
-#define F_CPU 16000000l
-#include <util/delay.h>
-
-int main (void)
-{
- DDRD = 0x01;
- PORTD |= 0x01;
- while (1)
- {
- _delay_ms (500);
- PORTD &= ~0x01;
- _delay_ms (500);
- PORTD |= 0x01;
- }
- return 0;
-}
diff --git a/20221031/blink-1a.c b/20221031/blink-1a.c
deleted file mode 100644
index f594cc175fa238d3ba3f930bc8bcbfeb1ddaa43b..0000000000000000000000000000000000000000
--- a/20221031/blink-1a.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <avr/io.h>
-
-#define F_CPU 16000000l
-#include <util/delay.h>
-
-int main (void)
-{
- DDRD = 0xff; /* 1111 1111 --> alle Ports als Output-Ports nutzen */
- PORTD = 0x1a; /* 0001 1010 */
- while (1)
- {
- _delay_ms (500);
- PORTD &= ~0x01;
- _delay_ms (500);
- PORTD |= 0x01;
- }
- return 0;
-}
diff --git a/20221031/blink-1b.c b/20221031/blink-1b.c
deleted file mode 100644
index f435112888a5ba118a33c689de63462776d1d072..0000000000000000000000000000000000000000
--- a/20221031/blink-1b.c
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <avr/io.h>
-
-#define F_CPU 16000000l
-#include <util/delay.h>
-
-int main (void)
-{
- DDRD = 0x7f; /* 0111 1111 --> alle Ports als Output-Ports nutzen */
- PORTD = 0x01; /* 0000 0001 */
- while (1)
- {
- while (PIND & 0x80) /* 1000 0000 */
- {
- _delay_ms (500);
- PORTD &= ~0x01;
- _delay_ms (500);
- PORTD |= 0x01;
- }
- }
- return 0;
-}
diff --git a/20221031/download.sh b/20221031/download.sh
deleted file mode 100755
index 770c3b5dca74ac09778be055c9d6f5adb0df293b..0000000000000000000000000000000000000000
--- a/20221031/download.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-port=$(ls -rt /dev/ttyACM* | tail -1)
-echo avrdude -P $port -c arduino -p m328p -U flash:w:$(ls -rt *.hex | tail -1)
-avrdude -P $port -c arduino -p m328p -U flash:w:$(ls -rt *.hex | tail -1) 2>/dev/null
diff --git a/20221031/gtk-04.c b/20221031/gtk-04.c
deleted file mode 100644
index 132dbcb61fb979372da88225e8cb881d2b81a2d4..0000000000000000000000000000000000000000
--- a/20221031/gtk-04.c
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <gtk/gtk.h>
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
-
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_container_add (GTK_CONTAINER (vbox), drawing_area);
-
- gtk_widget_show (drawing_area);
- gtk_widget_show (button);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
-}
diff --git a/20221031/gtk-05.c b/20221031/gtk-05.c
deleted file mode 100644
index c77feaac44766ae3e7b157d3a72e03f62c9c687b..0000000000000000000000000000000000000000
--- a/20221031/gtk-05.c
+++ /dev/null
@@ -1,27 +0,0 @@
-#include <gtk/gtk.h>
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
-
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_container_add (GTK_CONTAINER (vbox), drawing_area);
- gtk_widget_set_size_request (drawing_area, 100, 100);
-
- gtk_widget_show (drawing_area);
- gtk_widget_show (button);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
-}
diff --git a/20221031/gtk-06.c b/20221031/gtk-06.c
deleted file mode 100644
index 81e12e6958d3c0adbed8d315927104482bc4c681..0000000000000000000000000000000000000000
--- a/20221031/gtk-06.c
+++ /dev/null
@@ -1,53 +0,0 @@
-#include <gtk/gtk.h>
-
-gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
-{
- GdkRGBA red = { 1.0, 0.0, 0.0, 0.8 };
- GdkRGBA yellow = { 1.0, 1.0, 0.0, 0.6 };
- GdkRGBA blue = { 0.0, 0.5, 1.0, 0.4 };
-
- gdk_cairo_set_source_rgba (c, &red);
- cairo_rectangle (c, 10, 10, 60, 40);
- cairo_fill (c);
-
- gdk_cairo_set_source_rgba (c, &yellow);
- cairo_arc (c, 65, 50, 30, 0, 2 * G_PI);
- cairo_fill (c);
-
- gdk_cairo_set_source_rgba (c, &blue);
- cairo_move_to (c, 10, 70);
- cairo_line_to (c, 70, 70);
- cairo_line_to (c, 40, 18);
- cairo_close_path (c);
- cairo_fill (c);
-
- return FALSE; /* TRUE to stop other handlers from being invoked for the event.
- FALSE to propagate the event further. */
-}
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
-
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_container_add (GTK_CONTAINER (vbox), drawing_area);
- g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
- gtk_widget_set_size_request (drawing_area, 100, 100);
-
- gtk_widget_show (drawing_area);
- gtk_widget_show (button);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
-}
diff --git a/20221031/gtk-07.c b/20221031/gtk-07.c
deleted file mode 100644
index 11041fbe1d27585ca4edb951f195f114ddad126e..0000000000000000000000000000000000000000
--- a/20221031/gtk-07.c
+++ /dev/null
@@ -1,71 +0,0 @@
-#include <stdio.h>
-#include <gtk/gtk.h>
-
-gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
-{
- GdkRGBA red = { 1.0, 0.0, 0.0, 0.8 };
- GdkRGBA yellow = { 1.0, 1.0, 0.0, 0.6 };
- GdkRGBA blue = { 0.0, 0.5, 1.0, 0.4 };
-
- gdk_cairo_set_source_rgba (c, &red);
- cairo_rectangle (c, 10, 10, 60, 40);
- cairo_fill (c);
-
- gdk_cairo_set_source_rgba (c, &yellow);
- cairo_arc (c, 65, 50, 30, 0, 2 * G_PI);
- cairo_fill (c);
-
- gdk_cairo_set_source_rgba (c, &blue);
- cairo_move_to (c, 10, 70);
- cairo_line_to (c, 70, 70);
- cairo_line_to (c, 40, 18);
- cairo_close_path (c);
- cairo_fill (c);
-
- return FALSE; /* TRUE to stop other handlers from being invoked for the event.
- FALSE to propagate the event further. */
-}
-
-gboolean button_press (GtkWidget *widget, GdkEventButton *e, gpointer data)
-{
- printf ("button %d pressed at (%lf, %lf)\n", e->button, e->x, e->y);
- return FALSE;
-}
-
-gboolean key_press (GtkWidget *widget, GdkEventKey *e, gpointer data)
-{
- printf ("key '%c' (%d) pressed\n", e->keyval, e->keyval);
- return FALSE;
-}
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
-
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_container_add (GTK_CONTAINER (vbox), drawing_area);
- g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
- gtk_widget_set_size_request (drawing_area, 100, 100);
- gtk_widget_add_events (drawing_area, GDK_BUTTON_PRESS_MASK);
- g_signal_connect (drawing_area, "button_press_event", G_CALLBACK (button_press), NULL);
-
- gtk_widget_add_events (window, GDK_KEY_PRESS_MASK);
- g_signal_connect (window, "key_press_event", G_CALLBACK (key_press), NULL);
-
- gtk_widget_show (drawing_area);
- gtk_widget_show (button);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
-}
diff --git a/20221031/gtk-08.c b/20221031/gtk-08.c
deleted file mode 100644
index d3092d009f1b20909a96ed89be3cfe971c11263f..0000000000000000000000000000000000000000
--- a/20221031/gtk-08.c
+++ /dev/null
@@ -1,54 +0,0 @@
-#include <gtk/gtk.h>
-
-#define WIDTH 320
-#define HEIGHT 240
-
-double x = 5;
-double y = 95;
-
-gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
-{
- GdkRGBA blue = { 0.0, 0.5, 1.0, 1.0 };
- gdk_cairo_set_source_rgba (c, &blue);
- cairo_arc (c, x, y, 5, 0, 2 * G_PI);
- cairo_fill (c);
- return FALSE;
-}
-
-gboolean timer (GtkWidget *widget)
-{
- x += 0.5;
- y -= 0.7;
- gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
-}
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
-
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_container_add (GTK_CONTAINER (vbox), drawing_area);
- g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
- gtk_widget_set_size_request (drawing_area, WIDTH, HEIGHT);
-
- g_timeout_add (50, (GSourceFunc) timer, drawing_area);
-
- gtk_widget_show (drawing_area);
- gtk_widget_show (button);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
-}
diff --git a/20221031/gtk-09.c b/20221031/gtk-09.c
deleted file mode 100644
index 91af21857c6bb810659fbb4c11afbcab293fa188..0000000000000000000000000000000000000000
--- a/20221031/gtk-09.c
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <gtk/gtk.h>
-
-#define WIDTH 320
-#define HEIGHT 240
-
-double x = 5;
-double y = 95;
-double vx = 0.5;
-double vy = 0.7;
-double dt = 0.05;
-double g = 9.81;
-
-gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
-{
- GdkRGBA blue = { 0.0, 0.5, 1.0, 1.0 };
- gdk_cairo_set_source_rgba (c, &blue);
- cairo_arc (c, x, y, 5, 0, 2 * G_PI);
- cairo_fill (c);
- return FALSE;
-}
-
-gboolean timer (GtkWidget *widget)
-{
- x += vx * dt;
- y += vy * dt;
- vx += 0.0 * dt;
- vy += (-g) * dt;
- gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
-}
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
-
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_container_add (GTK_CONTAINER (vbox), drawing_area);
- g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
- gtk_widget_set_size_request (drawing_area, WIDTH, HEIGHT);
-
- g_timeout_add (50, (GSourceFunc) timer, drawing_area);
-
- gtk_widget_show (drawing_area);
- gtk_widget_show (button);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
-}
diff --git a/20221031/gtk-10.c b/20221031/gtk-10.c
deleted file mode 100644
index f7fb2d5b1c4d3f1082a15b8f3a23fb5480fdd4f1..0000000000000000000000000000000000000000
--- a/20221031/gtk-10.c
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <gtk/gtk.h>
-
-#define WIDTH 320
-#define HEIGHT 240
-
-double x = 5;
-double y = 95;
-double vx = 0.5;
-double vy = 0.7;
-double dt = 0.05;
-double g = 9.81;
-
-gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
-{
- GdkRGBA blue = { 0.0, 0.5, 1.0, 1.0 };
- gdk_cairo_set_source_rgba (c, &blue);
- cairo_arc (c, x, HEIGHT - y, 5, 0, 2 * G_PI);
- cairo_fill (c);
- return FALSE;
-}
-
-gboolean timer (GtkWidget *widget)
-{
- x += vx * dt;
- y += vy * dt;
- vx += 0.0 * dt;
- vy += (-g) * dt;
- gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
-}
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
-
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_container_add (GTK_CONTAINER (vbox), drawing_area);
- g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
- gtk_widget_set_size_request (drawing_area, WIDTH, HEIGHT);
-
- g_timeout_add (50, (GSourceFunc) timer, drawing_area);
-
- gtk_widget_show (drawing_area);
- gtk_widget_show (button);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
-}
diff --git a/20221031/gtk-11.c b/20221031/gtk-11.c
deleted file mode 100644
index 1fa3d7169dc09ed0a5e89abffdce3cb297509842..0000000000000000000000000000000000000000
--- a/20221031/gtk-11.c
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <gtk/gtk.h>
-
-#define WIDTH 640
-#define HEIGHT 480
-
-double x = 5;
-double y = 95;
-double vx = 0.5;
-double vy = 0.7;
-double dt = 0.05;
-double g = 9.81;
-
-gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
-{
- GdkRGBA blue = { 0.0, 0.5, 1.0, 1.0 };
- gdk_cairo_set_source_rgba (c, &blue);
- cairo_arc (c, x, HEIGHT - y, 5, 0, 2 * G_PI);
- cairo_fill (c);
- return FALSE;
-}
-
-gboolean timer (GtkWidget *widget)
-{
- x += vx * dt;
- y += vy * dt;
- vx += 0.0 * dt;
- vy += (-g) * dt;
- gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
-}
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
-
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_container_add (GTK_CONTAINER (vbox), drawing_area);
- g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
- gtk_widget_set_size_request (drawing_area, WIDTH, HEIGHT);
-
- g_timeout_add (50, (GSourceFunc) timer, drawing_area);
-
- gtk_widget_show (drawing_area);
- gtk_widget_show (button);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
-}
diff --git a/20221031/gtk-12.c b/20221031/gtk-12.c
deleted file mode 100644
index e0c274336e1ea7a21983daaa95a563796b532e25..0000000000000000000000000000000000000000
--- a/20221031/gtk-12.c
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <gtk/gtk.h>
-
-#define WIDTH 640
-#define HEIGHT 480
-
-double x = 5;
-double y = 95;
-double vx = 5.0;
-double vy = 0.7;
-double dt = 0.05;
-double g = 9.81;
-
-gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
-{
- GdkRGBA blue = { 0.0, 0.5, 1.0, 1.0 };
- gdk_cairo_set_source_rgba (c, &blue);
- cairo_arc (c, x, HEIGHT - y, 5, 0, 2 * G_PI);
- cairo_fill (c);
- return FALSE;
-}
-
-gboolean timer (GtkWidget *widget)
-{
- x += vx * dt;
- y += vy * dt;
- vx += 0.0 * dt;
- vy += (-g) * dt;
- gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
-}
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
-
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_container_add (GTK_CONTAINER (vbox), drawing_area);
- g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
- gtk_widget_set_size_request (drawing_area, WIDTH, HEIGHT);
-
- g_timeout_add (50, (GSourceFunc) timer, drawing_area);
-
- gtk_widget_show (drawing_area);
- gtk_widget_show (button);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
-}
diff --git a/20221031/higher-math-06.c b/20221031/higher-math-06.c
deleted file mode 100644
index 973ebb7a5cdd6a72036e5896b21724fd83e96eee..0000000000000000000000000000000000000000
--- a/20221031/higher-math-06.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-#define SIX 1 + 5
-#define NINE 8 + 1
-
-int main (void)
-{
- printf ("Six times nine = %d.\n", SIX * NINE);
- return 0;
-}
diff --git a/20221031/higher-math-06.txt b/20221031/higher-math-06.txt
deleted file mode 100644
index 39cf04fd7e451b1585739a0a6cf1e3a688ebe0c9..0000000000000000000000000000000000000000
--- a/20221031/higher-math-06.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-cassini/home/peter/bo/2022ws/hp/20221031> gcc -Wall -O higher-math-06.c -E -P | tail
-__attribute__ ((__nothrow__ , __leaf__)) ferror_unlocked (FILE *__stream)
-{
- return (((__stream)->_flags & 0x0020) != 0);
-}
-
-int main (void)
-{
- printf ("Six times nine = %d.\n", 1 + 5 * 8 + 1);
- return 0;
-}
-cassini/home/peter/bo/2022ws/hp/20221031>
diff --git a/20221031/higher-math-07.c b/20221031/higher-math-07.c
deleted file mode 100644
index a422dcca1512afa4e3daf48f242f5fd1264d5494..0000000000000000000000000000000000000000
--- a/20221031/higher-math-07.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-
-#define SIX 1 + 5
-#define NINE 8 + 1
-
-int main (void)
-{
- printf ("Six = %d.\n", SIX);
- printf ("Nine = %d.\n", NINE);
- printf ("Six times nine = %d.\n", SIX * NINE);
- return 0;
-}
diff --git a/20221031/hp-20221031.pdf b/20221031/hp-20221031.pdf
deleted file mode 100644
index 7e293396b330de1685fd4d03ccc9becee7c4a797..0000000000000000000000000000000000000000
Binary files a/20221031/hp-20221031.pdf and /dev/null differ
diff --git a/20221031/hp-20221031.tex b/20221031/hp-20221031.tex
deleted file mode 100644
index 42b011c21588311a5ff7d48eb1ff7db39ef7118f..0000000000000000000000000000000000000000
--- a/20221031/hp-20221031.tex
+++ /dev/null
@@ -1,812 +0,0 @@
-% hp-20221031.pdf - Lecture Slides on Low-Level Programming
-% Copyright (C) 2012, 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Callback-Funktionen, make, Bit-Operationen, I/O-Ports
-
-\documentclass[10pt,t]{beamer}
-
-\usepackage{pgslides}
-\usepackage{pdftricks}
-\usepackage{tikz}
-
-\begin{psinputs}
- \usepackage[utf8]{inputenc}
- \usepackage[german]{babel}
- \usepackage[T1]{fontenc}
- \usepackage{helvet}
- \renewcommand*\familydefault{\sfdefault}
- \usepackage{pstricks,pst-grad}
-\end{psinputs}
-
-\newcommand{\redurl}[1]{\href{#1}{\color{red}\nolinkurl{#1}}}
-
-\title{Hardwarenahe Programmierung}
-\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
-\date{31.\ Oktober 2022}
-
-\begin{document}
-
-\maketitleframe
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \begin{itemize}
- \vspace*{-\smallskipamount}
- \item[\dots]
- \item[2.13] Dateien und Fehlerbehandlung
- \item[2.14] Parameter des Hauptprogramms
- \color{medgreen}
- \item[2.15] String-Operationen
- \end{itemize}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \begin{itemize}
- \color{medgreen}
- \item[3.1] Der Präprozessor
- \item[3.2] Bibliotheken einbinden
- \color{orange}
- \item[3.3] Bibliotheken verwenden
- \color{red}
- \item[3.4] Projekt organisieren: make
- \end{itemize}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \item[\textbf{5}] \textbf{Algorithmen}
- \vspace*{-\smallskipamount}
- \item[\textbf{\dots}]
- \end{itemize}
-
-\end{frame}
-
-\setcounter{section}{1}
-\section{Einführung in C}
-\setcounter{subsection}{13}
-\subsection{String-Operationen}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \vspace*{-0.4cm}
- \begin{lstlisting}
- #include <stdio.h>
- #include <string.h>
-
- int main (void)
- {
- char buffer[100] = "";
- sprintf (buffer, "Die Antwort lautet: %d", 42);
- printf ("%s\n", buffer);
-
- char *answer = strstr (buffer, "Antwort");
- printf ("%s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- return 0;
- }
- \end{lstlisting}
- \vspace*{-1cm}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \vspace*{-0.4cm}
- \begin{lstlisting}
- #include <stdio.h>
- #include <string.h>
-
- int main (void)
- {
- char buffer[100] = "";
- snprintf (buffer, 100, "Die Antwort lautet: %d", 42);
- printf ("%s\n", buffer);
-
- char *answer = strstr (buffer, "Antwort");
- printf ("%s\n", answer);
- printf ("found at: %zd\n", answer - buffer);
-
- return 0;
- }
- \end{lstlisting}
-
-\end{frame}
-
-\begin{frame}
-
- \showsection
-
- Sprachelemente weitgehend komplett
-
- \bigskip
- Es fehlen:
- \begin{itemize}
- \item
- Ergänzungen (z.\,B.\ ternärer Operator, \lstinline{union}, \lstinline{unsigned}, \lstinline{volatile})
- \item
- Bibliotheksfunktionen (z.\,B.\ \lstinline{malloc()})
- \arrowitem
- werden eingeführt, wenn wir sie brauchen
- \bigskip
- \item
- Konzepte (z.\,B.\ rekursive Datenstrukturen, Klassen selbst bauen)
- \arrowitem
- werden eingeführt, wenn wir sie brauchen, oder:
- \arrowitem
- Literatur\\[\smallskipamount]
- (z.\,B.\ Wikibooks: C-Programmierung,\\
- Dokumentation zu Compiler und Bibliotheken)
- \bigskip
- \item
- Praxiserfahrung
- \arrowitem
- Übung und Praktikum: nur Einstieg
- \arrowitem
- selbständig arbeiten
- \end{itemize}
-\end{frame}
-
-\section{Bibliotheken}
-\subsection{Der Präprozessor}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \lstinline{#include}: %\pause:
- Text einbinden
- \begin{itemize}
-% \pause
- \item
- \lstinline{#include <stdio.h>}: Standard-Verzeichnisse -- Standard-Header
-% \pause
- \item
- \lstinline{#include "answer.h"}: auch aktuelles Verzeichnis -- eigene Header
- \end{itemize}
-
-% \pause
- \bigskip
-
- \lstinline{#define SIX 6}: Text ersetzen lassen -- Konstante definieren
- \begin{itemize}
-% \pause
- \item
- Kein Semikolon!
-% \pause
- \item
- Berechnungen in Klammern setzen:\\
- \lstinline{#define SIX (1 + 5)}
-% \pause
- \item
- Konvention: Großbuchstaben
- \end{itemize}
-
- Zum Debuggen: \lstinline[style=cmd]{gcc -E -P}
-
-\end{frame}
-
-\subsection{Bibliotheken einbinden}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- Inhalt der Header-Datei: externe Deklarationen
-
-% \pause
- \smallskip
- \lstinline{extern int answer (void);}
-
-% \pause
- \smallskip
- \lstinline{extern int printf (__const char *__restrict __format, ...);}
-
-% \pause
- \bigskip
- Funktion wird "`anderswo"' definiert
- \begin{itemize}
-% \pause
- \item
- separater C-Quelltext: mit an \lstinline[style=terminal]{gcc} übergeben
-% \pause
- \item
- Zusammenfügen zu ausführbarem Programm durch den \newterm{Linker}
-% \pause
- \item
- vorcompilierte Bibliothek: \lstinline[style=terminal]{-lfoo}\\
-% \pause
- = Datei \file{libfoo.a} in Standard-Verzeichnis
- \end{itemize}
-
-\end{frame}
-
-\subsection{Bibliothek verwenden (Beispiel: GTK+)}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{itemize}
- \item
- \lstinline{#include <gtk/gtk.h>}
- \pause
- \smallskip
- \item
- Mit \lstinline[style=cmd]{pkg-config --cflags --libs} erfährt man,\\
- welche Optionen und Bibliotheken man an \lstinline[style=cmd]{gcc}
- übergeben muß\alt<4->{.}{:}
- \pause
- \begin{onlyenv}<3>
- \begin{lstlisting}[style=terminal,gobble=10]
- $ ¡pkg-config --cflags --libs gtk+-3.0¿
- -pthread -I/usr/include/gtk-3.0 -I/usr/include/at-spi2-
- atk/2.0 -I/usr/include/at-spi-2.0 -I/usr/include/dbus-1
- .0 -I/usr/lib/x86_64-linux-gnu/dbus-1.0/include -I/usr/
- include/gtk-3.0 -I/usr/include/gio-unix-2.0/ -I/usr/inc
- lude/cairo -I/usr/include/pango-1.0 -I/usr/include/harf
- buzz -I/usr/include/pango-1.0 -I/usr/include/atk-1.0 -I
- /usr/include/cairo -I/usr/include/pixman-1 -I/usr/inclu
- de/freetype2 -I/usr/include/libpng16 -I/usr/include/gdk
- -pixbuf-2.0 -I/usr/include/libpng16 -I/usr/include/glib
- -2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -lgtk
- -3 -lgdk-3 -lpangocairo-1.0 -lpango-1.0 -latk-1.0 -lcai
- ro-gobject -lcairo -lgdk_pixbuf-2.0 -lgio-2.0 -lgobject
- -2.0 -lglib-2.0
- \end{lstlisting}
- \vspace*{-3cm}
- \end{onlyenv}
- \pause
- \arrowitem
- Compiler-Aufruf:
- \begin{onlyenv}<4>
- \begin{lstlisting}[style=terminal,gobble=10]
- $ ¡gcc -Wall -O hello-gtk.c -pthread -I/usr/include/gtk-
- 3.0 -I/usr/include/at-spi2-atk/2.0 -I/usr/include/at-sp
- i-2.0 -I/usr/include/dbus-1.0 -I/usr/lib/x86_64-linux-g
- nu/dbus-1.0/include -I/usr/include/gtk-3.0 -I/usr/inclu
- de/gio-unix-2.0/ -I/usr/include/cairo -I/usr/include/pa
- ngo-1.0 -I/usr/include/harfbuzz -I/usr/include/pango-1.
- 0 -I/usr/include/atk-1.0 -I/usr/include/cairo -I/usr/in
- clude/pixman-1 -I/usr/include/freetype2 -I/usr/include/
- libpng16 -I/usr/include/gdk-pixbuf-2.0 -I/usr/include/l
- ibpng16 -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux
- -gnu/glib-2.0/include -lgtk-3 -lgdk-3 -lpangocairo-1.0
- -lpango-1.0 -latk-1.0 -lcairo-gobject -lcairo -lgdk_pix
- buf-2.0 -lgio-2.0 -lgobject-2.0 -lglib-2.0 -o hello-gtk¿
- \end{lstlisting}
- \vspace*{-2cm}
- \end{onlyenv}
- \begin{onlyenv}<5->
- \begin{lstlisting}[style=terminal,gobble=10]
- $ ¡gcc -Wall -O hello-gtk.c $(pkg-config --cflags --libs
- gtk+-3.0) -o hello-gtk¿
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<5>
- \begin{picture}(0,0)(0.3,0.3)
- \color{red}
- \put(6.6,-0.6){\makebox(0,0)[bl]{\tikz{\draw[-latex](0,0)--(3,1.5);}}}
- \put(6.3,-0.7){\makebox(0,0)[t]{\shortstack{\strut Optionen:\\
- \strut u.\,a.\ viele Include-Verzeichnisse:\\
- \lstinline[style=cmd]{-I/usr/include/gtk-3.0}}}}
- \put(10.0,-2.1){\makebox(0,0)[bl]{\tikz{\draw[-latex](0,0)--(1.5,3);}}}
- \put(10.3,-2.2){\makebox(0,0)[t]{\shortstack{\strut Bibliotheken:\\
- \strut u.\,a.\ \lstinline[style=cmd]{-lgtk-3 -lcairo}~~~\strut}}}
- \end{picture}
- \end{onlyenv}
- \pause
- \pause
- \item
- Auf manchen Plattformen kommt es auf die Reihenfolge an:
- \begin{lstlisting}[style=terminal,gobble=8]
- $ ¡gcc -Wall -O $(pkg-config --cflags gtk+-3.0) \
- hello-gtk.c $(pkg-config --libs gtk+-3.0) \
- -o hello-gtk¿
- \end{lstlisting}
- (Backslash = "`Es geht in der nächsten Zeile weiter."')
- \end{itemize}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Selbst geschriebene Funktion übergeben: \newterm{Callback}
-
- \bigskip
-
- \begin{lstlisting}[xleftmargin=1em]
- gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
- {
- /* Zeichenbefehle */
- ...
-
- return FALSE;
- }
-
- ...
-
- g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
- \end{lstlisting}
-
- \medskip
-
- \begin{itemize}
- \arrowitem
- GTK+ ruft immer dann, wenn es etwas zu zeichnen gibt,\\
- die Funktion \lstinline{draw} auf.
- \end{itemize}
-
- \pause
- \begin{picture}(0,0)(-0.07,0.2)
- \color{red}
- \put(5.3,4.8){\makebox(0,0)[bl]{\tikz{\draw[-latex](0,0)--(1.90,1.15);}}}
- \put(5.0,4.7){\makebox(0,0)[t]{\shortstack{\strut repräsentiert den\\
- \strut Bildschirm, auf den\\
- \strut gezeichnet werden soll}}}
- \pause
- \put(9.7,5.1){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-0.2,0.85);}}}
- \put(9.7,5.0){\makebox(0,0)[t]{\shortstack{\strut optionale Zusatzinformationen\\
- \strut für draw(), typischerweise\\
- \strut ein Zeiger auf ein struct}}}
- \put(10.0,3.5){\makebox(0,0)[tl]{\tikz{\draw[-latex](0,0)--(0.6,-1.25);}}}
- \end{picture}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Selbst geschriebene Funktion übergeben: \newterm{Callback}
-
- \bigskip
-
- \begin{lstlisting}[xleftmargin=1em]
- gboolean timer (GtkWidget *widget)
- {
- /* Rechenbefehle */
- ...
-
- gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
- }
-
- ...
-
- g_timeout_add (50, (GSourceFunc) timer, drawing_area);
- \end{lstlisting}
-
- \medskip
-
- \begin{itemize}
- \arrowitem
- GTK+ ruft nach 50 Millisekunden
- die Funktion \lstinline{timer} auf.
- \end{itemize}
-
- \pause
- \begin{picture}(0,0)(-0.07,0.2)
- \color{red}
- \put(9.7,6.7){\makebox(0,0)[t]{\shortstack{\strut Dieser Bereich soll\\
- \strut neu gezeichnet werden.}}}
- \put(9.7,5.7){\makebox(0,0)[tr]{\tikz{\draw[-latex](0,0)--(-0.6,-0.8);}}}
- \pause
- \put(4.3,3.2){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-0.7,0.6);}}}
- \put(4.3,3.1){\makebox(0,0)[t]{\shortstack{\strut In weiteren 50 Millisekunden soll\\
- \strut die Funktion erneut aufgerufen werden.}}}
- \pause
- \put(9.3,2.9){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-3.3,0.9);}}}
- \put(9.8,2.8){\makebox(0,0)[t]{\shortstack{\strut Explizite Typumwandlung\\
- \strut eines Zeigers (später)}}}
- \end{picture}
-
-\end{frame}
-
-\subsection{Projekt organisieren: make}
-
-\begin{frame}[fragile]
-
- \showsubsection
- \begin{itemize}
- \item
- \only<4->{explizite und implizite} Regeln
- \begin{onlyenv}<2>
- \smallskip
- \begin{lstlisting}[language=make,gobble=10]
- philosophy: philosophy.o answer.o
- gcc philosophy.o answer.o -o philosophy
-
- answer.o: answer.c answer.h
- gcc -Wall -O answer.c -c
-
- philosophy.o: philosophy.c answer.h
- gcc -Wall -O philosophy.c -c
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<4>
- \smallskip
- \begin{lstlisting}[language=make,gobble=10]
- TARGET = philosophy
- OBJECTS = philosophy.o answer.o
- HEADERS = answer.h
- CFLAGS = -Wall -O
-
- $(TARGET): $(OBJECTS)
- gcc $(OBJECTS) -o $(TARGET)
-
- %.o: %.c $(HEADERS)
- gcc $(CFLAGS) $< -c
-
- clean:
- rm -f $(OBJECTS) $(TARGET)
- \end{lstlisting}
- \end{onlyenv}
- \item
- Makros
- \begin{onlyenv}<3>
- \smallskip
- \begin{lstlisting}[language=make,gobble=10]
- TARGET = philosophy
- OBJECTS = philosophy.o answer.o
- HEADERS = answer.h
- CFLAGS = -Wall -O
-
- $(TARGET): $(OBJECTS)
- gcc $(OBJECTS) -o $(TARGET)
-
- answer.o: answer.c $(HEADERS)
- gcc $(CFLAGS) answer.c -c
-
- philosophy.o: philosophy.c $(HEADERS)
- gcc $(CFLAGS) philosophy.c -c
-
- clean:
- rm -f $(OBJECTS) $(TARGET)
- \end{lstlisting}
- \vspace*{-1cm}
- \end{onlyenv}
- \begin{onlyenv}<5->
- \smallskip
- \arrowitem
- 3 Sprachen: C, Präprozessor, make
- \end{onlyenv}
- \end{itemize}
-
-\end{frame}
-
-\section{Hardwarenahe Programmierung}
-\subsection{Bit-Operationen}
-\subsubsection{Zahlensysteme}
-
-\begin{frame}[fragile]
-
- \showsection
- \vspace*{-\smallskipamount}
- \showsubsection
- \vspace*{-\medskipamount}
- \showsubsubsection
-
- \begin{tabular}{rlrl}
- Basis & Name & Beispiel & Anwendung \\[\smallskipamount]
- 2 & Binärsystem & 1\,0000\,0011 & Bit-Operationen \\
- 8 & Oktalsystem & \lstinline,0403, & Dateizugriffsrechte (Unix) \\
- 10 & Dezimalsystem & \lstinline,259, & Alltag \\
- 16 & Hexadezimalsystem & \lstinline,0x103, & Bit-Operationen \\
- 256 & (keiner gebräuchlich) & 0.0.1.3 & IP-Adressen (IPv4)
- \end{tabular}
-
- \bigskip
-
- \begin{itemize}
- \item
- Computer rechnen im Binärsystem.
- \item
- Für viele Anwendungen (z.\,B.\ I/O-Ports, Grafik, \dots) ist es notwendig,\\
- Bits in Zahlen einzeln ansprechen zu können.
- \end{itemize}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsubsection
-
- \begin{tabular}{rlrlrc}
- \qquad 000 & \bf 0 \hspace*{1.5cm} & 0000 & \bf 0 & \quad 1000 & \bf 8\\
- 001 & \bf 1 & 0001 & \bf 1 & 1001 & \bf 9\\
- 010 & \bf 2 & 0010 & \bf 2 & 1010 & \bf A\\
- 011 & \bf 3 & 0011 & \bf 3 & 1011 & \bf B\\[\smallskipamount]
- 100 & \bf 4 & 0100 & \bf 4 & 1100 & \bf C\\
- 101 & \bf 5 & 0101 & \bf 5 & 1101 & \bf D\\
- 110 & \bf 6 & 0110 & \bf 6 & 1110 & \bf E\\
- 111 & \bf 7 & 0111 & \bf 7 & 1111 & \bf F\\
- \end{tabular}
-
- \medskip
-
- \begin{itemize}
- \item
- Oktal- und Hexadezimalzahlen lassen sich ziffernweise\\
- in Binär-Zahlen umrechnen.
- \item
- Hexadezimalzahlen sind eine Kurzschreibweise für Binärzahlen,\\
- gruppiert zu jeweils 4 Bits.
- \item
- Oktalzahlen sind eine Kurzschreibweise für Binärzahlen,\\
- gruppiert zu jeweils 3 Bits.
- \item
- Trotz Taschenrechner u.\,ä.\ lohnt es sich,\\
- die o.\,a.\ Umrechnungstabelle \textbf{auswendig} zu kennen.
- \end{itemize}
-
-\end{frame}
-
-\subsubsection{Bit-Operationen in C}
-
-\begin{frame}[fragile]
-
- \showsubsubsection
-
- \begin{tabular}{lll}
- C-Operator & Verknüpfung & Anwendung \\[\smallskipamount]
- \lstinline,&, & Und & Bits gezielt löschen \\
- \lstinline,|, & Oder & Bits gezielt setzen \\
- \lstinline,^, & Exklusiv-Oder & Bits gezielt invertieren \\
- \lstinline,~, & Nicht & Alle Bits invertieren \\[\smallskipamount]
- \lstinline,<<, & Verschiebung nach links & Maske generieren \\
- \lstinline,>>, & Verschiebung nach rechts & Bits isolieren
- \end{tabular}
-
- \bigskip
-
- Numerierung der Bits: von rechts ab 0
-
- \medskip
-
- \begin{tabular}{ll}
- Bit Nr.\ 3 auf 1 setzen: &
- \lstinline,a |= 1 << 3;, \\
- Bit Nr.\ 4 auf 0 setzen: &
- \lstinline,a &= ~(1 << 4);, \\
- Bit Nr.\ 0 invertieren: &
- \lstinline,a ^= 1 << 0;,
- \end{tabular}
-
- \smallskip
-
- ~~Abfrage, ob Bit Nr.\ 1 gesetzt ist:\quad
- \lstinline{if (a & (1 << 1))}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsubsection
-
- C-Datentypen für Bit-Operationen:
- \smallskip\par
- \lstinline{#include <stdint.h>}
- \medskip\par
- \begin{tabular}{lllll}
- & 8 Bit & 16 Bit & 32 Bit & 64 Bit \\
- mit Vorzeichen & \lstinline,int8_t,
- & \lstinline,int16_t,
- & \lstinline,int32_t,
- & \lstinline,int64_t, \\
- ohne Vorzeichen & \lstinline,uint8_t,
- & \lstinline,uint16_t,
- & \lstinline,uint32_t,
- & \lstinline,uint64_t,
- \end{tabular}
-
- \bigskip
- \bigskip
-
- Ausgabe:
- \smallskip\par
- \begin{lstlisting}
- #include <stdio.h>
- #include <stdint.h>
- #include <inttypes.h>
- ...
- uint64_t x = 42;
- printf ("Die Antwort lautet: %" PRIu64 "\n", x);
- \end{lstlisting}
-
-\iffalse
-
- \bigskip
-
- Aufgabe: Schreiben Sie C-Funktionen, die ein "`Array von Bits"' realisieren, z.\,B.
-
- \smallskip
-
- \begin{tabular}[t]{ll}
- \lstinline|void set_bit (int i);| & Bei Index $i$ auf 1 setzen \\
- \lstinline|void clear_bit (int i);| & Bei Index $i$ auf 0 setzen \\
- \lstinline|int get_bit (int i);| & Bei Index $i$ lesen
- \end{tabular}
-
- \medskip
-
- Hinweise:
- \begin{itemize}
- \item
- Die Größe des Bit-"`Arrays"' (z.\,B.\ 1000) dürfen Sie als \emph{vorher bekannt\/} voraussetzen.
- \item
- Sie benötigen ein Array, z.\,B.\ von \lstinline|char|- oder \lstinline|int|-Variablen.
- \item
- Sie benötigen eine Division (\lstinline|/|) sowie den Divisionsrest (Modulo: \lstinline|%|).
- \end{itemize}
-
-\fi
-
-\end{frame}
-
-\subsection{I/O-Ports}
-
-\begin{frame}[fragile]
-
-% \showsection
- \showsubsection
- \vspace*{-1.5\medskipamount}
- {\large\textbf{\color{structure}4.3\quad Interrupts}}
-
- \bigskip
-
- Kommunikation mit externen Geräten
-
- \bigskip
-
- \begin{center}
- \includegraphics{io-ports-and-interrupts.pdf}
- \end{center}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- In Output-Port schreiben = Aktoren ansteuern
-
- Beispiel: LED
-
- \medskip
-
- \begin{lstlisting}
- #include <avr/io.h>
- ...
- DDRC = 0x70;
- PORTC = 0x40;
- \end{lstlisting}
- \begin{picture}(0,0)
- \put(3,0.67){\begin{minipage}{3cm}
- \color{red}%
- binär: 0111\,0000\\
- binär: 0100\,0000
- \end{minipage}}
- \put(10,0.67){\makebox(0,0)[r]{\color{red}Herstellerspezifisch!}}
- \end{picture}
-
- \bigskip
-
- \lstinline{DDR} = Data Direction Register\\
- Bit = 1 für Output-Port\\
- Bit = 0 für Input-Port
-
- \bigskip
-
- \emph{Details: siehe Datenblatt und Schaltplan}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Aus Input-Port lesen = Sensoren abfragen
-
- Beispiel: Taster
-
- \medskip
-
- \begin{lstlisting}
- #include <avr/io.h>
- ...
- DDRC = 0xfd;
- while ((PINC & 0x02) == 0)
- ; /* just wait */
- \end{lstlisting}
- \begin{picture}(0,0)(-1.5,-0.42)
- \put(3,0.67){\begin{minipage}{3cm}
- \color{red}%
- binär: 1111\,1101\\
- binär: 0000\,0010
- \end{minipage}}
- \put(10,0.67){\makebox(0,0)[r]{\color{red}Herstellerspezifisch!}}
- \end{picture}
-
- \bigskip
-
- \lstinline{DDR} = Data Direction Register\\
- Bit = 1 für Output-Port\\
- Bit = 0 für Input-Port
-
- \bigskip
-
- \emph{Details: siehe Datenblatt und Schaltplan}
-
- \bigskip
-
- Praktikumsaufgabe: Druckknopfampel
-
-\end{frame}
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \begin{itemize}
- \item[3.1] Der Präprozessor
- \item[3.2] Bibliotheken einbinden
- \color{medgreen}
- \item[3.3] Bibliotheken verwenden
- \item[3.4] Projekt organisieren: make
- \end{itemize}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \begin{itemize}
- \color{medgreen}
- \item[4.1] Bit-Operationen
- \item[4.2] I/O-Ports
- \color{red}
- \item[4.3] Interrupts
- \vspace*{-0.1cm}
- \item[\dots]
- \end{itemize}
- \item[\textbf{5}] \textbf{Algorithmen}
- \item[\textbf{\dots}]
- \end{itemize}
-
-\end{frame}
-
-\end{document}
diff --git a/20221031/hp-2022ws-p2.pdf b/20221031/hp-2022ws-p2.pdf
deleted file mode 100644
index 8cc34b0e76299d099b6a7be2669935f56fba17c7..0000000000000000000000000000000000000000
Binary files a/20221031/hp-2022ws-p2.pdf and /dev/null differ
diff --git a/20221031/hp-2022ws-p2.tex b/20221031/hp-2022ws-p2.tex
deleted file mode 100644
index dd2e4f0d238f0e796a3c992eb5e06703b36780de..0000000000000000000000000000000000000000
--- a/20221031/hp-2022ws-p2.tex
+++ /dev/null
@@ -1,180 +0,0 @@
-% hp-2022ws-p2.pdf - Labor Notes on Low-Level Programming
-% Copyright (C) 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Versuch 2: Druckknopfampel
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-\usepackage{multicol}
-\usepackage{amsmath}
-\usepackage{sfmath}
-
-\sloppy
-\raggedcolumns
-\pagestyle{empty}
-\addtolength{\textheight}{1cm}
-\newcommand{\sep}{~$\cdot$~}
-\newcommand{\mylicense}{CC-by-sa (Version 3.0) oder GNU GPL (Version 3 oder höher)}
-
-\begin{document}
-
- \makebox(0,0.005)[tl]{\includegraphics[scale=0.72]{logo-hochschule-bochum-cvh-text-v2.pdf}}\hfill
- \makebox(0,0)[tr]{\includegraphics[scale=0.5]{logo-hochschule-bochum.pdf}}
- \par\bigskip\bigskip
- \begin{center}
- \Large\textbf{Praktikumsversuch 2: Druckknopfampel}
- \par\medskip
- \normalsize Hardwarenahe Programmierung\sep
- Wintersemester 2022/23\sep
- Prof.~Dr.~Peter Gerwinski
- \end{center}
-
- Aufgabe: Programmieren Sie einen Mikrocontroller so,
- daß er eine Druckknopfampel steuern kann.
-
- \begin{multicols}{2}
-
- \begin{itemize}
- \item
- Normalerweise zeigt eine Druckknopfampel rotes Licht für die
- Fußgänger und grünes Licht für die Straße.
- \item
- Nach Knopfdruck wechselt die Straße über Gelb nach Rot.
- Danach bekommen die Fußgänger Grün.
- Nach einer gewissen Zeit bekommen die Fußgänger wieder Rot,
- und die Straße wechselt über Rot-Gelb wieder zu Grün.
-
- \medskip
- \item
- Als Mikrocontroller-Entwicklungsplattform stellen wir Ihnen
- einen \emph{Arduino Uno\/} zur Verfügung.
- \item
- Software-Entwiklung für den Arduino geschieht üblicherweise
- mit Hilfe der Entwicklungswerkzeuge \emph{GCC, binutils und
- glibc für AVR} sowie \emph{avrdude\/} für das Herunterladen
- des geschriebenen Programms vom PC auf den Mikrocontroller.
-
- Die Arduino-Entwicklungsumgebung (siehe z.\,B.\
- \url{https://www.arduino.cc/en/Main/Software}) integriert
- alle diese Komponenten.
- \item
- Wir schreiben unser Programm in C und nicht in der INO-Sprache.
- Wenn die Quelltext-Dateien in der Arduino-Entwicklungsumgebung
- die Endung \file{.ino} haben, ist das kein Problem,
- sofern der Inhalt der Datei in C geschrieben ist.
- \item
- Den Schaltplan des Arduino Uno sowie das Datenblatt des
- ATmega328p finden Sie per Web-Recherche.
-
- \columnbreak
-
- \item
- Sie können Ihr Programm direkt aus der Arduino-Entwicklungsumgebung heraus
- compilieren und auf den Mikrocontroller herunterladen.
- Wenn Sie dies von der Kommandozeile aus machen möchten,
- geht dies folgendermaßen:
-
- \lstinline[style=cmd]{avr-gcc -Wall -Os -mmcu=atmega328p \}\\
- \lstinline[style=cmd]{dateiname.c -o dateiname.elf}
-
- \lstinline[style=cmd]{avr-objcopy -O ihex \}\\
- \lstinline[style=cmd]{dateiname-4.elf dateiname-4.hex}
-
- \lstinline[style=cmd]{avrdude -P /dev/ttyACM0 -c arduino \}\\
- \lstinline[style=cmd]{-p m328p -U flash:w:dateiname.hex}
-
- Notfalls: \lstinline[style=cmd]{sudo chmod 666 /dev/ttyACM0}
-
- \medskip
- \item
- Die Verdrahtung erfolgt auf Steckplatinen -- siehe
- Abb.~\ref{Steckplatine}.
- Die mit roten und blauen Streifen markierten Lochreihen sind
- in Längsrichtung elektrisch verbunden, alle anderen in
- Querrichtung mit einer Trennung in der Mitte. Üblicherweise
- verwendet man die Längsrichtung für die Stromversorgung: Rot
- = Versorgungsspannung, Blau = 0\,V.
- \item
- LEDs sind keine Glühlampen! Sie haben einen Pluspol (länger)
- und einen Minuspol (kürzer, Gehäuse abgeflacht), und sie dürfen
- \textbf{nur mit Vorwiderstand} betrieben werden,
- andernfalls besteht die Gefahr einer Zerstörung der LED
- und/oder des Arduino.
- \item
- Anstelle eines Drucktasters verwenden wir ein Stück Draht.
- \item
- Bevor Sie Ihre Schaltung unter Strom setzen, lassen Sie
- diese \textbf{durch einen Betreuer prüfen}.
- \end{itemize}
-
- \vspace*{-\medskipamount}
-
- \strut\hfill\emph{Viel Erfolg!}\\[-3.5cm]
-
- \end{multicols}
-
- \vspace*{-1.5\bigskipamount}
-
- \begin{figure}[h]
- \begin{minipage}{7.3cm}
- \includegraphics[width=8cm]{400_points_breadboard.jpg}
- \vspace*{-1cm}
- \caption{Steckplatine\label{Steckplatine}}
- \vspace*{1cm}
- \end{minipage}%
- \begin{minipage}{9cm}
- \small\raggedright
- \vspace*{1cm}
- Bildquelle:
- \href{https://commons.wikimedia.org/wiki/File:400_points_breadboard.jpg}%
- {\nolinkurl{https://commons.wikimedia.org/}\\
- \nolinkurl{wiki/File:400_points_breadboard.jpg}}\\
- Autor: \url{https://www.flickr.com/people/33504192@N00}\\
- Lizenz: CC-BY-SA 2.0 Generic
- \end{minipage}
- \end{figure}
-
- \vspace*{-1.5\bigskipamount}
-
- \vfill
-
- \begingroup
-
- \small
-
- \setlength{\leftskip}{3cm}
-
- Stand: 31.\ Oktober 2022
-
-% Soweit nicht anders angegeben:\\
- Copyright \copyright\ 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022\quad Peter Gerwinski\\
- Lizenz: \mylicense
-
- Sie können diese Praktikumsunterlagen einschließlich \LaTeX-Quelltext
-% und Beispielprogramme\\
- herunterladen unter:\\
- \url{https://gitlab.cvh-server.de/pgerwinski/hp}
-
- \endgroup
-
-\end{document}
diff --git a/20221031/hp-musterloesung-20221031.pdf b/20221031/hp-musterloesung-20221031.pdf
deleted file mode 100644
index a10e2c9e2717e7e4f4799aadff5c4517c2b442a7..0000000000000000000000000000000000000000
Binary files a/20221031/hp-musterloesung-20221031.pdf and /dev/null differ
diff --git a/20221031/hp-musterloesung-20221031.tex b/20221031/hp-musterloesung-20221031.tex
deleted file mode 100644
index 124e067b33be400f158d0293e3b8255d0c291532..0000000000000000000000000000000000000000
--- a/20221031/hp-musterloesung-20221031.tex
+++ /dev/null
@@ -1,554 +0,0 @@
-% hp-musterloesung-20221031.pdf - Solutions to the Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Zahlensysteme, Mikrocontroller, Einfügen in Strings
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\begin{document}
-
- \section*{Hardwarenahe Programmierung\\
- Musterlösung zu den Übungsaufgaben -- 31.\ Oktober 2022}
-
- \exercise{Zahlensysteme}
-
- Wandeln Sie ohne Hilfsmittel
-
- \begin{minipage}[t]{0.3\textwidth}
- \begin{itemize}
- \item
- nach Dezimal:
- \begin{itemize}
- \item[(a)]
- 0010\,0000$_2$
- \item[(b)]
- 42$_{16}$
- \item[(c)]
- 17$_8$
- \end{itemize}
- \end{itemize}
- \end{minipage}\hfill
- \begin{minipage}[t]{0.3\textwidth}
- \begin{itemize}
- \item
- nach Hexadezimal:
- \begin{itemize}
- \item[(d)]
- 0010\,0000$_2$
- \item[(e)]
- 42$_{10}$
- \item[(f)]
- 192.168.20.254$_{256}$
- \end{itemize}
- \end{itemize}
- \end{minipage}\hfill
- \begin{minipage}[t]{0.3\textwidth}
- \begin{itemize}
- \item
- nach Binär:
- \begin{itemize}
- \item[(g)]
- 750$_8$
- \item[(h)]
- 42$_{10}$
- \item[(i)]
- AFFE$_{16}$
- \end{itemize}
- \end{itemize}
- \end{minipage}
-
- \medskip
-
- Berechnen Sie ohne Hilfsmittel:
- \begin{itemize}
- \item[(j)]
- 750$_8$ \& 666$_8$
- \item[(k)]
- A380$_{16}$ + B747$_{16}$
- \item[(l)]
- AFFE$_{16} >> 1$
- \end{itemize}
-
- Die tiefgestellte Zahl steht für die Basis des Zahlensystems.
- Jede Teilaufgabe zählt 1 Punkt. \addtocounter{points}{12}
-
- (In der Klausur sind Hilfsmittel zugelassen,
- daher ist dies \emph{keine\/} typische Klausuraufgabe.)
-
- \solution
-
- Wandeln Sie ohne Hilfsmittel
-
- \begin{itemize}
- \item
- nach Dezimal:
- \begin{itemize}
- \item[(a)]
- $0010\,0000_2 = 32_{10}$
-
- Eine Eins mit fünf Nullen dahinter steht binär für $2^5 = 32$:\\
- mit $1$ anfangen und fünfmal verdoppeln.
- \item[(b)]
- $42_{16} = 4 \cdot 16 + 2 \cdot 1 = 64 + 2 = 66$
- \item[(c)]
- $17_8 = 1 \cdot 8 + 7 \cdot 1 = 8 + 7 = 15$
- \end{itemize}
- Umwandlung von und nach Dezimal ist immer rechenaufwendig.
- Umwandlungen zwischen Binär, Oktal und Hexadezimal gehen ziffernweise
- und sind daher wesentlich einfacher.
- \item
- nach Hexadezimal:
- \begin{itemize}
- \item[(d)]
- $0010\,0000_2 = 20_{16}$
-
- Umwandlung von Binär nach Hexadezimal geht ziffernweise:\\
- Vier Binärziffern werden zu einer Hex-Ziffer.
- \item[(e)]
- $\rm 42_{10} = 32_{10} + 10_{10} = 20_{16} + A_{16} = 2A_{16}$
- \item[(f)]
- $\rm 192.168.20.254_{256} = C0\,A8\,14\,FE_{16}$
-
- Umwandlung von der Basis 256 nach Hexadezimal geht ziffernweise:\\
- Eine 256er-Ziffer wird zu zwei Hex-Ziffern.
-
- Da die 256er-Ziffern dezimal angegeben sind,
- müssen wir viermal Dezimal nach Hexadezimal umwandeln.
- Hierfür bieten sich unterschiedliche Wege an.
-
- $\rm 192_{10} = 128_{10} + 64_{10} = 1100\,0000_{2} = C0_{16}$
-
- $\rm 168_{10} = 10_{10} \cdot 16_{10} + 8_{10} = A_{16} \cdot 10_{16} + 8_{16} = A8_{16}$
-
- $20_{10} = 16_{10} + 4_{10} = 10_{16} + 4_{16} = 14$
-
- $\rm 254_{10} = 255_{10} - 1_{10} = FF_{16} - 1_{16} = FE_{16}$
- \end{itemize}
- \item
- nach Binär:
- \begin{itemize}
- \item[(g)]
- $750_8 = 111\,101\,000_2$
-
- Umwandlung von Oktal nach Binär geht ziffernweise:\\
- Eine Oktalziffer wird zu drei Binärziffern.
- \item[(h)]
- $\rm 42_{10} = 2A_{16}$ (siehe oben) $= 0010\,1010_{16}$
-
- Umwandlung von Hexadezimal nach Binär geht ziffernweise:\\
- Eine Hex-Ziffer wird zu vier Binärziffern.
- \item[(i)]
- $\rm AFFE_{16} = 1010\,1111\,1111\,1110_2$
-
- Umwandlung von Hexadezimal nach Binär geht ziffernweise:\\
- Eine Hex-Ziffer wird zu vier Binärziffern.
- \end{itemize}
- \end{itemize}
-
- \medskip
-
- Berechnen Sie ohne Hilfsmittel:
- \begin{itemize}
- \item[(j)]
- $750_8\,\&\,666_8
- = 111\,101\,000_2\,\&\,110\,110\,110_2
- = 110\,100\,000_2
- = 640_8$
-
- Binäre Und-Operationen lassen sich am leichtesten
- in binärer Schreibweise durchführen.
- Umwandlung zwischen Oktal und Binär geht ziffernweise:
- Eine Oktalziffer wird zu drei Binärziffern und umgekehrt.
-
- Mit etwas Übung funktionieren diese Operationen
- auch direkt mit Oktalzahlen im Kopf.
-
- \item[(k)]
- $\rm\phantom{+}A380_{16}$\\
- $\rm+\kern2ptB747_{16}$\\[-\medskipamount]
- \rule{1.4cm}{0.5pt}\\
- $\rm 15AC7_{16}$
- \begin{picture}(0,0)
- \put(-1.4,0.35){\mbox{\scriptsize\bf 1}}
- \end{picture}
-
- Mit Hexadezimalzahlen (und Binär- und Oktal- und sonstigen Zahlen)
- kann man genau wie mit Dezimalzahlen schriftlich rechnen.
- Man muß nur daran denken, daß der "`Zehner"'-Überlauf nicht bei
- $10_{10}$ stattfindet, sondern erst bei $10_{16} = 16_{10}$
- (hier: $\rm 8_{16} + 4_{16} = C_{16}$ und
- $\rm 3_{16} + 7_{16} = A_{16}$, aber
- $\rm A_{16} + B_{16} = 10_{10} + 11_{10}
- = 21_{10} = 16_{10} + 5_{10} = 10_{16} + 5_{16} = 15_{16}$).
-
- \item[(l)]
- $\rm AFFE_{16} >> 1
- = 1010\,1111\,1111\,1110_2 >> 1
- = 0101\,0111\,1111\,1111_2
- = 57FF_{16}$
-
- Bit-Verschiebungen lassen sich am leichtesten
- in binärer Schreibweise durchführen.
- Umwandlung zwischen Hexadezimal und Binär geht ziffernweise:
- Eine Hex-Ziffer wird zu vier Binärziffern und umgekehrt.
-
- Mit etwas Übung funktionieren diese Operationen
- auch direkt mit Hexadezimalzahlen im Kopf.
-
- \end{itemize}
-
- \exercise{Mikrocontroller}
-
- \begin{minipage}[t]{10cm}
- An die vier Ports eines ATmega16-Mikrocontrollers sind Leuchtdioden angeschlossen:
- \begin{itemize}
- \item
- von links nach rechts an die Ports A, B, C und D,
- \item
- von oben nach unten an die Bits Nr.\ 0 bis 7.
- \end{itemize}
-
- Wir betrachten das folgende Programm (\gitfile{hp}{2022ws/20221031}{aufgabe-2.c}):
-
- \begin{lstlisting}[gobble=6]
- #include <avr/io.h>
-
- int main (void)
- {
- DDRA = 0xff;
- DDRB = 0xff;
- DDRC = 0xff;
- DDRD = 0xff;
- PORTA = 0x1f;
- PORTB = 0x10;
- PORTD = 0x10;
- PORTC = 0xfc;
- while (1);
- return 0;
- }
- \end{lstlisting}
- \end{minipage}\hfill
- \begin{minipage}[t]{3cm}
- \strut\\[-\baselineskip]
- \includegraphics[width=3cm]{leds.jpg}
- \end{minipage}
-
- \vspace*{-3cm}
-
- \strut\hfill
- \begin{minipage}{11.8cm}
- \begin{itemize}
- \item[(a)]
- Was bewirkt dieses Programm? \points{4}
- \item[(b)]
- Wozu dienen die ersten vier Zeilen des Hauptprogramms? \points{2}
- \item[(c)]
- Was würde stattdessen die Zeile \lstinline{DDRA, DDRB, DDRC, DDRD = 0xff;} bewirken?
- \points{2}
- \item[(d)]
- Schreiben Sie das Programm so um,
- daß die durch das Programm dargestellte Figur spiegelverkehrt erscheint. \points{3}
- \item[(e)]
- Wozu dient das \lstinline{while (1)}? \points{2}
- \item
- Alle Antworten bitte mit Begründung.
- \end{itemize}
- \end{minipage}
-
- \solution
-
- \begin{itemize}
- \item[(a)]
- \textbf{Was bewirkt dieses Programm?}
-
- \newcommand{\x}{$\bullet$}
- \renewcommand{\o}{$\circ$}
-
- \begin{minipage}[t]{0.75\textwidth}\parskip\smallskipamount
- Es läßt die LEDs in dem rechts abgebildeten Muster aufleuchten,\\
- das z.\,B.\ als die Ziffer 4 gelesen werden kann.
-
- (Das Zeichen \x\ steht für eine leuchtende, \o\ für eine nicht leuchtende LED.)
-
- Die erste Spalte (Port A) von unten nach oben gelesen (Bit 7 bis 0)\\
- entspricht der Binärdarstellung von \lstinline{0x1f}: 0001\,1111.
-
- Die dritte Spalte (Port C) von unten nach oben gelesen (Bit 7 bis 0)\\
- entspricht der Binärdarstellung von \lstinline{0xfc}: 1111\,1100.
-
- Die zweite und vierte Spalte (Port B und D) von unten nach oben gelesen\\
- (Bit 7 bis 0) entsprechen der Binärdarstellung von \lstinline{0x10}: 0001\,0000.
-
- Achtung: Die Zuweisung der Werte an die Ports erfolgt im Programm\\
- \emph{nicht\/} in der Reihenfolge A B C D, sondern in der Reihenfolge A B D C.
- \end{minipage}\hfill
- \begin{minipage}[t]{0.15\textwidth}
- \vspace*{-0.5cm}%
- \begin{tabular}{cccc}
- \x & \o & \o & \o \\
- \x & \o & \o & \o \\
- \x & \o & \x & \o \\
- \x & \o & \x & \o \\
- \x & \x & \x & \x \\
- \o & \o & \x & \o \\
- \o & \o & \x & \o \\
- \o & \o & \x & \o \\
- \end{tabular}
- \end{minipage}
-
- \item[(b)]
- \textbf{Wozu dienen die ersten vier Zeilen des Hauptprogramms?}
-
- Mit diesen Zeilen werden alle jeweils 8 Bits aller 4 Ports
- als Output-Ports konfiguriert.
-
- \item[(c)]
- \textbf{Was würde stattdessen die Zeile \lstinline{DDRA, DDRB, DDRC, DDRD = 0xff;} bewirken?}
-
- Der Komma-Operator in C bewirkt, daß der erste Wert berechnet
- und wieder verworfen wird und stattdessen der zweite Wert weiterverarbeitet wird.
- Konkret hier hätte das zur Folge,
- daß \lstinline{DDRA}, \lstinline{DDRB} und \lstinline{DDRC}
- gelesen und die gelesenen Werte ignoriert werden;
- anschließend wird \lstinline{DDRD} der Wert \lstinline{0xff} zugewiesen.
- Damit würde also nur einer von vier Ports überhaupt konfiguriert.
-
- Da es sich bei den \lstinline{DDR}-Variablen
- um \lstinline{volatile}-Variable handelt,
- nimmt der Compiler an, daß der Lesezugriff schon irgendeinen Sinn hätte.
- Der Fehler bliebe also unbemerkt.
-
- \item[(d)]
- \textbf{Schreiben Sie das Programm so um,
- daß die durch das Programm dargestellte Figur spiegelverkehrt erscheint.}
-
- Hierzu vertauschen wir die Zuweisungen
- an \lstinline{PORTA} und \lstinline{PORTD}
- sowie die Zuweisungen
- an \lstinline{PORTB} und \lstinline{PORTC}:
-
- \begin{lstlisting}[gobble=8]
- PORTD = 0x1f;
- PORTC = 0x10;
- PORTA = 0x10;
- PORTB = 0xfc;
- \end{lstlisting}
-
- Damit ergibt sich eine Spiegelung an der vertikalen Achse.
-
- Alternativ kann man auch an der horizontalen Achse spiegeln.
- Dafür muß man die Bits in den Hexadezimalzahlen umdrehen:
-
- \begin{lstlisting}[gobble=8]
- PORTA = 0xf8;
- PORTB = 0x08;
- PORTD = 0x08;
- PORTC = 0x3f;
- \end{lstlisting}
-
- Die Frage, welche der beiden Spiegelungen gewünscht ist,
- wäre übrigens \emph{auch in der Klausur zulässig}.
-
- \item[(e)]
- \textbf{Wozu dient das \lstinline{while (1)}?}
-
- Mit dem \lstinline{return}-Befehl am Ende des Hauptprogramms
- gibt das Programm die Kontrolle an das Betriebssystem zurück.
-
- Dieses Programm jedoch läuft auf einem Mikrocontroller,
- auf dem es kein Betriebssystem gibt.
- Wenn das \lstinline{return} ausgeführt würde,
- hätte es ein undefiniertes Verhalten zur Folge.
-
- Um dies zu verhindern, endet das Programm in einer Endlosschleife,
- mit der wir den Mikrocontroller anweisen,
- nach der Ausführung des Programms \emph{nichts mehr\/} zu tun
- (im Gegensatz zu: \emph{irgendetwas Undefiniertes\/} zu tun).
-
- \end{itemize}
-
- \exercise{Einfügen in Strings}
-
- Wir betrachten das folgende Programm (\gitfile{hp}{2022ws/20221031}{aufgabe-2.c}):
-% \begin{lstlisting}[style=numbered]
- \begin{lstlisting}
- #include <stdio.h>
- #include <string.h>
-
- void insert_into_string (char src, char *target, int pos)
- {
- int len = strlen (target);
- for (int i = pos; i < len; i++)
- target[i+1] = target[i];
- target[pos] = src;
- }
-
- int main (void)
- {
- char test[100] = "Hochshule Bochum";
- insert_into_string ('c', test, 5);
- printf ("%s\n", test);
- return 0;
- }
- \end{lstlisting}
- Die Ausgabe des Programms lautet:
- \lstinline[style=terminal]{Hochschhhhhhhhhhh}
-
- \begin{enumerate}[\quad(a)]
- \item
- Erklären Sie, wie die Ausgabe zustandekommt.
- \points{3}
-% \workspace{12}
- \item
- Schreiben Sie die Funktion \lstinline|insert_into_string()| so um,
- daß sie den Buchstaben \lstinline{src} an der Stelle \lstinline{pos}
- in den String \lstinline{target} einfügt.\par
- Die Ausgabe des Programms müßte dann
- \lstinline[style=terminal]{Hochschule Bochum} lauten.
- \points{2}
-% \workspace{13}
- \item
- Was kann passieren, wenn Sie die Zeile
- \lstinline{char test[100] = "Hochshule Bochum";}\\
- durch
- \lstinline{char test[] = "Hochshule Bochum";} ersetzen?
- Begründen Sie Ihre Antwort.
- \points{2}
-% \workspace{10}
- \item
- Was kann passieren, wenn Sie die Zeile
- \lstinline{char test[100] = "Hochshule Bochum";}\\
- durch
- \lstinline{char *test = "Hochshule Bochum";} ersetzen?
- Begründen Sie Ihre Antwort.
- \points{2}
-% \workspace{10}
-% \item
-% Schreiben Sie eine Funktion
-% \lstinline{void insert_into_string_sorted (char src, char *target)},
-% die voraussetzt, daß der String \lstinline{target} alphabetisch sortiert ist
-% und den Buchstaben \lstinline{src} an der alphabetisch richtigen Stelle
-% einfügt. Diese Funktion darf die bereits vorhandene Funktion
-% \lstinline|insert_into_string()| aufrufen.\\
-% \points{4}\par
-% Zum Testen eignen sich die folgenden Zeilen im Hauptprogramm:
-% \begin{lstlisting}[gobble=8]
-% char test[100] = "";
-% insert_into_string_sorted ('c', test);
-% insert_into_string_sorted ('a', test);
-% insert_into_string_sorted ('d', test);
-% insert_into_string_sorted ('b', test);
-% \end{lstlisting}
-% Danach sollte \lstinline{test[]} die Zeichenfolge \lstinline{"abcd"} enthalten.
-% \workspace{14}
-% \item
-% Wie schnell (Landau-Symbol in Abhängigkeit von der Länge $n$ des Strings)
-% arbeitet Ihre Funktion
-% \lstinline{void insert_into_string_sorted (char src, char *target)}
-% und warum?
-% \points{1}
-% \workspace{10}
-% \item
-% Beschreiben Sie -- in Worten oder als C-Quelltext --, wie man die Funktion\\
-% \lstinline{void insert_into_string_sorted (char src, char *target)}
-% so gestalten kann,\\
-% daß sie in $\mathcal{O}(\log n)$ arbeitet.
-% \points{3}
-% \workspace{35}
- \end{enumerate}
-
- \solution
-
- \begin{enumerate}[\quad(a)]
- \item
- \textbf{Erklären Sie, wie die Ausgabe zustandekommt.}
-
- In der Schleife wird \emph{zuerst\/} der nächste Buchstabe \lstinline{target[i + 1]}
- gleich dem aktuellen gesetzt
- und \emph{danach\/} der Zähler \lstinline{i} erhöht.
- Dadurch wird im nächsten Schleifendurchlauf der bereits verschobene Buchstabe
- noch weiter geschoben und letztlich alle Buchstaben in \lstinline{target[]}
- durch den an der Stelle \lstinline{pos} ersetzt.
-
- \item
- \textbf{Schreiben Sie die Funktion \lstinline|insert_into_string()| so um,
- daß sie den Buchstben \lstinline{src} an der Stelle \lstinline{pos}
- in den String \lstinline{target} einfügt.}\par
- \textbf{Die Ausgabe des Programms müßte dann
- \lstinline[style=terminal]{Hochschule Bochum} lauten.}
-
- Um im String "`Platz zu schaffen"', muß man von hinten beginnen,
- also die Schleife umdrehen\\
- (siehe: \gitfile{hp}{2022ws/20221031}{loesung-3.c}):
- \begin{lstlisting}{gobble=8}
- for (int i = len; i >= pos; i--)
- target[i + 1] = target[i];
- \end{lstlisting}
-
- \item
- \textbf{Was kann passieren, wenn Sie die Zeile
- \lstinline{char test[100] = "Hochshule Bochum";}\\
- durch
- \lstinline{char test[] = "Hochshule Bochum";}
- ersetzen und warum?}
-
- Die Schreibweise \lstinline{test[]} bedeutet,
- daß der Compiler selbst zählt, wieviel Speicherplatz der String benötigt,
- un dann genau die richtige Menge Speicher reserviert
- (anstatt, wie wir es manuell getan haben, pauschal Platz für 100 Zeichen).
-
- Wenn wir nun in den String ein zusätzliches Zeichen einfügen,
- ist dafür kein Speicherplatz reserviert worden,
- und wir \textbf{überschreiben} dann Speicher, an dem sich andere Variable befinden,
- was zu einem \textbf{Absturz} führen kann.
-
- Da wir hier nur ein einziges Zeichen schreiben,
- wird dieser Fehler nicht sofort auffallen.
- Dies ist schlimmer, als wenn das Programm direkt beim ersten Test abstürzt,
- denn dadurch entsteht bei uns der Eindruck, es sei in Ordnung.
- Wenn danach der Fehler in einer Produktivumgebung auftritt,
- kann dadurch Schaden entstehen -- je nach Einsatzgebiet der Software
- u.\,U.\ erheblicher Vermögens-, Sach- und/oder Personenschaden
- (z.\,B.\ Absturz eines Raumflugkörpers).
-
- \item
- \textbf{Was kann passieren, wenn Sie
- \lstinline{char test[100] = "Hochshule Bochum";}\\
- durch
- \lstinline{char *test = "Hochshule Bochum";}
- ersetzen und warum?}
-
- In diesem Fall wird der Speicher für den eigentlichen String
- in einem unbenannten, \textbf{nicht schreibbaren} Teil des Speichers reserviert.
- Unser Versuch, dorthin ein zusätzliches Zeichen zu schreiben,
- fürt dann normalerweise zu einem \textbf{Absturz}.
-
- In manchen Systemen (Betriebssystem, Compiler, \dots)
- ist der Speicherbereich tatsächlich sehr wohl schreibbar.
- In diesem Fall tritt der Absturz nicht immer und nicht immer sofort auf --
- genau wie in Aufgabenteil (c).
-
- \end{enumerate}
-
-\end{document}
diff --git a/20221031/hp-uebung-20221031.pdf b/20221031/hp-uebung-20221031.pdf
deleted file mode 100644
index 07b200cd72ae7406dcb15eb2b94b0aec6e2675ff..0000000000000000000000000000000000000000
Binary files a/20221031/hp-uebung-20221031.pdf and /dev/null differ
diff --git a/20221031/hp-uebung-20221031.tex b/20221031/hp-uebung-20221031.tex
deleted file mode 100644
index c8039a92a5de856a8ba95ca5380f2cd7e2babd45..0000000000000000000000000000000000000000
--- a/20221031/hp-uebung-20221031.tex
+++ /dev/null
@@ -1,262 +0,0 @@
-% hp-uebung-20221031.pdf - Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Zahlensysteme, Mikrocontroller, Einfügen in Strings
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\begin{document}
-
- \thispagestyle{empty}
-
- \section*{Hardwarenahe Programmierung\\
- Übungsaufgaben -- 31.\ Oktober 2022}
-
- Diese Übung enthält Punkteangaben wie in einer Klausur.
- Um zu "`bestehen"', müssen Sie innerhalb von 85 Minuten
- unter Verwendung ausschließlich zugelassener Hilfsmittel
- 17 Punkte (von insgesamt \totalpoints) erreichen.
-
- \exercise{Zahlensysteme}
-
- Wandeln Sie ohne Hilfsmittel
-
- \begin{minipage}[t]{0.3\textwidth}
- \begin{itemize}
- \item
- nach Dezimal:
- \begin{itemize}
- \item[(a)]
- 0010\,0000$_2$
- \item[(b)]
- 42$_{16}$
- \item[(c)]
- 17$_8$
- \end{itemize}
- \end{itemize}
- \end{minipage}\hfill
- \begin{minipage}[t]{0.3\textwidth}
- \begin{itemize}
- \item
- nach Hexadezimal:
- \begin{itemize}
- \item[(d)]
- 0010\,0000$_2$
- \item[(e)]
- 42$_{10}$
- \item[(f)]
- 192.168.20.254$_{256}$
- \end{itemize}
- \end{itemize}
- \end{minipage}\hfill
- \begin{minipage}[t]{0.3\textwidth}
- \begin{itemize}
- \item
- nach Binär:
- \begin{itemize}
- \item[(g)]
- 750$_8$
- \item[(h)]
- 42$_{10}$
- \item[(i)]
- AFFE$_{16}$
- \end{itemize}
- \end{itemize}
- \end{minipage}
-
- \medskip
-
- Berechnen Sie ohne Hilfsmittel:
- \begin{itemize}
- \item[(j)]
- 750$_8$ \& 666$_8$
- \item[(k)]
- A380$_{16}$ + B747$_{16}$
- \item[(l)]
- AFFE$_{16} >> 1$
- \end{itemize}
-
- Die tiefgestellte Zahl steht für die Basis des Zahlensystems.
- Jede Teilaufgabe zählt 1 Punkt. \addtocounter{points}{12}
-
- (In der Klausur sind Hilfsmittel zugelassen,
- daher ist dies \emph{keine\/} typische Klausuraufgabe.)
-
- \exercise{Mikrocontroller}
-
- \begin{minipage}[t]{10cm}
- An die vier Ports eines ATmega16-Mikrocontrollers sind Leuchtdioden angeschlossen:
- \begin{itemize}
- \item
- von links nach rechts an die Ports A, B, C und D,
- \item
- von oben nach unten an die Bits Nr.\ 0 bis 7.
- \end{itemize}
-
- Wir betrachten das folgende Programm (\gitfile{hp}{2022ws/20221031}{aufgabe-2.c}):
-
- \begin{lstlisting}[gobble=6]
- #include <avr/io.h>
-
- int main (void)
- {
- DDRA = 0xff;
- DDRB = 0xff;
- DDRC = 0xff;
- DDRD = 0xff;
- PORTA = 0x1f;
- PORTB = 0x10;
- PORTD = 0x10;
- PORTC = 0xfc;
- while (1);
- return 0;
- }
- \end{lstlisting}
- \end{minipage}\hfill
- \begin{minipage}[t]{3cm}
- \strut\\[-\baselineskip]
- \includegraphics[width=3cm]{leds.jpg}
- \end{minipage}
-
- \vspace*{-3cm}
-
- \strut\hfill
- \begin{minipage}{11.8cm}
- \begin{itemize}
- \item[(a)]
- Was bewirkt dieses Programm? \points{4}
- \item[(b)]
- Wozu dienen die ersten vier Zeilen des Hauptprogramms? \points{2}
- \item[(c)]
- Was würde stattdessen die Zeile \lstinline{DDRA, DDRB, DDRC, DDRD = 0xff;} bewirken?
- \points{2}
- \item[(d)]
- Schreiben Sie das Programm so um,
- daß die durch das Programm dargestellte Figur spiegelverkehrt erscheint. \points{3}
- \item[(e)]
- Wozu dient das \lstinline{while (1)}? \points{2}
- \item
- Alle Antworten bitte mit Begründung.
- \end{itemize}
- \end{minipage}
-
- \exercise{Einfügen in Strings}
-
- Wir betrachten das folgende Programm (\gitfile{hp}{2022ws/20221031}{aufgabe-3.c}):
-% \begin{lstlisting}[style=numbered]
- \begin{lstlisting}
- #include <stdio.h>
- #include <string.h>
-
- void insert_into_string (char src, char *target, int pos)
- {
- int len = strlen (target);
- for (int i = pos; i < len; i++)
- target[i+1] = target[i];
- target[pos] = src;
- }
-
- int main (void)
- {
- char test[100] = "Hochshule Bochum";
- insert_into_string ('c', test, 5);
- printf ("%s\n", test);
- return 0;
- }
- \end{lstlisting}
- Die Ausgabe des Programms lautet:
- \lstinline[style=terminal]{Hochschhhhhhhhhhh}
-
- \begin{enumerate}[\quad(a)]
- \item
- Erklären Sie, wie die Ausgabe zustandekommt.
- \points{3}
-% \workspace{12}
- \item
- Schreiben Sie die Funktion \lstinline|insert_into_string()| so um,
- daß sie den Buchstaben \lstinline{src} an der Stelle \lstinline{pos}
- in den String \lstinline{target} einfügt.\par
- Die Ausgabe des Programms müßte dann
- \lstinline[style=terminal]{Hochschule Bochum} lauten.
- \points{2}
-% \workspace{13}
- \item
- Was kann passieren, wenn Sie die Zeile
- \lstinline{char test[100] = "Hochshule Bochum";}\\
- durch
- \lstinline{char test[] = "Hochshule Bochum";} ersetzen?
- Begründen Sie Ihre Antwort.
- \points{2}
-% \workspace{10}
- \item
- Was kann passieren, wenn Sie die Zeile
- \lstinline{char test[100] = "Hochshule Bochum";}\\
- durch
- \lstinline{char *test = "Hochshule Bochum";} ersetzen?
- Begründen Sie Ihre Antwort.
- \points{2}
-% \workspace{10}
-% \item
-% Schreiben Sie eine Funktion
-% \lstinline{void insert_into_string_sorted (char src, char *target)},
-% die voraussetzt, daß der String \lstinline{target} alphabetisch sortiert ist
-% und den Buchstaben \lstinline{src} an der alphabetisch richtigen Stelle
-% einfügt. Diese Funktion darf die bereits vorhandene Funktion
-% \lstinline|insert_into_string()| aufrufen.\\
-% \points{4}\par
-% Zum Testen eignen sich die folgenden Zeilen im Hauptprogramm:
-% \begin{lstlisting}[gobble=8]
-% char test[100] = "";
-% insert_into_string_sorted ('c', test);
-% insert_into_string_sorted ('a', test);
-% insert_into_string_sorted ('d', test);
-% insert_into_string_sorted ('b', test);
-% \end{lstlisting}
-% Danach sollte \lstinline{test[]} die Zeichenfolge \lstinline{"abcd"} enthalten.
-% \workspace{14}
-% \item
-% Wie schnell (Landau-Symbol in Abhängigkeit von der Länge $n$ des Strings)
-% arbeitet Ihre Funktion
-% \lstinline{void insert_into_string_sorted (char src, char *target)}
-% und warum?
-% \points{1}
-% \workspace{10}
-% \item
-% Beschreiben Sie -- in Worten oder als C-Quelltext --, wie man die Funktion\\
-% \lstinline{void insert_into_string_sorted (char src, char *target)}
-% so gestalten kann,\\
-% daß sie in $\mathcal{O}(\log n)$ arbeitet.
-% \points{3}
-% \workspace{35}
- \end{enumerate}
-
- \begin{flushright}
- \textit{Viel Erfolg!}
- \end{flushright}
-
- \makeatletter
- \immediate\write\@mainaux{\string\gdef\string\totalpoints{\arabic{points}}}
- \makeatother
-
-\end{document}
diff --git a/20221031/int-types-01.c b/20221031/int-types-01.c
deleted file mode 100644
index f25506073bdc0111222ff93f88d586b35383e0e8..0000000000000000000000000000000000000000
--- a/20221031/int-types-01.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-#include <inttypes.h>
-
-int main (void)
-{
- uint64_t x = 42;
- printf ("Die Antwort lautet: %" PRIu64 "\n", x);
- return 0;
-}
diff --git a/20221031/int-types-01.txt b/20221031/int-types-01.txt
deleted file mode 100644
index 58fdfb4d785ccbeffe1f9498d3e11df72fce0e68..0000000000000000000000000000000000000000
--- a/20221031/int-types-01.txt
+++ /dev/null
@@ -1,34 +0,0 @@
-cassini/home/peter/bo/2022ws/hp/20221031> cat int-types-01.c
-#include <stdio.h>
-#include <stdint.h>
-#include <inttypes.h>
-
-int main (void)
-{
- uint64_t x = 42;
- printf ("Die Antwort lautet: %" PRIu64 "\n", x);
- return 0;
-}
-cassini/home/peter/bo/2022ws/hp/20221031> gcc -Wall -O int-types-01.c -E -P | tail
-{
- return __wcstoul_internal (nptr, endptr, base, 0);
-}
-
-int main (void)
-{
- uint64_t x = 42;
- printf ("Die Antwort lautet: %" "l" "u" "\n", x);
- return 0;
-}
-cassini/home/peter/bo/2022ws/hp/20221031> gcc -m32 -Wall -O int-types-01.c -E -P | tail
-{
- return __wcstoull_internal (nptr, endptr, base, 0);
-}
-
-int main (void)
-{
- uint64_t x = 42;
- printf ("Die Antwort lautet: %" "ll" "u" "\n", x);
- return 0;
-}
-cassini/home/peter/bo/2022ws/hp/20221031>
diff --git a/20221031/io-ports-and-interrupts.pdf b/20221031/io-ports-and-interrupts.pdf
deleted file mode 120000
index bcd46f7afb35605b20bdb05637e6de0a039893ec..0000000000000000000000000000000000000000
--- a/20221031/io-ports-and-interrupts.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/io-ports-and-interrupts.pdf
\ No newline at end of file
diff --git a/20221031/leds.jpg b/20221031/leds.jpg
deleted file mode 120000
index 5e66b77c5c428129f6f4abcc80ae48f0c9a53c35..0000000000000000000000000000000000000000
--- a/20221031/leds.jpg
+++ /dev/null
@@ -1 +0,0 @@
-../common/leds.jpg
\ No newline at end of file
diff --git a/20221031/loesung-3.c b/20221031/loesung-3.c
deleted file mode 100644
index 85abfcf3e1e4bacf454acd10f6832b757a64ac35..0000000000000000000000000000000000000000
--- a/20221031/loesung-3.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-void insert_into_string (char src, char *target, int pos)
-{
- int len = strlen (target);
- for (int i = len; i >= pos; i--)
- target[i + 1] = target[i];
- target[pos] = src;
-}
-
-int main (void)
-{
- char test[100] = "Hochshule Bochum";
- insert_into_string ('c', test, 5);
- printf ("%s\n", test);
- return 0;
-}
diff --git a/20221031/logo-hochschule-bochum-cvh-text-v2.pdf b/20221031/logo-hochschule-bochum-cvh-text-v2.pdf
deleted file mode 120000
index 4aa99b8f81061aca6dcaf43eed2d9efef40555f8..0000000000000000000000000000000000000000
--- a/20221031/logo-hochschule-bochum-cvh-text-v2.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
diff --git a/20221031/logo-hochschule-bochum.pdf b/20221031/logo-hochschule-bochum.pdf
deleted file mode 120000
index b6b9491e370e499c9276918182cdb82cb311bcd1..0000000000000000000000000000000000000000
--- a/20221031/logo-hochschule-bochum.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20221031/pgscript.sty b/20221031/pgscript.sty
deleted file mode 120000
index 95c888478c99ea7fda0fd11ccf669ae91be7178b..0000000000000000000000000000000000000000
--- a/20221031/pgscript.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgscript.sty
\ No newline at end of file
diff --git a/20221031/pgslides.sty b/20221031/pgslides.sty
deleted file mode 120000
index 5be1416f4216f076aa268901f52a15d775e43f64..0000000000000000000000000000000000000000
--- a/20221031/pgslides.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgslides.sty
\ No newline at end of file
diff --git a/20221031/philosophy-03.txt b/20221031/philosophy-03.txt
deleted file mode 100644
index b201e09fe01bbcda4b0582c14639e79335688876..0000000000000000000000000000000000000000
--- a/20221031/philosophy-03.txt
+++ /dev/null
@@ -1,24 +0,0 @@
-cassini/home/peter/bo/2022ws/hp/20221031> cat philosophy.c
-#include <stdio.h>
-#include "answer.h"
-
-int main (void)
-{
- printf ("The answer is %d.\n", answer ());
- return 0;
-}
-cassini/home/peter/bo/2022ws/hp/20221031> cat answer.h
-extern int answer (void);
-cassini/home/peter/bo/2022ws/hp/20221031> cat answer.c
-#include "answer.h"
-
-int answer (void)
-{
- return 23;
-}
-cassini/home/peter/bo/2022ws/hp/20221031> gcc -Wall -O philosophy.c -c
-cassini/home/peter/bo/2022ws/hp/20221031> gcc -Wall -O answer.c -c
-cassini/home/peter/bo/2022ws/hp/20221031> gcc philosophy.o answer.o -o philosophy
-cassini/home/peter/bo/2022ws/hp/20221031> ./philosophy
-The answer is 23.
-cassini/home/peter/bo/2022ws/hp/20221031>
\ No newline at end of file
diff --git a/20221031/philosophy-04.txt b/20221031/philosophy-04.txt
deleted file mode 100644
index cf8db4e6dd5aea1e9424d2bd3bc9150bc21076a9..0000000000000000000000000000000000000000
--- a/20221031/philosophy-04.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-cassini/home/peter/bo/2022ws/hp/20221031> ls -lrt philosophy* answer.*
--rw-r--r-- 1 peter peter 26 Nov 22 2012 answer.h
--rw-r--r-- 1 peter peter 117 Nov 22 2012 philosophy.c
--rw-r--r-- 1 peter peter 56 Nov 21 2013 answer.c
--rw-r--r-- 1 peter peter 1632 Okt 31 12:28 philosophy.o
--rw-r--r-- 1 peter peter 1208 Okt 31 12:29 answer.o
--rwxr-xr-x 1 peter peter 16680 Okt 31 12:29 philosophy
--rw-r--r-- 1 peter peter 705 Okt 31 12:29 philosophy-03.txt
-cassini/home/peter/bo/2022ws/hp/20221031> rm philosophy
-cassini/home/peter/bo/2022ws/hp/20221031> make -f Makefile-1
-gcc philosophy.o answer.o -o philosophy
-cassini/home/peter/bo/2022ws/hp/20221031> rm philosophy.o answer.o
-cassini/home/peter/bo/2022ws/hp/20221031> make -f Makefile-1
-gcc -Wall -O philosophy.c -c
-gcc -Wall -O answer.c -c
-gcc philosophy.o answer.o -o philosophy
-cassini/home/peter/bo/2022ws/hp/20221031>
diff --git a/20221031/philosophy.c b/20221031/philosophy.c
deleted file mode 100644
index e9f508a501d9ec66d02e0636a9f6c71f2c7a8594..0000000000000000000000000000000000000000
--- a/20221031/philosophy.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-#include "answer.h"
-
-int main (void)
-{
- printf ("The answer is %d.\n", answer ());
- return 0;
-}
diff --git a/20221107/Makefile b/20221107/Makefile
deleted file mode 100644
index 7ae33df99f68fcf460324cfbb008f3f7a3863638..0000000000000000000000000000000000000000
--- a/20221107/Makefile
+++ /dev/null
@@ -1,8 +0,0 @@
-%.elf: %.c
- avr-gcc -Wall -Os -mmcu=atmega328p $< -o $@
-
-%.hex: %.elf
- avr-objcopy -O ihex $< $@
-
-download:
- ./download.sh
diff --git a/20221107/aufgabe-2.c b/20221107/aufgabe-2.c
deleted file mode 100644
index d0b065941fbc0082bf867d872527299dca97b98f..0000000000000000000000000000000000000000
--- a/20221107/aufgabe-2.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <string.h>
-
-int fun_1 (char *s)
-{
- int x = 0;
- for (int i = 0; i < strlen (s); i++)
- x += s[i];
- return x;
-}
-
-int fun_2 (char *s)
-{
- int i = 0, x = 0;
- int len = strlen (s);
- while (i < len)
- x += s[i++];
- return x;
-}
diff --git a/20221107/aufgabe-3.c b/20221107/aufgabe-3.c
deleted file mode 100644
index 4c95eb6ad4881c904448309c6b7c46fa101cc109..0000000000000000000000000000000000000000
--- a/20221107/aufgabe-3.c
+++ /dev/null
@@ -1,33 +0,0 @@
-#include <stdint.h>
-#include <avr/io.h>
-#include <avr/interrupt.h>
-
-uint8_t counter = 1;
-uint8_t leds = 0;
-
-ISR (TIMER0_COMP_vect)
-{
- if (counter == 0)
- {
- leds = (leds + 1) % 8;
- PORTC = leds << 4;
- }
- counter++;
-}
-
-void init (void)
-{
- cli ();
- TCCR0 = (1 << CS01) | (1 << CS00);
- TIMSK = 1 << OCIE0;
- sei ();
- DDRC = 0x70;
-}
-
-int main (void)
-{
- init ();
- while (1)
- ; /* do nothing */
- return 0;
-}
diff --git a/20221107/blink-0.c b/20221107/blink-0.c
deleted file mode 100644
index b0022c681fd1482ed0a6d9fded7bb0a54699de32..0000000000000000000000000000000000000000
--- a/20221107/blink-0.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <avr/io.h>
-
-int main (void)
-{
- DDRD = 0x40; /* binär: 0100 0000 */
- PORTD = 0x40; /* binär: 0100 0000 */
- while (1);
- return 0;
-}
diff --git a/20221107/blink-0a.c b/20221107/blink-0a.c
deleted file mode 100644
index 7093fa4cbf094be60a9ae35117c84be13258235c..0000000000000000000000000000000000000000
--- a/20221107/blink-0a.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <avr/io.h>
-
-int main (void)
-{
- DDRD = 0x40; /* binär: 0100 0000 */
- PORTD = 0x00; /* binär: 0000 0000 */
- while (1);
- return 0;
-}
diff --git a/20221107/blink-1.c b/20221107/blink-1.c
deleted file mode 100644
index 6d28dce84f94375094c98479c30a54ace1b2a9d9..0000000000000000000000000000000000000000
--- a/20221107/blink-1.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <avr/io.h>
-
-#define F_CPU 16000000l
-#include <util/delay.h>
-
-int main (void)
-{
- DDRD = 0x01;
- PORTD |= 0x01;
- while (1)
- {
- _delay_ms (500);
- PORTD &= ~0x01;
- _delay_ms (500);
- PORTD |= 0x01;
- }
- return 0;
-}
diff --git a/20221107/blink-10.c b/20221107/blink-10.c
deleted file mode 100644
index 6c36fbe183bb4c68bb0ae757145dd96897106dd9..0000000000000000000000000000000000000000
--- a/20221107/blink-10.c
+++ /dev/null
@@ -1,31 +0,0 @@
-#include <avr/io.h>
-#include <avr/interrupt.h>
-#include <stdint.h>
-
-#define F_CPU 16000000l
-#include <util/delay.h>
-
-volatile uint8_t key_pressed = 0;
-
-ISR (INT0_vect) /* PD2 */
-{
- key_pressed = 1;
-}
-
-int main (void)
-{
- cli ();
- EICRA = 1 << ISC00 | 1 << ISC01; /* INT0: steigende Flanke */
- EIMSK = 1 << INT0; /* INT0 einschalten */
- sei ();
- DDRD = 0xfb; /* binär: 1111 1011 */
- PORTD = 0x44; /* binär: 0100 0100 */
- while (1)
- {
- while (!key_pressed)
- ; /* just wait */
- PORTD ^= 0x40;
- key_pressed = 0;
- }
- return 0;
-}
diff --git a/20221107/blink-10.s b/20221107/blink-10.s
deleted file mode 100644
index b77f3989646f63d842f03582b278c2b2b8937ca4..0000000000000000000000000000000000000000
--- a/20221107/blink-10.s
+++ /dev/null
@@ -1,75 +0,0 @@
- .file "blink-10.c"
-__SP_H__ = 0x3e
-__SP_L__ = 0x3d
-__SREG__ = 0x3f
-__tmp_reg__ = 0
-__zero_reg__ = 1
- .text
-.global __vector_1
- .type __vector_1, @function
-__vector_1:
- push r1
- push r0
- in r0,__SREG__
- push r0
- clr __zero_reg__
- push r24
-/* prologue: Signal */
-/* frame size = 0 */
-/* stack size = 4 */
-.L__stack_usage = 4
- ldi r24,lo8(1)
- sts key_pressed,r24
-/* epilogue start */
- pop r24
- pop r0
- out __SREG__,r0
- pop r0
- pop r1
- reti
- .size __vector_1, .-__vector_1
- .section .text.startup,"ax",@progbits
-.global main
- .type main, @function
-main:
-/* prologue: function */
-/* frame size = 0 */
-/* stack size = 0 */
-.L__stack_usage = 0
-/* #APP */
- ; 17 "blink-10.c" 1
- cli
- ; 0 "" 2
-/* #NOAPP */
- ldi r24,lo8(3)
- sts 105,r24
- ldi r24,lo8(1)
- out 0x1d,r24
-/* #APP */
- ; 20 "blink-10.c" 1
- sei
- ; 0 "" 2
-/* #NOAPP */
- ldi r24,lo8(-5)
- out 0xa,r24
- ldi r24,lo8(68)
- out 0xb,r24
- ldi r25,lo8(64)
-.L3:
- lds r24,key_pressed
- tst r24
- breq .L3
- in r24,0xb
- eor r24,r25
- out 0xb,r24
- sts key_pressed,__zero_reg__
- rjmp .L3
- .size main, .-main
-.global key_pressed
- .section .bss
- .type key_pressed, @object
- .size key_pressed, 1
-key_pressed:
- .zero 1
- .ident "GCC: (GNU) 5.4.0"
-.global __do_clear_bss
diff --git a/20221107/blink-11.c b/20221107/blink-11.c
deleted file mode 100644
index 72020dc5c582d1ce19e4efd8a079818760e89f27..0000000000000000000000000000000000000000
--- a/20221107/blink-11.c
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <avr/io.h>
-#include <avr/interrupt.h>
-#include <stdint.h>
-
-#define F_CPU 16000000l
-#include <util/delay.h>
-
-volatile uint8_t key_pressed = 0;
-
-ISR (INT0_vect) /* PD2 */
-{
- key_pressed = 1;
-}
-
-int main (void)
-{
- cli ();
- EICRA = 1 << ISC00 | 1 << ISC01; /* INT0: steigende Flanke */
- EIMSK = 1 << INT0; /* INT0 einschalten */
- sei ();
- DDRD = 0xfb; /* binär: 1111 1011 */
- PORTD = 0x44; /* binär: 0100 0100 */
- while (1)
- {
- while (!key_pressed)
- ; /* just wait */
- _delay_ms (1);
- PORTD ^= 0x40;
- key_pressed = 0;
- }
- return 0;
-}
diff --git a/20221107/blink-1a.c b/20221107/blink-1a.c
deleted file mode 100644
index f594cc175fa238d3ba3f930bc8bcbfeb1ddaa43b..0000000000000000000000000000000000000000
--- a/20221107/blink-1a.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <avr/io.h>
-
-#define F_CPU 16000000l
-#include <util/delay.h>
-
-int main (void)
-{
- DDRD = 0xff; /* 1111 1111 --> alle Ports als Output-Ports nutzen */
- PORTD = 0x1a; /* 0001 1010 */
- while (1)
- {
- _delay_ms (500);
- PORTD &= ~0x01;
- _delay_ms (500);
- PORTD |= 0x01;
- }
- return 0;
-}
diff --git a/20221107/blink-1b.c b/20221107/blink-1b.c
deleted file mode 100644
index f435112888a5ba118a33c689de63462776d1d072..0000000000000000000000000000000000000000
--- a/20221107/blink-1b.c
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <avr/io.h>
-
-#define F_CPU 16000000l
-#include <util/delay.h>
-
-int main (void)
-{
- DDRD = 0x7f; /* 0111 1111 --> alle Ports als Output-Ports nutzen */
- PORTD = 0x01; /* 0000 0001 */
- while (1)
- {
- while (PIND & 0x80) /* 1000 0000 */
- {
- _delay_ms (500);
- PORTD &= ~0x01;
- _delay_ms (500);
- PORTD |= 0x01;
- }
- }
- return 0;
-}
diff --git a/20221107/blink-2.c b/20221107/blink-2.c
deleted file mode 100644
index 9389b19b1bf46d5ca90bac823e3f94269fe02878..0000000000000000000000000000000000000000
--- a/20221107/blink-2.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <avr/io.h>
-
-#define F_CPU 16000000l
-#include <util/delay.h>
-
-int main (void)
-{
- DDRD = 0x02; /* binär: 0000 0010 */
- PORTD = 0x02;
- while (1)
- {
- _delay_ms (250);
- PORTD ^= 0x02;
- }
- return 0;
-}
diff --git a/20221107/blink-2a.c b/20221107/blink-2a.c
deleted file mode 100644
index a2e246a00bb109a865f246dabc20a0e1f0bbc792..0000000000000000000000000000000000000000
--- a/20221107/blink-2a.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <avr/io.h>
-
-#define F_CPU 16000000l
-#include <util/delay.h>
-
-int main (void)
-{
- DDRD = 0x04; /* binär: 0000 0100 */
- PORTD = 0x04;
- while (1)
- {
- _delay_ms (250);
- PORTD ^= 0x04;
- }
- return 0;
-}
diff --git a/20221107/blink-3.c b/20221107/blink-3.c
deleted file mode 100644
index 5268e7977f0f2a99b2005a81a2fa7560dfea481f..0000000000000000000000000000000000000000
--- a/20221107/blink-3.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include <avr/io.h>
-
-#define F_CPU 16000000
-#include <util/delay.h>
-
-int main (void)
-{
- DDRD = 0x01;
- PORTD = 0x01;
- while (1)
- {
- while ((PIND & 0x02) == 0)
- ; /* just wait */
- PORTD ^= 0x01;
- }
- return 0;
-}
diff --git a/20221107/blink-4.c b/20221107/blink-4.c
deleted file mode 100644
index ceafab6b1e7462497fde98b7a12e72cc34132bbe..0000000000000000000000000000000000000000
--- a/20221107/blink-4.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <avr/io.h>
-
-#define F_CPU 16000000
-#include <util/delay.h>
-
-int main (void)
-{
- DDRD = 0x01; /* binär: 0000 0001 */
- PORTD = 0x01; /* ^ Ouptut */
- while (1) /* ^ Input */
- {
- while ((PIND & 0x02) == 0) /* binär: 0000 0010 */
- ; /* just wait */
- PORTD ^= 0x01;
- _delay_ms (200);
- }
- return 0;
-}
diff --git a/20221107/blink-5.c b/20221107/blink-5.c
deleted file mode 100644
index bb755f0de02d3e224909f1d2a37789f3c14a0f03..0000000000000000000000000000000000000000
--- a/20221107/blink-5.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <avr/io.h>
-#include <avr/interrupt.h>
-
-ISR (TIMER0_COMPB_vect)
-{
- PORTD ^= 0x40;
-}
-
-int main (void)
-{
- cli ();
- TCCR0B = (1 << CS01) | (1 << CS00); /* Takt durch 64 dividieren */
- TIMSK0 = 1 << OCIE0B; /* Interrupt einschalten */
- sei ();
- DDRD = 0xfd; /* binär: 1111 1101 */
- PORTD = 0x40; /* binär: 0100 0000 */
- while (1);
- return 0;
-}
diff --git a/20221107/blink-6.c b/20221107/blink-6.c
deleted file mode 100644
index 651ab6e4ac926242337a0520c11f2bbd935bdd22..0000000000000000000000000000000000000000
--- a/20221107/blink-6.c
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <avr/io.h>
-#include <avr/interrupt.h>
-#include <stdint.h>
-
-ISR (TIMER0_COMPB_vect)
-{
- static uint8_t counter = 0;
- if (counter++ == 0)
- PORTD ^= 0x40;
-}
-
-int main (void)
-{
- cli ();
- TCCR0B = (1 << CS01) | (1 << CS00); /* Takt durch 64 dividieren */
- TIMSK0 = 1 << OCIE0B; /* Interrupt einschalten */
- sei ();
- DDRD = 0xfd; /* binär: 1111 1101 */
- PORTD = 0x40; /* binär: 0100 0000 */
- while (1);
- return 0;
-}
diff --git a/20221107/blink-7.c b/20221107/blink-7.c
deleted file mode 100644
index 7ed39822752f61b636f001b77eb3742a57e953a9..0000000000000000000000000000000000000000
--- a/20221107/blink-7.c
+++ /dev/null
@@ -1,20 +0,0 @@
-#include <avr/io.h>
-#include <avr/interrupt.h>
-#include <stdint.h>
-
-ISR (INT0_vect) /* PD2 */
-{
- PORTD ^= 0x40;
-}
-
-int main (void)
-{
- cli ();
- EICRA = 1 << ISC00 | 1 << ISC01; /* INT0: steigende Flanke */
- EIMSK = 1 << INT0; /* INT0 einschalten */
- sei ();
- DDRD = 0xfb; /* binär: 1111 1011 */
- PORTD = 0x40; /* binär: 0100 0000 */
- while (1);
- return 0;
-}
diff --git a/20221107/blink-8.c b/20221107/blink-8.c
deleted file mode 100644
index aba94f07176a75656619d1ba09e83093cbc66c89..0000000000000000000000000000000000000000
--- a/20221107/blink-8.c
+++ /dev/null
@@ -1,20 +0,0 @@
-#include <avr/io.h>
-#include <avr/interrupt.h>
-#include <stdint.h>
-
-ISR (INT0_vect) /* PD2 */
-{
- PORTD ^= 0x40;
-}
-
-int main (void)
-{
- cli ();
- EICRA = 1 << ISC00 | 1 << ISC01; /* INT0: steigende Flanke */
- EIMSK = 1 << INT0; /* INT0 einschalten */
- sei ();
- DDRD = 0xff; /* binär: 1111 1111 */
- PORTD = 0x40; /* binär: 0100 0000 */
- while (1);
- return 0;
-}
diff --git a/20221107/blink-9.c b/20221107/blink-9.c
deleted file mode 100644
index 486b7a2d07ea524e709560a627b4121ead7ed332..0000000000000000000000000000000000000000
--- a/20221107/blink-9.c
+++ /dev/null
@@ -1,31 +0,0 @@
-#include <avr/io.h>
-#include <avr/interrupt.h>
-#include <stdint.h>
-
-#define F_CPU 16000000l
-#include <util/delay.h>
-
-uint8_t key_pressed = 0;
-
-ISR (INT0_vect) /* PD2 */
-{
- key_pressed = 1;
-}
-
-int main (void)
-{
- cli ();
- EICRA = 1 << ISC00 | 1 << ISC01; /* INT0: steigende Flanke */
- EIMSK = 1 << INT0; /* INT0 einschalten */
- sei ();
- DDRD = 0xfb; /* binär: 1111 1011 */
- PORTD = 0x44; /* binär: 0100 0100 */
- while (1)
- {
- while (!key_pressed)
- ; /* just wait */
- PORTD ^= 0x40;
- key_pressed = 0;
- }
- return 0;
-}
diff --git a/20221107/blink-9.s b/20221107/blink-9.s
deleted file mode 100644
index 82e900d919212d857c79b51e071b1a13babbfc75..0000000000000000000000000000000000000000
--- a/20221107/blink-9.s
+++ /dev/null
@@ -1,78 +0,0 @@
- .file "blink-9.c"
-__SP_H__ = 0x3e
-__SP_L__ = 0x3d
-__SREG__ = 0x3f
-__tmp_reg__ = 0
-__zero_reg__ = 1
- .text
-.global __vector_1
- .type __vector_1, @function
-__vector_1:
- push r1
- push r0
- in r0,__SREG__
- push r0
- clr __zero_reg__
- push r24
-/* prologue: Signal */
-/* frame size = 0 */
-/* stack size = 4 */
-.L__stack_usage = 4
- ldi r24,lo8(1)
- sts key_pressed,r24
-/* epilogue start */
- pop r24
- pop r0
- out __SREG__,r0
- pop r0
- pop r1
- reti
- .size __vector_1, .-__vector_1
- .section .text.startup,"ax",@progbits
-.global main
- .type main, @function
-main:
-/* prologue: function */
-/* frame size = 0 */
-/* stack size = 0 */
-.L__stack_usage = 0
-/* #APP */
- ; 17 "blink-9.c" 1
- cli
- ; 0 "" 2
-/* #NOAPP */
- ldi r24,lo8(3)
- sts 105,r24
- ldi r24,lo8(1)
- out 0x1d,r24
-/* #APP */
- ; 20 "blink-9.c" 1
- sei
- ; 0 "" 2
-/* #NOAPP */
- ldi r24,lo8(-5)
- out 0xa,r24
- ldi r24,lo8(68)
- out 0xb,r24
- ldi r25,lo8(64)
-.L4:
- lds r24,key_pressed
- cpse r24,__zero_reg__
- rjmp .L7
-.L6:
- rjmp .L6
-.L7:
- in r24,0xb
- eor r24,r25
- out 0xb,r24
- sts key_pressed,__zero_reg__
- rjmp .L4
- .size main, .-main
-.global key_pressed
- .section .bss
- .type key_pressed, @object
- .size key_pressed, 1
-key_pressed:
- .zero 1
- .ident "GCC: (GNU) 5.4.0"
-.global __do_clear_bss
diff --git a/20221107/download.sh b/20221107/download.sh
deleted file mode 100755
index 770c3b5dca74ac09778be055c9d6f5adb0df293b..0000000000000000000000000000000000000000
--- a/20221107/download.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-port=$(ls -rt /dev/ttyACM* | tail -1)
-echo avrdude -P $port -c arduino -p m328p -U flash:w:$(ls -rt *.hex | tail -1)
-avrdude -P $port -c arduino -p m328p -U flash:w:$(ls -rt *.hex | tail -1) 2>/dev/null
diff --git a/20221107/hp-20221107.pdf b/20221107/hp-20221107.pdf
deleted file mode 100644
index ebeb94f73fb232d1b3ce27c703301b6a3b3e1e89..0000000000000000000000000000000000000000
Binary files a/20221107/hp-20221107.pdf and /dev/null differ
diff --git a/20221107/hp-20221107.tex b/20221107/hp-20221107.tex
deleted file mode 100644
index 159a1850f21fe03f04efee08f9ab126438794a63..0000000000000000000000000000000000000000
--- a/20221107/hp-20221107.tex
+++ /dev/null
@@ -1,1148 +0,0 @@
-% hp-20221107.pdf - Lecture Slides on Low-Level Programming
-% Copyright (C) 2012, 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Interrupts, volatile-Variable, Endianness
-
-\documentclass[10pt,t]{beamer}
-
-\usepackage{pgslides}
-\usepackage{pdftricks}
-\usepackage{tikz}
-
-\begin{psinputs}
- \usepackage[utf8]{inputenc}
- \usepackage[german]{babel}
- \usepackage[T1]{fontenc}
- \usepackage{helvet}
- \renewcommand*\familydefault{\sfdefault}
- \usepackage{pstricks,pst-grad}
-\end{psinputs}
-
-\newcommand{\redurl}[1]{\href{#1}{\color{red}\nolinkurl{#1}}}
-
-\title{Hardwarenahe Programmierung}
-\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
-\date{7.\ November 2022}
-
-\begin{document}
-
-\maketitleframe
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \begin{itemize}
- \item[3.1] Der Präprozessor
- \item[3.2] Bibliotheken einbinden
- \color{medgreen}
- \item[3.3] Bibliotheken verwenden
- \item[3.4] Projekt organisieren: make
- \end{itemize}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \begin{itemize}
- \color{medgreen}
- \item[4.1] Bit-Operationen
- \item[4.2] I/O-Ports
- \color{red}
- \item[4.3] Interrupts
- \vspace*{-0.1cm}
- \item[\dots]
- \end{itemize}
- \item[\textbf{5}] \textbf{Algorithmen}
- \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
- \item[\textbf{7}] \textbf{Datenstrukturen}
- \end{itemize}
-
-\end{frame}
-
-\setcounter{section}{2}
-\section{Bibliotheken}
-\setcounter{subsection}{2}
-\subsection{Bibliotheken verwenden (Beispiel: GTK+)}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{itemize}
- \item
- \lstinline{#include <gtk/gtk.h>}
- \pause
- \smallskip
- \item
- Mit \lstinline[style=cmd]{pkg-config --cflags --libs} erfährt man,\\
- welche Optionen und Bibliotheken man an \lstinline[style=cmd]{gcc}
- übergeben muß\alt<4->{.}{:}
- \pause
- \begin{onlyenv}<3>
- \begin{lstlisting}[style=terminal,gobble=10]
- $ ¡pkg-config --cflags --libs gtk+-3.0¿
- -pthread -I/usr/include/gtk-3.0 -I/usr/include/at-spi2-
- atk/2.0 -I/usr/include/at-spi-2.0 -I/usr/include/dbus-1
- .0 -I/usr/lib/x86_64-linux-gnu/dbus-1.0/include -I/usr/
- include/gtk-3.0 -I/usr/include/gio-unix-2.0/ -I/usr/inc
- lude/cairo -I/usr/include/pango-1.0 -I/usr/include/harf
- buzz -I/usr/include/pango-1.0 -I/usr/include/atk-1.0 -I
- /usr/include/cairo -I/usr/include/pixman-1 -I/usr/inclu
- de/freetype2 -I/usr/include/libpng16 -I/usr/include/gdk
- -pixbuf-2.0 -I/usr/include/libpng16 -I/usr/include/glib
- -2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -lgtk
- -3 -lgdk-3 -lpangocairo-1.0 -lpango-1.0 -latk-1.0 -lcai
- ro-gobject -lcairo -lgdk_pixbuf-2.0 -lgio-2.0 -lgobject
- -2.0 -lglib-2.0
- \end{lstlisting}
- \vspace*{-3cm}
- \end{onlyenv}
- \pause
- \arrowitem
- Compiler-Aufruf:
- \begin{onlyenv}<4>
- \begin{lstlisting}[style=terminal,gobble=10]
- $ ¡gcc -Wall -O hello-gtk.c -pthread -I/usr/include/gtk-
- 3.0 -I/usr/include/at-spi2-atk/2.0 -I/usr/include/at-sp
- i-2.0 -I/usr/include/dbus-1.0 -I/usr/lib/x86_64-linux-g
- nu/dbus-1.0/include -I/usr/include/gtk-3.0 -I/usr/inclu
- de/gio-unix-2.0/ -I/usr/include/cairo -I/usr/include/pa
- ngo-1.0 -I/usr/include/harfbuzz -I/usr/include/pango-1.
- 0 -I/usr/include/atk-1.0 -I/usr/include/cairo -I/usr/in
- clude/pixman-1 -I/usr/include/freetype2 -I/usr/include/
- libpng16 -I/usr/include/gdk-pixbuf-2.0 -I/usr/include/l
- ibpng16 -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux
- -gnu/glib-2.0/include -lgtk-3 -lgdk-3 -lpangocairo-1.0
- -lpango-1.0 -latk-1.0 -lcairo-gobject -lcairo -lgdk_pix
- buf-2.0 -lgio-2.0 -lgobject-2.0 -lglib-2.0 -o hello-gtk¿
- \end{lstlisting}
- \vspace*{-2cm}
- \end{onlyenv}
- \begin{onlyenv}<5->
- \begin{lstlisting}[style=terminal,gobble=10]
- $ ¡gcc -Wall -O hello-gtk.c $(pkg-config --cflags --libs
- gtk+-3.0) -o hello-gtk¿
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<5>
- \begin{picture}(0,0)(0.3,0.3)
- \color{red}
- \put(6.6,-0.6){\makebox(0,0)[bl]{\tikz{\draw[-latex](0,0)--(3,1.5);}}}
- \put(6.3,-0.7){\makebox(0,0)[t]{\shortstack{\strut Optionen:\\
- \strut u.\,a.\ viele Include-Verzeichnisse:\\
- \lstinline[style=cmd]{-I/usr/include/gtk-3.0}}}}
- \put(10.0,-2.1){\makebox(0,0)[bl]{\tikz{\draw[-latex](0,0)--(1.5,3);}}}
- \put(10.3,-2.2){\makebox(0,0)[t]{\shortstack{\strut Bibliotheken:\\
- \strut u.\,a.\ \lstinline[style=cmd]{-lgtk-3 -lcairo}~~~\strut}}}
- \end{picture}
- \end{onlyenv}
- \pause
- \pause
- \item
- Auf manchen Plattformen kommt es auf die Reihenfolge an:
- \begin{lstlisting}[style=terminal,gobble=8]
- $ ¡gcc -Wall -O $(pkg-config --cflags gtk+-3.0) \
- hello-gtk.c $(pkg-config --libs gtk+-3.0) \
- -o hello-gtk¿
- \end{lstlisting}
- (Backslash = "`Es geht in der nächsten Zeile weiter."')
- \end{itemize}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Selbst geschriebene Funktion übergeben: \newterm{Callback}
-
- \bigskip
-
- \begin{lstlisting}[xleftmargin=1em]
- gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
- {
- /* Zeichenbefehle */
- ...
-
- return FALSE;
- }
-
- ...
-
- g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
- \end{lstlisting}
-
- \medskip
-
- \begin{itemize}
- \arrowitem
- GTK+ ruft immer dann, wenn es etwas zu zeichnen gibt,\\
- die Funktion \lstinline{draw} auf.
- \end{itemize}
-
- \pause
- \begin{picture}(0,0)(-0.07,0.2)
- \color{red}
- \put(5.3,4.8){\makebox(0,0)[bl]{\tikz{\draw[-latex](0,0)--(1.90,1.15);}}}
- \put(5.0,4.7){\makebox(0,0)[t]{\shortstack{\strut repräsentiert den\\
- \strut Bildschirm, auf den\\
- \strut gezeichnet werden soll}}}
- \pause
- \put(9.7,5.1){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-0.2,0.85);}}}
- \put(9.7,5.0){\makebox(0,0)[t]{\shortstack{\strut optionale Zusatzinformationen\\
- \strut für draw(), typischerweise\\
- \strut ein Zeiger auf ein struct}}}
- \put(10.0,3.5){\makebox(0,0)[tl]{\tikz{\draw[-latex](0,0)--(0.6,-1.25);}}}
- \end{picture}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Selbst geschriebene Funktion übergeben: \newterm{Callback}
-
- \bigskip
-
- \begin{lstlisting}[xleftmargin=1em]
- gboolean timer (GtkWidget *widget)
- {
- /* Rechenbefehle */
- ...
-
- gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
- }
-
- ...
-
- g_timeout_add (50, (GSourceFunc) timer, drawing_area);
- \end{lstlisting}
-
- \medskip
-
- \begin{itemize}
- \arrowitem
- GTK+ ruft nach 50 Millisekunden
- die Funktion \lstinline{timer} auf.
- \end{itemize}
-
- \pause
- \begin{picture}(0,0)(-0.07,0.2)
- \color{red}
- \put(9.7,6.7){\makebox(0,0)[t]{\shortstack{\strut Dieser Bereich soll\\
- \strut neu gezeichnet werden.}}}
- \put(9.7,5.7){\makebox(0,0)[tr]{\tikz{\draw[-latex](0,0)--(-0.6,-0.8);}}}
- \pause
- \put(4.3,3.2){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-0.7,0.6);}}}
- \put(4.3,3.1){\makebox(0,0)[t]{\shortstack{\strut In weiteren 50 Millisekunden soll\\
- \strut die Funktion erneut aufgerufen werden.}}}
- \pause
- \put(9.3,2.9){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-3.3,0.9);}}}
- \put(9.8,2.8){\makebox(0,0)[t]{\shortstack{\strut Explizite Typumwandlung\\
- \strut eines Zeigers (später)}}}
- \end{picture}
-
-\end{frame}
-
-\subsection{Projekt organisieren: make}
-
-\begin{frame}[fragile]
-
- \showsubsection
- \begin{itemize}
- \item
- \only<4->{explizite und implizite} Regeln
- \begin{onlyenv}<2>
- \smallskip
- \begin{lstlisting}[language=make,gobble=10]
- philosophy: philosophy.o answer.o
- gcc philosophy.o answer.o -o philosophy
-
- answer.o: answer.c answer.h
- gcc -Wall -O answer.c -c
-
- philosophy.o: philosophy.c answer.h
- gcc -Wall -O philosophy.c -c
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<4>
- \smallskip
- \begin{lstlisting}[language=make,gobble=10]
- TARGET = philosophy
- OBJECTS = philosophy.o answer.o
- HEADERS = answer.h
- CFLAGS = -Wall -O
-
- $(TARGET): $(OBJECTS)
- gcc $(OBJECTS) -o $(TARGET)
-
- %.o: %.c $(HEADERS)
- gcc $(CFLAGS) $< -c
-
- clean:
- rm -f $(OBJECTS) $(TARGET)
- \end{lstlisting}
- \end{onlyenv}
- \item
- Makros
- \begin{onlyenv}<3>
- \smallskip
- \begin{lstlisting}[language=make,gobble=10]
- TARGET = philosophy
- OBJECTS = philosophy.o answer.o
- HEADERS = answer.h
- CFLAGS = -Wall -O
-
- $(TARGET): $(OBJECTS)
- gcc $(OBJECTS) -o $(TARGET)
-
- answer.o: answer.c $(HEADERS)
- gcc $(CFLAGS) answer.c -c
-
- philosophy.o: philosophy.c $(HEADERS)
- gcc $(CFLAGS) philosophy.c -c
-
- clean:
- rm -f $(OBJECTS) $(TARGET)
- \end{lstlisting}
- \vspace*{-1cm}
- \end{onlyenv}
- \begin{onlyenv}<5->
- \smallskip
- \arrowitem
- 3 Sprachen: C, Präprozessor, make
- \end{onlyenv}
- \end{itemize}
-
-\end{frame}
-
-\section{Hardwarenahe Programmierung}
-\subsection{Bit-Operationen}
-\subsubsection{Zahlensysteme}
-
-\begin{frame}[fragile]
-
- \showsection
- \vspace*{-\smallskipamount}
- \showsubsection
- \vspace*{-\medskipamount}
- \showsubsubsection
-
- \begin{tabular}{rlrl}
- Basis & Name & Beispiel & Anwendung \\[\smallskipamount]
- 2 & Binärsystem & 1\,0000\,0011 & Bit-Operationen \\
- 8 & Oktalsystem & \lstinline,0403, & Dateizugriffsrechte (Unix) \\
- 10 & Dezimalsystem & \lstinline,259, & Alltag \\
- 16 & Hexadezimalsystem & \lstinline,0x103, & Bit-Operationen \\
- 256 & (keiner gebräuchlich) & 0.0.1.3 & IP-Adressen (IPv4)
- \end{tabular}
-
- \bigskip
-
- \begin{itemize}
- \item
- Computer rechnen im Binärsystem.
- \item
- Für viele Anwendungen (z.\,B.\ I/O-Ports, Grafik, \dots) ist es notwendig,\\
- Bits in Zahlen einzeln ansprechen zu können.
- \end{itemize}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsubsection
-
- \begin{tabular}{rlrlrc}
- \qquad 000 & \bf 0 \hspace*{1.5cm} & 0000 & \bf 0 & \quad 1000 & \bf 8\\
- 001 & \bf 1 & 0001 & \bf 1 & 1001 & \bf 9\\
- 010 & \bf 2 & 0010 & \bf 2 & 1010 & \bf A\\
- 011 & \bf 3 & 0011 & \bf 3 & 1011 & \bf B\\[\smallskipamount]
- 100 & \bf 4 & 0100 & \bf 4 & 1100 & \bf C\\
- 101 & \bf 5 & 0101 & \bf 5 & 1101 & \bf D\\
- 110 & \bf 6 & 0110 & \bf 6 & 1110 & \bf E\\
- 111 & \bf 7 & 0111 & \bf 7 & 1111 & \bf F\\
- \end{tabular}
-
- \medskip
-
- \begin{itemize}
- \item
- Oktal- und Hexadezimalzahlen lassen sich ziffernweise\\
- in Binär-Zahlen umrechnen.
- \item
- Hexadezimalzahlen sind eine Kurzschreibweise für Binärzahlen,\\
- gruppiert zu jeweils 4 Bits.
- \item
- Oktalzahlen sind eine Kurzschreibweise für Binärzahlen,\\
- gruppiert zu jeweils 3 Bits.
- \item
- Trotz Taschenrechner u.\,ä.\ lohnt es sich,\\
- die o.\,a.\ Umrechnungstabelle \textbf{auswendig} zu kennen.
- \end{itemize}
-
-\end{frame}
-
-\subsubsection{Bit-Operationen in C}
-
-\begin{frame}[fragile]
-
- \showsubsubsection
-
- \begin{tabular}{lll}
- C-Operator & Verknüpfung & Anwendung \\[\smallskipamount]
- \lstinline,&, & Und & Bits gezielt löschen \\
- \lstinline,|, & Oder & Bits gezielt setzen \\
- \lstinline,^, & Exklusiv-Oder & Bits gezielt invertieren \\
- \lstinline,~, & Nicht & Alle Bits invertieren \\[\smallskipamount]
- \lstinline,<<, & Verschiebung nach links & Maske generieren \\
- \lstinline,>>, & Verschiebung nach rechts & Bits isolieren
- \end{tabular}
-
- \bigskip
-
- Numerierung der Bits: von rechts ab 0
-
- \medskip
-
- \begin{tabular}{ll}
- Bit Nr.\ 3 auf 1 setzen: &
- \lstinline,a |= 1 << 3;, \\
- Bit Nr.\ 4 auf 0 setzen: &
- \lstinline,a &= ~(1 << 4);, \\
- Bit Nr.\ 0 invertieren: &
- \lstinline,a ^= 1 << 0;,
- \end{tabular}
-
- \smallskip
-
- ~~Abfrage, ob Bit Nr.\ 1 gesetzt ist:\quad
- \lstinline{if (a & (1 << 1))}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsubsection
-
- C-Datentypen für Bit-Operationen:
- \smallskip\par
- \lstinline{#include <stdint.h>}
- \medskip\par
- \begin{tabular}{lllll}
- & 8 Bit & 16 Bit & 32 Bit & 64 Bit \\
- mit Vorzeichen & \lstinline,int8_t,
- & \lstinline,int16_t,
- & \lstinline,int32_t,
- & \lstinline,int64_t, \\
- ohne Vorzeichen & \lstinline,uint8_t,
- & \lstinline,uint16_t,
- & \lstinline,uint32_t,
- & \lstinline,uint64_t,
- \end{tabular}
-
- \bigskip
- \bigskip
-
- Ausgabe:
- \smallskip\par
- \begin{lstlisting}
- #include <stdio.h>
- #include <stdint.h>
- #include <inttypes.h>
- ...
- uint64_t x = 42;
- printf ("Die Antwort lautet: %" PRIu64 "\n", x);
- \end{lstlisting}
-
-\end{frame}
-
-\subsection{I/O-Ports}
-
-\begin{frame}[fragile]
-
-% \showsection
- \showsubsection
- \vspace*{-1.5\medskipamount}
- {\large\textbf{\color{structure}4.3\quad Interrupts}}
-
- \bigskip
-
- Kommunikation mit externen Geräten
-
- \bigskip
-
- \begin{center}
- \includegraphics{io-ports-and-interrupts.pdf}
- \end{center}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- In Output-Port schreiben = Aktoren ansteuern
-
- Beispiel: LED
-
- \medskip
-
- \begin{lstlisting}
- #include <avr/io.h>
- ...
- DDRC = 0x70;
- PORTC = 0x40;
- \end{lstlisting}
- \begin{picture}(0,0)
- \put(3,0.67){\begin{minipage}{3cm}
- \color{red}%
- binär: 0111\,0000\\
- binär: 0100\,0000
- \end{minipage}}
- \put(10,0.67){\makebox(0,0)[r]{\color{red}Herstellerspezifisch!}}
- \end{picture}
-
- \bigskip
-
- \lstinline{DDR} = Data Direction Register\\
- Bit = 1 für Output-Port\\
- Bit = 0 für Input-Port
-
- \bigskip
-
- \emph{Details: siehe Datenblatt und Schaltplan}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Aus Input-Port lesen = Sensoren abfragen
-
- Beispiel: Taster
-
- \medskip
-
- \begin{lstlisting}
- #include <avr/io.h>
- ...
- DDRC = 0xfd;
- while ((PINC & 0x02) == 0)
- ; /* just wait */
- \end{lstlisting}
- \begin{picture}(0,0)(-1.5,-0.42)
- \put(3,0.67){\begin{minipage}{3cm}
- \color{red}%
- binär: 1111\,1101\\
- binär: 0000\,0010
- \end{minipage}}
- \put(10,0.67){\makebox(0,0)[r]{\color{red}Herstellerspezifisch!}}
- \end{picture}
-
- \bigskip
-
- \lstinline{DDR} = Data Direction Register\\
- Bit = 1 für Output-Port\\
- Bit = 0 für Input-Port
-
- \bigskip
-
- \emph{Details: siehe Datenblatt und Schaltplan}
-
- \bigskip
-
- Praktikumsaufgabe: Druckknopfampel
-
-\end{frame}
-
-\subsection{Interrupts}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Externes Gerät ruft (per Stromsignal) Unterprogramm auf
-
- Zeiger hinterlegen: "`Interrupt-Vektor"'
-
- Beispiel: eingebaute Uhr\hfill
- \makebox(0,0)[tr]{%
- \only<1->{\begin{minipage}[t]{4.7cm}
- \vspace*{-0.3cm}%
- statt Zählschleife (\lstinline{_delay_ms}):\\
- Hauptprogramm kann\\
- andere Dinge tun
- \end{minipage}}%
- }
-
- \medskip
-
- \begin{lstlisting}
- #include <avr/interrupt.h>
-
- ...
-
-
- ISR (TIMER0B_COMP_vect)
- {
- PORTD ^= 0x40;
- }
- \end{lstlisting}
- \begin{picture}(0,0)
- \color{red}
- \put(1.9,3.1){\makebox(0,0)[tr]{\tikz{\draw[-latex](0,0)--(-1.4,-1.0);}}}
- \put(2.0,3.2){\makebox(0,0)[l]{"`Dies ist ein Interrupt-Handler."'}}
- \put(2.3,2.6){\makebox(0,0)[tr]{\tikz{\draw[-latex](0,0)--(-0.6,-0.55);}}}
- \put(2.4,2.6){\makebox(0,0)[l]{Interrupt-Vektor darauf zeigen lassen}}
- \end{picture}
-
- Initialisierung über spezielle Ports:
- \lstinline{TCCR0B}, \lstinline{TIMSK0}
-
- \bigskip
-
- \emph{Details: siehe Datenblatt und Schaltplan}
-
- \vspace*{-2.5cm}\hfill
- {\color{red}Herstellerspezifisch!}%
- \hspace*{1cm}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Externes Gerät ruft (per Stromsignal) Unterprogramm auf
-
- Zeiger hinterlegen: "`Interrupt-Vektor"'
-
- Beispiel: Taster\hfill
- \makebox(0,0)[tr]{%
- \begin{minipage}[t]{4.7cm}
- \vspace*{-0.3cm}%
- statt \newterm{Busy Waiting\/}:\\
- Hauptprogramm kann\\
- andere Dinge tun
- \end{minipage}}
-
- \medskip
-
- \begin{lstlisting}
- #include <avr/interrupt.h>
- ...
-
- ISR (INT0_vect)
- {
- PORTD ^= 0x40;
- }
- \end{lstlisting}
-
- \medskip
-
- Initialisierung über spezielle Ports:
- \lstinline{EICRA}, \lstinline{EIMSK}
-
- \bigskip
-
- \emph{Details: siehe Datenblatt und Schaltplan}
-
- \vspace*{-2.5cm}\hfill
- {\color{red}Herstellerspezifisch!}%
- \hspace*{1cm}
-
-\end{frame}
-
-\subsection{volatile-Variable}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Externes Gerät ruft (per Stromsignal) Unterprogramm auf
-
- Zeiger hinterlegen: "`Interrupt-Vektor"'
-
- Beispiel: Taster
-
- \vspace*{-2.5pt}
-
- \begin{minipage}[t]{5cm}
- \begin{onlyenv}<1>
- \begin{lstlisting}[gobble=8]
- ¡#include <avr/interrupt.h>
- ...
-
- uint8_t key_pressed = 0;
-
- ISR (INT0_vect)
- {
- key_pressed = 1;
- }¿
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<2>
- \begin{lstlisting}[gobble=8]
- ¡#include <avr/interrupt.h>
- ...
-
- volatile uint8_t key_pressed = 0;
-
- ISR (INT0_vect)
- {
- key_pressed = 1;
- }¿
- \end{lstlisting}
- \end{onlyenv}
- \end{minipage}\hfill
- \begin{minipage}[t]{6cm}
- \begin{lstlisting}[gobble=6]
- ¡int main (void)
- {
- ...
-
- while (1)
- {
- while (!key_pressed)
- ; /* just wait */
- PORTD ^= 0x40;
- key_pressed = 0;
- }
- return 0;
- }¿
- \end{lstlisting}
- \end{minipage}
-
- \pause
- \begin{picture}(0,0)
- \color{red}
- \put(10.3,4.0){\makebox(0,0)[b]{\begin{minipage}{6cm}
- \begin{center}
- \textbf{volatile}:\\
- Speicherzugriff\\
- nicht wegoptimieren
- \end{center}
- \end{minipage}}}
- \put(10.3,3.95){\makebox(0,0)[tr]{\tikz{\draw[-latex](0,0)--(-0.5,-0.9);}}}
- \end{picture}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Was ist eigentlich \lstinline{PORTD}?
-
- \bigskip
- \pause
-
- \lstinline[style=cmd]{avr-gcc -Wall -Os -mmcu=atmega328p blink-3.c -E}
-
- \bigskip
- \pause
- \lstinline{PORTD = 0x01;}\\
- \textarrow\quad
- \lstinline[style=terminal]{(*(volatile uint8_t *)((0x0B) + 0x20)) = 0x01;}\\
- \pause
- \begin{picture}(0,2)(0,-1.7)
- \color{red}
- \put(5.75,0.3){$\underbrace{\rule{2.95cm}{0pt}}_{\mbox{Zahl: \lstinline|0x2B|}}$}
- \pause
- \put(1.55,0.3){$\underbrace{\rule{4.0cm}{0pt}}_{\mbox{\shortstack[t]{Umwandlung in Zeiger\\
- auf \lstinline|volatile uint8_t|}}}$}
- \pause
- \put(1.32,-1){\makebox(0,0)[b]{\tikz{\draw[-latex](0,0)--(0,1.3)}}}
- \put(1.12,-1.1){\makebox(0,0)[tl]{Dereferenzierung des Zeigers}}
- \end{picture}
-
- \pause
- \textarrow\quad
- \lstinline|volatile uint8_t|-Variable an Speicheradresse \lstinline|0x2B|
-
- \pause
- \bigskip
- \bigskip
-
- \textarrow\quad
- \lstinline|PORTA = PORTB = PORTC = PORTD = 0| ist eine schlechte Idee.
-
-\end{frame}
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \begin{itemize}
- \item[4.1] Bit-Operationen
- \item[4.2] I/O-Ports
- \color{medgreen}
- \item[4.3] Interrupts
- \item[4.4] volatile-Variable
- \color{red}
- \item[4.5] Byte-Reihenfolge -- Endianness
- \color{black}
- \item[4.6] Binärdarstellung negativer Zahlen
- \item[4.7] Speicherausrichtung -- Alignment
- \end{itemize}
- \item[\textbf{5}] \textbf{Algorithmen}
- \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
- \item[\textbf{7}] \textbf{Datenstrukturen}
- \end{itemize}
-
-\end{frame}
-
-\subsection{Byte-Reihenfolge -- Endianness}
-\subsubsection{Konzept}
-
-\begin{frame}[fragile]
-
- \showsubsection
- \showsubsubsection
-
- Eine Zahl geht über mehrere Speicherzellen.\\
- Beispiel: 16-Bit-Zahl in 2 8-Bit-Speicherzellen
-
- \smallskip
-
- Welche Bits liegen wo?
-
- \pause
- \bigskip
-
- $1027 = 1024 + 2 + 1 = 0000\,0100\,0000\,0011_2 = 0403_{16}$
-
- \pause
- \bigskip
- Speicherzellen:
-
- \medskip
- \begin{tabular}{|c|c|l}\cline{1-2}
- \raisebox{-0.25ex}{04} & \raisebox{-0.25ex}{03} & \strut Big-Endian "`großes Ende zuerst"' \\\cline{1-2}
- \multicolumn{2}{c}{} & \pause für Menschen leichter lesbar \pause \\
- \multicolumn{3}{c}{} \\[-5pt]\cline{1-2}
- \raisebox{-0.25ex}{03} & \raisebox{-0.25ex}{04} & \strut Little-Endian "`kleines Ende zuerst"' \\\cline{1-2}
- \multicolumn{2}{c}{} & \pause bei Additionen effizienter
- \end{tabular}
-
- \pause
- \medskip
- \textarrow\ Geschmackssache
- \pause\\
- \quad\textbf{\dots\ außer bei Datenaustausch!}
-
-% \pause
-% \bigskip
-%
-% Aber: nicht verwechseln! \qquad $0304_{16} = 772$
-
-\end{frame}
-
-\begin{frame}
-
- \showsubsection
- \showsubsubsection
-
- Eine Zahl geht über mehrere Speicherzellen.\\
- Beispiel: 16-Bit-Zahl in 2 8-Bit-Speicherzellen
-
- \smallskip
-
- Welche Bits liegen wo?
-
- \medskip
-
- \textarrow\ Geschmackssache\\
- \textbf{\dots\ außer bei Datenaustausch!}
-
- \begin{itemize}
- \item
- Dateiformate
- \item
- Datenübertragung
- \end{itemize}
-
-\end{frame}
-
-\subsubsection{Dateiformate}
-
-\begin{frame}
-
- \showsubsection
- \showsubsubsection
-
- Audio-Formate: Reihenfolge der Bytes in 16- und 32-Bit-Zahlen
- \begin{itemize}
- \item
- RIFF-WAVE-Dateien (\file{.wav}): Little-Endian
- \item
- Au-Dateien (\file{.au}): Big-Endian
- \pause
- \item
- ältere AIFF-Dateien (\file{.aiff}): Big-Endian
- \item
- neuere AIFF-Dateien (\file{.aiff}): Little-Endian
- \end{itemize}
-
- \pause
- \bigskip
-
- Grafik-Formate: Reihenfolge der Bits in den Bytes
- \begin{itemize}
- \item
- PBM-Dateien: Big-Endian\only<4->{, MSB first}
- \item
- XBM-Dateien: Little-Endian\only<4->{, LSB first}
- \end{itemize}
- \only<4->{MSB/LSB = most/least significant bit}
-
-\end{frame}
-
-\iffalse
-
-\subsubsection{Datenübertragung}
-
-\begin{frame}
-
- \showsubsection
- \showsubsubsection
-
- \begin{itemize}
- \item
- RS-232 (serielle Schnittstelle): LSB first
- \item
- I$^2$C: MSB first
- \item
- USB: beides
- \pause
- \medskip
- \item
- Ethernet: LSB first
- \item
- TCP/IP (Internet): Big-Endian
- \end{itemize}
-
-\end{frame}
-
-\subsection{Binärdarstellung negativer Zahlen}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Speicher ist begrenzt!\\
- \textarrow\ feste Anzahl von Bits
-
- \medskip
-
- 8-Bit-Zahlen ohne Vorzeichen: \lstinline{uint8_t}\\
- \textarrow\ Zahlenwerte von \lstinline{0x00} bis \lstinline{0xff} = 0 bis 255\\
- \pause
- \textarrow\ 255 + 1 = 0
-
- \pause
- \medskip
-
- 8-Bit-Zahlen mit Vorzeichen: \lstinline{int8_t}\\
- \lstinline{0xff} = 255 ist die "`natürliche"' Schreibweise für $-1$.\\
- \pause
- \textarrow\ Zweierkomplement
-
- \pause
- \medskip
-
- Oberstes Bit = 1: negativ\\
- Oberstes Bit = 0: positiv\\
- \textarrow\ 127 + 1 = $-128$
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Speicher ist begrenzt!\\
- \textarrow\ feste Anzahl von Bits
-
- \medskip
-
- 16-Bit-Zahlen ohne Vorzeichen:
- \lstinline{uint16_t}\hfill\lstinline{uint8_t}\\
- \textarrow\ Zahlenwerte von \lstinline{0x0000} bis \lstinline{0xffff}
- = 0 bis 65535\hfill 0 bis 255\\
- \textarrow\ 65535 + 1 = 0\hfill 255 + 1 = 0
-
- \medskip
-
- 16-Bit-Zahlen mit Vorzeichen:
- \lstinline{int16_t}\hfill\lstinline{int8_t}\\
- \lstinline{0xffff} = 66535 ist die "`natürliche"' Schreibweise für $-1$.\hfill
- \lstinline{0xff} = 255 = $-1$\\
- \textarrow\ Zweierkomplement
-
- \medskip
-
- Oberstes Bit = 1: negativ\\
- Oberstes Bit = 0: positiv\\
- \textarrow\ 32767 + 1 = $-32768$
-
- \bigskip
- Literatur: \url{http://xkcd.com/571/}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Frage: \emph{Für welche Zahl steht der Speicherinhalt\,
- \raisebox{2pt}{%
- \tabcolsep0.25em
- \begin{tabular}{|c|c|}\hline
- \rule{0pt}{11pt}a3 & 90 \\\hline
- \end{tabular}}
- (hexadezimal)?}
-
- \pause
- \smallskip
- Antwort: \emph{Das kommt darauf an.} ;--)
-
- \pause
- \medskip
- Little-Endian:
-
- \smallskip
-
- \begin{tabular}{lrl}
- als \lstinline,int8_t,: & $-93$ & (nur erstes Byte)\\
- als \lstinline,uint8_t,: & $163$ & (nur erstes Byte)\\
- als \lstinline,int16_t,: & $-28509$\\
- als \lstinline,uint16_t,: & $37027$\\
- \lstinline,int32_t, oder größer: & $37027$
- & (zusätzliche Bytes mit Nullen aufgefüllt)
- \end{tabular}
-
- \pause
- \medskip
- Big-Endian:
-
- \smallskip
-
- \begin{tabular}{lrl}
- als \lstinline,int8_t,: & $-93$ & (nur erstes Byte)\\
- als \lstinline,uint8_t,: & $163$ & (nur erstes Byte)\\
- als \lstinline,int16_t,: & $-23664$\\
- als \lstinline,uint16_t,: & $41872$\\ als \lstinline,int32_t,: & $-1550843904$ & (zusätzliche Bytes\\
- als \lstinline,uint32_t,: & $2744123392$ & mit Nullen aufgefüllt)\\
- als \lstinline,int64_t,: & $-6660823848880963584$\\
- als \lstinline,uint64_t,: & $11785920224828588032$\\
- \end{tabular}
-
- \vspace*{-1cm}
-
-\end{frame}
-
-\subsection{Speicherausrichtung -- Alignment}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{lstlisting}
- #include <stdint.h>
-
- uint8_t a;
- uint16_t b;
- uint8_t c;
- \end{lstlisting}
-
- \pause
- \bigskip
-
- Speicheradresse durch 2 teilbar -- "`16-Bit-Alignment"'
- \begin{itemize}
- \item
- 2-Byte-Operation: effizienter
- \pause
- \item
- \dots\ oder sogar nur dann erlaubt
- \pause
- \arrowitem
- Compiler optimiert Speicherausrichtung
- \end{itemize}
-
- \medskip
-
- \pause
- \begin{minipage}{3cm}
- \begin{lstlisting}[gobble=6]
- ¡uint8_t a;
- uint8_t dummy;
- uint16_t b;
- uint8_t c;¿
- \end{lstlisting}
- \end{minipage}
- \pause
- \begin{minipage}{3cm}
- \begin{lstlisting}[gobble=6]
- ¡uint8_t a;
- uint8_t c;
- uint16_t b;¿
- \end{lstlisting}
- \end{minipage}
-
- \pause
- \vspace{-1.75cm}
- \strut\hfill
- \begin{minipage}{6.5cm}
- Fazit:
- \begin{itemize}
- \item
- \textbf{Adressen von Variablen\\
- sind systemabhängig}
- \item
- Bei Definition von Datenformaten\\
- Alignment beachten \textarrow\ effizienter
- \end{itemize}
- \end{minipage}
-
-\end{frame}
-
-\fi
-
-\end{document}
diff --git a/20221107/hp-musterloesung-20221107.pdf b/20221107/hp-musterloesung-20221107.pdf
deleted file mode 100644
index 1800b1be645e13b5540dfa4917c13e99038f6a7d..0000000000000000000000000000000000000000
Binary files a/20221107/hp-musterloesung-20221107.pdf and /dev/null differ
diff --git a/20221107/hp-musterloesung-20221107.tex b/20221107/hp-musterloesung-20221107.tex
deleted file mode 100644
index 22e4b5e8bd3c2671c0fe3b09351dbe37339808b5..0000000000000000000000000000000000000000
--- a/20221107/hp-musterloesung-20221107.tex
+++ /dev/null
@@ -1,447 +0,0 @@
-% hp-musterloesung-20221031.pdf - Solutions to the Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Ausgabe von Hexadezimalzahlen, Länge von Strings, LED-Blinkmuster
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\begin{document}
-
- \section*{Hardwarenahe Programmierung\\
- Musterlösung zu den Übungsaufgaben -- 7.\ November 2022}
-
- \exercise{Ausgabe von Hexadezimalzahlen}
-
- Schreiben Sie eine Funktion \lstinline{void print_hex (uint32_t x)},
- die eine gegebene vorzeichenlose 32-Bit-Ganzzahl \lstinline{x}
- als Hexadezimalzahl ausgibt.
- (Der Datentyp \lstinline{uint32_t} ist mit \lstinline{#include <stdint.h>} verfügbar.)
-
- Verwenden Sie dafür \emph{nicht\/} \lstinline{printf()} mit
- der Formatspezifikation \lstinline{%x} als fertige Lösung,
- sondern programmieren Sie die nötige Ausgabe selbst.
- (Für Tests ist \lstinline{%x} hingegen erlaubt und sicherlich nützlich.)
-
- Die Verwendung von \lstinline{printf()}
- mit anderen Formatspezifikationen wie z.\,B.\ \lstinline{%d}
- oder \lstinline{%c} oder \lstinline{%s} ist hingegen zulässig.
-
- \points{8}
-
- (Hinweis für die Klausur: Abgabe auf Datenträger ist erlaubt und erwünscht,
- aber nicht zwingend.)
-
- \solution
-
- Um die Ziffern von \lstinline{x} zur Basis 16 zu isolieren,
- berechnen wir \lstinline{x % 16} (modulo 16 = Rest bei Division durch 16)
- und dividieren anschließend \lstinline{x} durch 16,
- solange bis \lstinline{x} den Wert 0 erreicht.
-
- Wenn wir die auf diese Weise ermittelten Ziffern direkt ausgeben,
- sind sie \emph{Little-Endian}, erscheinen also in umgekehrter Reihenfolge.
- Die Datei \gitfile{hp}{2022ws/20221107}{loesung-1-1.c} setzt diesen Zwischenschritt um.
-
- Die Ausgabe der Ziffern erfolgt in \gitfile{hp}{2022ws/20221107}{loesung-1-1.c}
- über \lstinline{printf ("%d")}
- für die Ziffern 0 bis 9. Für die darüberliegenden Ziffern
- wird der Buchstabe \lstinline{a} um die Ziffer abzüglich 10 inkrementiert
- und der erhaltene Wert mit \lstinline{printf ("%c")} als Zeichen ausgegeben.
-
- Um die umgekehrte Reihenfolge zu beheben,
- speichern wir die Ziffern von \lstinline{x}
- in einem Array \lstinline{digits[]} zwischen
- und geben sie anschließend in einer zweiten Schleife
- in umgekehrter Reihenfolge aus (siehe \gitfile{hp}{2022ws/20221107}{loesung-1-2.c}).
- Da wir wissen, daß \lstinline{x} eine 32-Bit-Zahl ist
- und daher höchstens 8 Hexadezimalziffern haben kann,
- ist 8 eine sinnvolle Länge für das Ziffern-Array \lstinline{digits[8]}.
-
- Nun sind die Ziffern in der richtigen Reihenfolge,
- aber wir erhalten zusätzlich zu den eigentlichen Ziffern führende Nullen.
- Da in der Aufgabenstellung nicht von führenden Nullen die Rede war,
- sind diese nicht verboten; \gitfile{hp}{2022ws/20221107}{loesung-1-2.c} ist daher
- eine richtige Lösung der Aufgabe.
-
- \breath
-
- Wenn wir die führenden Nullen vermeiden wollen,
- können wir die \lstinline{for}-Schleifen durch \lstinline{while}-Schleifen ersetzen.
- Die erste Schleife zählt hoch, solange \lstinline{x} ungleich 0 ist;
- die zweite zählt von dem erreichten Wert aus wieder herunter
- -- siehe \gitfile{hp}{2022ws/20221107}{loesung-1-3.c}.
- Da wir wissen, daß die Zahl \lstinline{x} höchstens 32 Bit,
- also höchstens 8 Hexadezimalziffern hat,
- wissen wir, daß \lstinline{i} höchstens den Wert 8 erreichen kann,
- das Array also nicht überlaufen wird.
-
- Man beachte, daß der Array-Index nach der ersten Schleife "`um einen zu hoch"' ist.
- In der zweiten Schleife muß daher \emph{zuerst\/} der Index dekrementiert werden.
- Erst danach darf ein Zugriff auf \lstinline{digit[i]} erfolgen.
-
- \breath
-
- Alternativ können wir auch mitschreiben,
- ob bereits eine Ziffer ungleich Null ausgegeben wurde,
- und andernfalls die Ausgabe von Null-Ziffern unterdrücken
- -- siehe \gitfile{hp}{2022ws/20221107}{loesung-1-4.c}.
-
- \breath
-
- Weitere Möglichkeiten ergeben sich, wenn man bedenkt,
- daß eine Hexadezimalziffer genau einer Gruppe von vier Binärziffern entspricht.
- Eine Bitverschiebung um 4 nach rechts
- ist daher dasselbe wie eine Division durch 16,
- und eine Und-Verknüpfung mit 15$_{10}$ = f$_{16}$ = 1111$_2$
- ist dasselbe wie die Operation Modulo 16.
- Die Datei \gitfile{hp}{2022ws/20221107}{loesung-1-5.c} ist eine in dieser Weise abgewandelte Variante
- von \gitfile{hp}{2022ws/20221107}{loesung-1-3.c}.
-
- Mit dieser Methode kann man nicht nur auf die jeweils unterste Ziffer,
- sondern auf alle Ziffern direkt zugreifen.
- Damit ist kein Array als zusätzlicher Speicher mehr nötig.
- Die Datei \gitfile{hp}{2022ws/20221107}{loesung-1-6.c} setzt dies auf einfache Weise um.
- Sie gibt wieder führende Nullen mit aus,
- ist aber trotzdem eine weitere richtige Lösung der Aufgabe.
-
- Die führenden Nullen ließen sich auf die gleiche Weise vermeiden
- wie in \gitfile{hp}{2022ws/20221107}{loesung-1-4.c}.
-
- Die Bitverschiebungsmethode hat den Vorteil,
- daß kein zusätzliches Array benötigt wird.
- Auch wird die als Parameter übergebene Zahl \lstinline{x} nicht verändert,
- was bei größeren Zahlen, die über Zeiger übergeben werden, von Vorteil sein kann.
- Demgegenüber steht der Nachteil,
- daß diese Methode nur für eine ganze Anzahl von Bits funktioniert,
- also für Basen, die Zweierpotenzen sind (z.\,B.\ 2, 8, 16, 256).
- Für alle anderen Basen (z.\,B.\ 10) eignet sich nur die Methode
- mit Division und Modulo-Operation.
-
- \exercise{Länge von Strings}
-
- Strings werden in der Programmiersprache C durch Zeiger auf \lstinline{char}-Variable realisiert.
-
- Beispiel: \lstinline{char *hello_world = "Hello, world!\n"}
-
- Die Systembibliothek stellt eine Funktion \lstinline{strlen()} zur Ermittlung der Länge von Strings\\
- zur Verfügung (\lstinline{#include <string.h>}).
-
- \begin{itemize}
- \item[(a)]
- Auf welche Weise ist die Länge eines Strings gekennzeichnet?
- \points{1}
- \item[(b)]
- Wie lang ist die Beispiel-String-Konstante \lstinline{"Hello, world!\n"},
- und wieviel Speicherplatz belegt sie?\\
- \points{2}
- \item[(c)]
- Schreiben Sie eine eigene Funktion \lstinline{int strlen (char *s)},
- die die Länge eines Strings zurückgibt.\\
- \points{3}
- \end{itemize}
-
- Wir betrachten nun die folgenden Funktionen (Datei: \gitfile{hp}{2022ws/20221107}{aufgabe-2.c}):
- \begin{center}
- \begin{minipage}{8cm}
- \begin{lstlisting}[gobble=8]
- int fun_1 (char *s)
- {
- int x = 0;
- for (int i = 0; i < strlen (s); i++)
- x += s[i];
- return x;
- }
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}{6cm}
- \vspace*{-1cm}
- \begin{lstlisting}[gobble=8]
- int fun_2 (char *s)
- {
- int i = 0, x = 0;
- int len = strlen (s);
- while (i < len)
- x += s[i++];
- return x;
- }
- \end{lstlisting}
- \vspace*{-1cm}
- \end{minipage}
- \end{center}
- \begin{itemize}
- \item[(d)]
- Was bewirken die beiden Funktionen?
- \points{2}
- \item[(e)]
-% Von welcher Ordnung (Landau-Symbol) sind die beiden Funktionen
-% hinsichtlich der Anzahl ihrer Zugriffe auf die Zeichen im String -- und warum?
-% Sie dürfen für \lstinline{strlen()} Ihre eigene Version der Funktion voraussetzen.
-% \points 3
-% \item[(f)]
- Schreiben Sie eine eigene Funktion,
- die dieselbe Aufgabe erledigt wie \lstinline{fun_2()},\\
- nur effizienter.
- \points{4}
- \end{itemize}
-
- \solution
-
- \begin{itemize}
- \item[(a)]
- \textbf{Auf welche Weise ist die Länge eines Strings gekennzeichnet?}
-
- Ein String ist ein Array von \lstinline{char}s.
- Nach den eigentlichen Zeichen des Strings enthält das Array
- \textbf{ein Null-Symbol} (Zeichen mit Zahlenwert 0,
- nicht zu verwechseln mit der Ziffer \lstinline{'0'}) als Ende-Markierung.
- Die Länge eines Strings ist die Anzahl der Zeichen
- \emph{vor\/} diesem Symbol.
-
- \item[(b)]
- {\bf Wie lang ist die Beispiel-String-Konstante \lstinline{"Hello, world!\n"},
- und wieviel Speicherplatz belegt sie?}
-
- Sie ist 14 Zeichen lang (\lstinline{'\n'} ist nur 1 Zeichen;
- das Null-Symbol, das das Ende markiert, zählt hier nicht mit)
- und belegt Speicherplatz für 15 Zeichen
- (15 Bytes -- einschließlich Null-Symbol / Ende-Markierung).
-
- \item[(c)]
- \textbf{Schreiben Sie eine eigene Funktion \lstinline{int strlen (char *s)},
- die die Länge eines Strings zurückgibt.}
-
- Siehe die Dateien \gitfile{hp}{2022ws/20221107}{loesung-2c-1.c} (mit Array-Index)
- und \gitfile{hp}{2022ws/20221107}{loesung-2c-2.c} (mit Zeiger-Arithmetik).
- Beide Lösungen sind korrekt und arbeiten gleich schnell.
-
- Die Warnung \lstinline[style=terminal]{conflicting types for built-in function "strlen"}
- kann normalerweise ignoriert werden;
- auf manchen Systemen (z.\,B.\ MinGW) hat jedoch die eingebaute Funktion \lstinline{strlen()}
- beim Linken Vorrang vor der selbstgeschriebenen,
- so daß die selbstgeschriebene Funktion nie aufgerufen wird.
- In solchen Fällen ist es zulässig, die selbstgeschriebene Funktion
- anders zu nennen (z.\,B.\ \lstinline{my_strlen()}).
-
- \item[(d)]
- \textbf{Was bewirken die beiden Funktionen?}
-
- Beide addieren die Zahlenwerte der im String enthaltenen Zeichen
- und geben die Summe als Funktionsergebnis zurück.
-
- Im Falle des Test-Strings \lstinline{"Hello, world!\n"}
- lautet der Rückgabewert 1171 (siehe \gitfile{hp}{2022ws/20221107}{loesung-2d-1.c} und \gitfile{hp}{2022ws/20221107}{loesung-2d-2.c}).
-
- \item[(e)]
-% \textbf{Von welcher Ordnung (Landau-Symbol) sind die beiden Funktionen
-% hinsichtlich der Anzahl ihrer Zugriffe auf die Zeichen im String -- und warum?
-% Sie dürfen für \lstinline{strlen()} Ihre eigene Version der Funktion voraussetzen.}
-%
-% Vorüberlegung: \lstinline{strlen()} greift in einer Schleife
-% auf alle Zeichen des Strings der Länge $n$ zu,
-% hat also $\mathcal{O}(n)$.
-%
-% \lstinline{fun_1()} ruft in jedem Schleifendurchlauf
-% (zum Prüfen der \lstinline{while}-Bedingung) einmal \lstinline{strlen()} auf
-% und greift anschließend auf ein Zeichen des Strings zu,
-% hat also $\mathcal{O}\bigl(n\cdot(n+1)\bigr) = \mathcal{O}(n^2)$.
-%
-% \lstinline{fun_2()} ruft einmalig \lstinline{strlen()} auf
-% und greift anschließend in einer Schleife auf alle Zeichen des Strings zu,
-% hat also $\mathcal{O}(n+n) = \mathcal{O}(n)$.
-%
-% \item[(f)]
- \textbf{Schreiben Sie eine eigene Funktion,
- die dieselbe Aufgabe erledigt wie \lstinline{fun_2()},
- nur effizienter.}
-
- Die Funktion wird effizienter,
- wenn man auf den Aufruf von \lstinline{strlen()} verzichtet
- und stattdessen die Ende-Prüfung in derselben Schleife vornimmt,
- in der man auch die Zahlenwerte der Zeichen des Strings aufsummiert.
-
- Die Funktion \lstinline{fun_3()} in der Datei \gitfile{hp}{2022ws/20221107}{loesung-2e-1.c}
- realisiert dies mit einem Array-Index,
- Die Funktion \lstinline{fun_4()} in der Datei \gitfile{hp}{2022ws/20221107}{loesung-2e-2.c}
- mit Zeiger-Arithmetik.
- Beide Lösungen sind korrekt und arbeiten gleich schnell.
-
-% \textbf{Bemerkung:} Die effizientere Version der Funktion
-% arbeitet doppelt so schnell wie die ursprüngliche,
-% hat aber ebenfalls die Ordnung $\mathcal{O}(n)$.
-
- \end{itemize}
-
- \exercise{LED-Blinkmuster}
-
- Wir betrachten das folgende Programm für einen ATmega32-Mikro-Controller
- (Datei: \gitfile{hp}{2022ws/20221107}{aufgabe-3.c}).
-
- \begin{minipage}[t]{7cm}
- \begin{lstlisting}[gobble=6]
- #include <stdint.h>
- #include <avr/io.h>
- #include <avr/interrupt.h>
-
- uint8_t counter = 1;
- uint8_t leds = 0;
-
- ISR (TIMER0_COMP_vect)
- {
- if (counter == 0)
- {
- leds = (leds + 1) % 8;
- PORTC = leds << 4;
- }
- counter++;
- }
- \end{lstlisting}
- \end{minipage}\hfill\begin{minipage}[t]{8.5cm}
- \begin{lstlisting}[gobble=6]
- void init (void)
- {
- cli ();
- TCCR0 = (1 << CS01) | (1 << CS00);
- TIMSK = 1 << OCIE0;
- sei ();
- DDRC = 0x70;
- }
-
- int main (void)
- {
- init ();
- while (1)
- ; /* do nothing */
- return 0;
- }
- \end{lstlisting}
- \end{minipage}
-
- An die Bits Nr.\ 4, 5 und 6 des Output-Ports C des Mikro-Controllers sind LEDs angeschlossen.\\
- Sobald das Programm läuft, blinken diese in charakteristischer Weise:
- \begin{quote}
- \newcommand{\tdn}[1]{\raisebox{-2pt}{#1}}
- \begin{tabular}{|c|c|c|c|}\hline
- \tdn{Phase} & \tdn{LED oben (rot)} & \tdn{LED Mitte (gelb)} & \tdn{LED unten (grün)} \\[2pt]\hline
- 1 & aus & aus & an \\\hline
- 2 & aus & an & aus \\\hline
- 3 & aus & an & an \\\hline
- 4 & an & aus & aus \\\hline
- 5 & an & aus & an \\\hline
- 6 & an & an & aus \\\hline
- 7 & an & an & an \\\hline
- 8 & aus & aus & aus \\\hline
- \end{tabular}
- \end{quote}
- Jede Phase dauert etwas länger als eine halbe Sekunde.
- Nach 8 Phasen wiederholt sich das Schema.
-
- Erklären Sie das Verhalten des Programms anhand des Quelltextes:
- \vspace{-\medskipamount}
- \begin{itemize}\itemsep0pt
- \item[(a)]
- Wieso macht das Programm überhaupt etwas,
- wenn doch das Hauptprogramm nach dem Initialisieren lediglich eine Endlosschleife ausführt,
- in der \emph{nichts} passiert?
- \points{1}
- \item[(b)]
- Wieso wird die Zeile \lstinline|PORTC = leds << 4;| überhaupt aufgerufen,
- wenn dies doch nur unter der Bedingung \lstinline|counter == 0| passiert,
- wobei die Variable \lstinline|counter| auf 1 initialisiert,
- fortwährend erhöht und nirgendwo zurückgesetzt wird?
- \points{2}
- \item[(c)]
- Wie kommt das oben beschriebene Blinkmuster zustande?
- \points{2}
- \item[(d)]
- Wieso dauert eine Phase ungefähr eine halbe Sekunde?
- \points{2}
- \item[(e)]
- Was bedeutet "`\lstinline|ISR (TIMER0_COMP_vect)|"'?
- \points{1}
- \end{itemize}
-
- \goodbreak
- Hinweis:
- \vspace{-\medskipamount}
- \begin{itemize}\itemsep0pt
- \item
- Die Funktion \lstinline|init()| sorgt dafür, daß der Timer-Interrupt Nr.\ 0 des Mikro-Controllers
- etwa 488mal pro Sekunde aufgerufen wird.
- Außerdem initialisiert sie die benötigten Bits an Port C als Output-Ports.
- Sie selbst brauchen die Funktion \lstinline|init()| nicht weiter zu erklären.
- \end{itemize}
-
- \solution
-
- \begin{itemize}\itemsep0pt
- \item[(a)]
- \textbf{Wieso macht das Programm überhaupt etwas,
- wenn doch das Hauptprogramm nach dem Initialisieren lediglich eine Endlosschleife ausführt,
- in der \emph{nichts} passiert?}
-
- Das Blinken wird durch einen Interrupt-Handler implementiert.
- Dieser wird nicht durch das Hauptprogramm,
- sondern durch ein Hardware-Ereignis (hier: Uhr) aufgerufen.
-
- \item[(b)]
- \textbf{Wieso wird die Zeile \lstinline|PORTC = leds << 4;| überhaupt aufgerufen,
- wenn dies doch nur unter der Bedingung \lstinline|counter == 0| passiert,
- wobei die Variable \lstinline|counter| auf 1 initialisiert,
- fortwährend erhöht und nirgendwo zurückgesetzt wird?}
-
- Die vorzeichenlose 8-Bit-Variable \lstinline{counter} kann nur
- Werte von 0 bis 255 annehmen; bei einem weiteren
- Inkrementieren springt sie wieder auf 0 (Überlauf),
- und die \lstinline{if}-Bedingung ist erfüllt.
-
- \item[(c)]
- \textbf{Wie kommt das oben beschriebene Blinkmuster zustande?}
-
- In jedem Aufruf des Interrupt-Handlers wird die Variable
- \lstinline{leds} um 1 erhöht und anschließend modulo 8 genommen.
- Sie durchläuft daher immer wieder die Zahlen von 0 bis 7.
-
- Durch die Schiebeoperation \lstinline{leds << 4} werden die 3 Bits
- der Variablen \lstinline{leds} an diejenigen Stellen im Byte
- geschoben, an denen die LEDs an den Mikro-Controller
- angeschlossen sind (Bits 4, 5 und 6).
-
- Entsprechend durchläuft das Blinkmuster immer wieder
- die Binärdarstellungen der Zahlen von 0 bis 7
- (genauer: von 1 bis 7 und danach 0).
-
- \item[(d)]
- \textbf{Wieso dauert eine Phase ungefähr eine halbe Sekunde?}
-
- Der Interrupt-Handler wird gemäß Hinweis 488mal pro Sekunde aufgerufen.
- Bei jedem 256sten Aufruf ändert sich das LED-Muster.
- Eine Phase dauert somit $\frac{256}{488} \approx 0.52$ Sekunden.
-
- \item[(e)]
- \textbf{Was bedeutet "`\lstinline|ISR (TIMER0_COMP_vect)|"'?}
-
- Deklaration eines Interrupt-Handlers für den Timer-Interrupt Nr.\ 0
- \end{itemize}
-
-\end{document}
diff --git a/20221107/hp-uebung-20221107.pdf b/20221107/hp-uebung-20221107.pdf
deleted file mode 100644
index da415d10ebc69833dcb69539d57554e3abf18933..0000000000000000000000000000000000000000
Binary files a/20221107/hp-uebung-20221107.pdf and /dev/null differ
diff --git a/20221107/hp-uebung-20221107.tex b/20221107/hp-uebung-20221107.tex
deleted file mode 100644
index a2d90f5ef64065e0e6f6744604ae5e13ecdadf13..0000000000000000000000000000000000000000
--- a/20221107/hp-uebung-20221107.tex
+++ /dev/null
@@ -1,236 +0,0 @@
-% hp-uebung-20221107.pdf - Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Ausgabe von Hexadezimalzahlen, Länge von Strings, LED-Blinkmuster
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\begin{document}
-
- \thispagestyle{empty}
-
- \section*{Hardwarenahe Programmierung\\
- Übungsaufgaben -- 7.\ November 2022}
-
- Diese Übung enthält Punkteangaben wie in einer Klausur.
- Um zu "`bestehen"', müssen Sie innerhalb von 80 Minuten
- unter Verwendung ausschließlich zugelassener Hilfsmittel
- 14 Punkte (von insgesamt \totalpoints) erreichen.
-
- \exercise{Ausgabe von Hexadezimalzahlen}
-
- Schreiben Sie eine Funktion \lstinline{void print_hex (uint32_t x)},
- die eine gegebene vorzeichenlose 32-Bit-Ganzzahl \lstinline{x}
- als Hexadezimalzahl ausgibt.
- (Der Datentyp \lstinline{uint32_t} ist mit \lstinline{#include <stdint.h>} verfügbar.)
-
- Verwenden Sie dafür \emph{nicht\/} \lstinline{printf()} mit
- der Formatspezifikation \lstinline{%x} als fertige Lösung,
- sondern programmieren Sie die nötige Ausgabe selbst.
- (Für Tests ist \lstinline{%x} hingegen erlaubt und sicherlich nützlich.)
-
- Die Verwendung von \lstinline{printf()}
- mit anderen Formatspezifikationen wie z.\,B.\ \lstinline{%d}
- oder \lstinline{%c} oder \lstinline{%s} ist hingegen zulässig.
-
- \points{8}
-
- (Hinweis für die Klausur: Abgabe auf Datenträger ist erlaubt und erwünscht,
- aber nicht zwingend.)
-
- \exercise{Länge von Strings}
-
- Strings werden in der Programmiersprache C durch Zeiger auf \lstinline{char}-Variable realisiert.
-
- Beispiel: \lstinline{char *hello_world = "Hello, world!\n"}
-
- Die Systembibliothek stellt eine Funktion \lstinline{strlen()} zur Ermittlung der Länge von Strings\\
- zur Verfügung (\lstinline{#include <string.h>}).
-
- \begin{itemize}
- \item[(a)]
- Auf welche Weise ist die Länge eines Strings gekennzeichnet?
- \points{1}
- \item[(b)]
- Wie lang ist die Beispiel-String-Konstante \lstinline{"Hello, world!\n"},
- und wieviel Speicherplatz belegt sie?\\
- \points{2}
- \item[(c)]
- Schreiben Sie eine eigene Funktion \lstinline{int strlen (char *s)},
- die die Länge eines Strings zurückgibt.\\
- \points{3}
- \end{itemize}
-
- Wir betrachten nun die folgenden Funktionen (Datei: \gitfile{hp}{2022ws/20221107}{aufgabe-2.c}):
- \begin{center}
- \begin{minipage}{8cm}
- \begin{lstlisting}[gobble=8]
- int fun_1 (char *s)
- {
- int x = 0;
- for (int i = 0; i < strlen (s); i++)
- x += s[i];
- return x;
- }
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}{6cm}
- \vspace*{-1cm}
- \begin{lstlisting}[gobble=8]
- int fun_2 (char *s)
- {
- int i = 0, x = 0;
- int len = strlen (s);
- while (i < len)
- x += s[i++];
- return x;
- }
- \end{lstlisting}
- \vspace*{-1cm}
- \end{minipage}
- \end{center}
- \begin{itemize}
- \item[(d)]
- Was bewirken die beiden Funktionen?
- \points{2}
- \item[(e)]
-% Von welcher Ordnung (Landau-Symbol) sind die beiden Funktionen
-% hinsichtlich der Anzahl ihrer Zugriffe auf die Zeichen im String -- und warum?
-% Sie dürfen für \lstinline{strlen()} Ihre eigene Version der Funktion voraussetzen.
-% \points 3
-% \item[(f)]
- Schreiben Sie eine eigene Funktion,
- die dieselbe Aufgabe erledigt wie \lstinline{fun_2()},\\
- nur effizienter.
- \points{4}
- \end{itemize}
-
- \exercise{LED-Blinkmuster}
-
- Wir betrachten das folgende Programm für einen ATmega32-Mikro-Controller
- (Datei: \gitfile{hp}{2022ws/20221107}{aufgabe-3.c}).
-
- \begin{minipage}[t]{7cm}
- \begin{lstlisting}[gobble=6]
- #include <stdint.h>
- #include <avr/io.h>
- #include <avr/interrupt.h>
-
- uint8_t counter = 1;
- uint8_t leds = 0;
-
- ISR (TIMER0_COMP_vect)
- {
- if (counter == 0)
- {
- leds = (leds + 1) % 8;
- PORTC = leds << 4;
- }
- counter++;
- }
- \end{lstlisting}
- \end{minipage}\hfill\begin{minipage}[t]{8.5cm}
- \begin{lstlisting}[gobble=6]
- void init (void)
- {
- cli ();
- TCCR0 = (1 << CS01) | (1 << CS00);
- TIMSK = 1 << OCIE0;
- sei ();
- DDRC = 0x70;
- }
-
- int main (void)
- {
- init ();
- while (1)
- ; /* do nothing */
- return 0;
- }
- \end{lstlisting}
- \end{minipage}
-
- An die Bits Nr.\ 4, 5 und 6 des Output-Ports C des Mikro-Controllers sind LEDs angeschlossen.\\
- Sobald das Programm läuft, blinken diese in charakteristischer Weise:
- \begin{quote}
- \newcommand{\tdn}[1]{\raisebox{-2pt}{#1}}
- \begin{tabular}{|c|c|c|c|}\hline
- \tdn{Phase} & \tdn{LED oben (rot)} & \tdn{LED Mitte (gelb)} & \tdn{LED unten (grün)} \\[2pt]\hline
- 1 & aus & aus & an \\\hline
- 2 & aus & an & aus \\\hline
- 3 & aus & an & an \\\hline
- 4 & an & aus & aus \\\hline
- 5 & an & aus & an \\\hline
- 6 & an & an & aus \\\hline
- 7 & an & an & an \\\hline
- 8 & aus & aus & aus \\\hline
- \end{tabular}
- \end{quote}
- Jede Phase dauert etwas länger als eine halbe Sekunde.
- Nach 8 Phasen wiederholt sich das Schema.
-
- Erklären Sie das Verhalten des Programms anhand des Quelltextes:
- \vspace{-\medskipamount}
- \begin{enumerate}[\quad(a)]
- \item
- Wieso macht das Programm überhaupt etwas,
- wenn doch das Hauptprogramm nach dem Initialisieren lediglich eine Endlosschleife ausführt,
- in der \emph{nichts} passiert?
- \points{1}
- \item
- Wieso wird die Zeile \lstinline|PORTC = leds << 4;| überhaupt aufgerufen,
- wenn dies doch nur unter der Bedingung \lstinline|counter == 0| passiert,
- wobei die Variable \lstinline|counter| auf 1 initialisiert,
- fortwährend erhöht und nirgendwo zurückgesetzt wird?
- \points{2}
- \item
- Wie kommt das oben beschriebene Blinkmuster zustande?
- \points{2}
- \item
- Wieso dauert eine Phase ungefähr eine halbe Sekunde?
- \points{2}
- \item
- Was bedeutet "`\lstinline|ISR (TIMER0_COMP_vect)|"'?
- \points{1}
- \end{enumerate}
-
- Hinweis:
- \vspace{-\medskipamount}
- \begin{itemize}\itemsep0pt
- \item
- Die Funktion \lstinline|init()| sorgt dafür, daß der Timer-Interrupt Nr.\ 0 des Mikro-Controllers
- etwa 488mal pro Sekunde aufgerufen wird.
- Außerdem initialisiert sie die benötigten Bits an Port C als Output-Ports.
- Sie selbst brauchen die Funktion \lstinline|init()| nicht weiter zu erklären.
- \end{itemize}
-
- \begin{flushright}
- \textit{Viel Erfolg!}
- \end{flushright}
-
- \makeatletter
- \immediate\write\@mainaux{\string\gdef\string\totalpoints{\arabic{points}}}
- \makeatother
-
-\end{document}
diff --git a/20221107/io-ports-and-interrupts.pdf b/20221107/io-ports-and-interrupts.pdf
deleted file mode 120000
index bcd46f7afb35605b20bdb05637e6de0a039893ec..0000000000000000000000000000000000000000
--- a/20221107/io-ports-and-interrupts.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/io-ports-and-interrupts.pdf
\ No newline at end of file
diff --git a/20221107/loesung-1-1.c b/20221107/loesung-1-1.c
deleted file mode 100644
index 98b2f03f19d21aa2a794fef1f3f98feff95f5142..0000000000000000000000000000000000000000
--- a/20221107/loesung-1-1.c
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-void print_hex (uint32_t x)
-{
- while (x)
- {
- int digit = x % 16;
- if (digit < 10)
- printf ("%d", digit);
- else
- printf ("%c", 'a' + digit - 10);
- x /= 16;
- }
-}
-
-int main (void)
-{
- print_hex (0xcafe42);
- printf ("\n");
- return 0;
-}
diff --git a/20221107/loesung-1-2.c b/20221107/loesung-1-2.c
deleted file mode 100644
index 35aa3b3aea6fc8faaa55c7d5382f0a8de9282aee..0000000000000000000000000000000000000000
--- a/20221107/loesung-1-2.c
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-void print_hex (uint32_t x)
-{
- char digit[8];
- for (int i = 0; i < 8; i++)
- {
- digit[i] = x % 16;
- x /= 16;
- }
- for (int i = 7; i >= 0; i--)
- {
- if (digit[i] < 10)
- printf ("%d", digit[i]);
- else
- printf ("%c", 'a' + digit[i] - 10);
- }
-}
-
-int main (void)
-{
- print_hex (0xcafe42);
- printf ("\n");
- return 0;
-}
diff --git a/20221107/loesung-1-3.c b/20221107/loesung-1-3.c
deleted file mode 100644
index 2462f2b537896722d8d1774a5d47f374ee5ef7fa..0000000000000000000000000000000000000000
--- a/20221107/loesung-1-3.c
+++ /dev/null
@@ -1,29 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-void print_hex (uint32_t x)
-{
- char digit[8];
- int i = 0;
- while (x)
- {
- digit[i] = x % 16;
- x /= 16;
- i++;
- }
- while (i > 0)
- {
- i--;
- if (digit[i] < 10)
- printf ("%d", digit[i]);
- else
- printf ("%c", 'a' + digit[i] - 10);
- }
-}
-
-int main (void)
-{
- print_hex (0xcafe42);
- printf ("\n");
- return 0;
-}
diff --git a/20221107/loesung-1-4.c b/20221107/loesung-1-4.c
deleted file mode 100644
index 5083dcb865c86beafd43ce3e8837510b13cbe850..0000000000000000000000000000000000000000
--- a/20221107/loesung-1-4.c
+++ /dev/null
@@ -1,31 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-void print_hex (uint32_t x)
-{
- char digit[8];
- for (int i = 0; i < 8; i++)
- {
- digit[i] = x % 16;
- x /= 16;
- }
- int printing = 0;
- for (int i = 7; i >= 0; i--)
- {
- if (printing || digit[i] != 0)
- {
- printing = 1;
- if (digit[i] < 10)
- printf ("%d", digit[i]);
- else
- printf ("%c", 'a' + digit[i] - 10);
- }
- }
-}
-
-int main (void)
-{
- print_hex (0xcafe42);
- printf ("\n");
- return 0;
-}
diff --git a/20221107/loesung-1-5.c b/20221107/loesung-1-5.c
deleted file mode 100644
index e3446edb4a40348ac14da420f344c208f8916f7e..0000000000000000000000000000000000000000
--- a/20221107/loesung-1-5.c
+++ /dev/null
@@ -1,29 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-void print_hex (uint32_t x)
-{
- char digit[8];
- int i = 0;
- while (x)
- {
- digit[i] = x & 0x0000000f;
- x >>= 4;
- i++;
- }
- while (i > 0)
- {
- i--;
- if (digit[i] < 10)
- printf ("%d", digit[i]);
- else
- printf ("%c", 'a' + digit[i] - 10);
- }
-}
-
-int main (void)
-{
- print_hex (0xcafe42);
- printf ("\n");
- return 0;
-}
diff --git a/20221107/loesung-1-6.c b/20221107/loesung-1-6.c
deleted file mode 100644
index 7b8e8e1a9d7285b8a1e02ff1a91310f1dc02ed5b..0000000000000000000000000000000000000000
--- a/20221107/loesung-1-6.c
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-void print_hex (uint32_t x)
-{
- int i = 32;
- while (i > 0)
- {
- i -= 4;
- int digit = (x >> i) & 0x0000000f;
- if (digit < 10)
- printf ("%d", digit);
- else
- printf ("%c", 'a' + digit - 10);
- }
-}
-
-int main (void)
-{
- print_hex (0xcafe42);
- printf ("\n");
- return 0;
-}
diff --git a/20221107/loesung-2.c b/20221107/loesung-2.c
deleted file mode 100644
index 85abfcf3e1e4bacf454acd10f6832b757a64ac35..0000000000000000000000000000000000000000
--- a/20221107/loesung-2.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-void insert_into_string (char src, char *target, int pos)
-{
- int len = strlen (target);
- for (int i = len; i >= pos; i--)
- target[i + 1] = target[i];
- target[pos] = src;
-}
-
-int main (void)
-{
- char test[100] = "Hochshule Bochum";
- insert_into_string ('c', test, 5);
- printf ("%s\n", test);
- return 0;
-}
diff --git a/20221107/loesung-2c-1.c b/20221107/loesung-2c-1.c
deleted file mode 100644
index 69ddd0e4e749f6ca31bfa3d4f929c333648ef6ea..0000000000000000000000000000000000000000
--- a/20221107/loesung-2c-1.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int strlen (char *s)
-{
- int l = 0;
- while (s[l])
- l++;
- return l;
-}
-
-int main (void)
-{
- printf ("%d\n", strlen ("Hello, world!\n"));
- return 0;
-}
diff --git a/20221107/loesung-2c-2.c b/20221107/loesung-2c-2.c
deleted file mode 100644
index e783c474e485e80d08a6e86f8ae6e179f5a294f4..0000000000000000000000000000000000000000
--- a/20221107/loesung-2c-2.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int strlen (char *s)
-{
- char *s0 = s;
- while (*s)
- s++;
- return s - s0;
-}
-
-int main (void)
-{
- printf ("%d\n", strlen ("Hello, world!\n"));
- return 0;
-}
diff --git a/20221107/loesung-2d-1.c b/20221107/loesung-2d-1.c
deleted file mode 100644
index 57521382c21fb743c6f5f5c65320bc4ac9360b1a..0000000000000000000000000000000000000000
--- a/20221107/loesung-2d-1.c
+++ /dev/null
@@ -1,34 +0,0 @@
-
-#include <stdio.h>
-
-int strlen (char *s)
-{
- int l = 0;
- while (s[l])
- l++;
- return l;
-}
-
-int fun_1 (char *s)
-{
- int x = 0;
- for (int i = 0; i < strlen (s); i++)
- x += s[i];
- return x;
-}
-
-int fun_2 (char *s)
-{
- int i = 0, x = 0;
- int len = strlen (s);
- while (i < len)
- x += s[i++];
- return x;
-}
-
-int main (void)
-{
- printf ("%d\n", fun_1 ("Hello, world!\n"));
- printf ("%d\n", fun_2 ("Hello, world!\n"));
- return 0;
-}
diff --git a/20221107/loesung-2d-2.c b/20221107/loesung-2d-2.c
deleted file mode 100644
index 5f3f0961129aa16fc9c4510ae21bb77b69913b12..0000000000000000000000000000000000000000
--- a/20221107/loesung-2d-2.c
+++ /dev/null
@@ -1,34 +0,0 @@
-
-#include <stdio.h>
-
-int strlen (char *s)
-{
- char *s0 = s;
- while (*s)
- s++;
- return s - s0;
-}
-
-int fun_1 (char *s)
-{
- int x = 0;
- for (int i = 0; i < strlen (s); i++)
- x += s[i];
- return x;
-}
-
-int fun_2 (char *s)
-{
- int i = 0, x = 0;
- int len = strlen (s);
- while (i < len)
- x += s[i++];
- return x;
-}
-
-int main (void)
-{
- printf ("%d\n", fun_1 ("Hello, world!\n"));
- printf ("%d\n", fun_2 ("Hello, world!\n"));
- return 0;
-}
diff --git a/20221107/loesung-2e-1.c b/20221107/loesung-2e-1.c
deleted file mode 100644
index 74f5add0c5f62cccb8f817d40f860893f496db11..0000000000000000000000000000000000000000
--- a/20221107/loesung-2e-1.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int fun_3 (char *s)
-{
- int i = 0, x = 0;
- while (s[i])
- x += s[i++];
- return x;
-}
-
-int main (void)
-{
- printf ("%d\n", fun_3 ("Hello, world!\n"));
- return 0;
-}
diff --git a/20221107/loesung-2e-2.c b/20221107/loesung-2e-2.c
deleted file mode 100644
index b223d2d17c261d7cf1373a8379def8911a45ccb7..0000000000000000000000000000000000000000
--- a/20221107/loesung-2e-2.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int fun_4 (char *s)
-{
- int x = 0;
- while (*s)
- x += *s++;
- return x;
-}
-
-int main (void)
-{
- printf ("%d\n", fun_4 ("Hello, world!\n"));
- return 0;
-}
diff --git a/20221107/logo-hochschule-bochum-cvh-text-v2.pdf b/20221107/logo-hochschule-bochum-cvh-text-v2.pdf
deleted file mode 120000
index 4aa99b8f81061aca6dcaf43eed2d9efef40555f8..0000000000000000000000000000000000000000
--- a/20221107/logo-hochschule-bochum-cvh-text-v2.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
diff --git a/20221107/logo-hochschule-bochum.pdf b/20221107/logo-hochschule-bochum.pdf
deleted file mode 120000
index b6b9491e370e499c9276918182cdb82cb311bcd1..0000000000000000000000000000000000000000
--- a/20221107/logo-hochschule-bochum.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20221107/pgscript.sty b/20221107/pgscript.sty
deleted file mode 120000
index 95c888478c99ea7fda0fd11ccf669ae91be7178b..0000000000000000000000000000000000000000
--- a/20221107/pgscript.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgscript.sty
\ No newline at end of file
diff --git a/20221107/pgslides.sty b/20221107/pgslides.sty
deleted file mode 120000
index 5be1416f4216f076aa268901f52a15d775e43f64..0000000000000000000000000000000000000000
--- a/20221107/pgslides.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgslides.sty
\ No newline at end of file
diff --git a/20221107/test.pbm b/20221107/test.pbm
deleted file mode 100644
index 2196f5cf811f0705aa4324f82088418694246002..0000000000000000000000000000000000000000
Binary files a/20221107/test.pbm and /dev/null differ
diff --git a/20221107/test.png b/20221107/test.png
deleted file mode 100644
index 92e23a26dd9bdd61085f4265346a958438970d57..0000000000000000000000000000000000000000
Binary files a/20221107/test.png and /dev/null differ
diff --git a/20221107/test.xbm b/20221107/test.xbm
deleted file mode 100644
index 9cf13a19dca3b0c195cf23e35456562948aca16d..0000000000000000000000000000000000000000
--- a/20221107/test.xbm
+++ /dev/null
@@ -1,5 +0,0 @@
-#define test_width 9
-#define test_height 8
-static char test_bits[] = {
- 0x00, 0x00, 0x44, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x82, 0x00,
- 0x7C, 0x00, 0x00, 0x00, };
diff --git a/20221107/widerstaende-interner-pull-up.png b/20221107/widerstaende-interner-pull-up.png
deleted file mode 100644
index c96fea6fd4c5771ff9dc8df05f7c5006a766f962..0000000000000000000000000000000000000000
Binary files a/20221107/widerstaende-interner-pull-up.png and /dev/null differ
diff --git a/20221107/widerstaende-keine.png b/20221107/widerstaende-keine.png
deleted file mode 100644
index fd8214fdcf448851af922827b6fb5f7a78e8306e..0000000000000000000000000000000000000000
Binary files a/20221107/widerstaende-keine.png and /dev/null differ
diff --git a/20221107/widerstaende-pull-down.png b/20221107/widerstaende-pull-down.png
deleted file mode 100644
index 7bc85ac1e2d7567c50b1bc254567ed57692fab46..0000000000000000000000000000000000000000
Binary files a/20221107/widerstaende-pull-down.png and /dev/null differ
diff --git a/20221107/widerstaende-pull-up.png b/20221107/widerstaende-pull-up.png
deleted file mode 100644
index 95879fa0099f6139728d40498cd2826765cc03b5..0000000000000000000000000000000000000000
Binary files a/20221107/widerstaende-pull-up.png and /dev/null differ
diff --git a/20221107/widerstaende.xcf.gz b/20221107/widerstaende.xcf.gz
deleted file mode 100644
index 6f88deabf7bd885256eeab2abef8813259b67091..0000000000000000000000000000000000000000
Binary files a/20221107/widerstaende.xcf.gz and /dev/null differ
diff --git a/20221114/Tower_of_Hanoi.jpeg b/20221114/Tower_of_Hanoi.jpeg
deleted file mode 120000
index a1a794afda08596ffa2f46f278db53455de25b6c..0000000000000000000000000000000000000000
--- a/20221114/Tower_of_Hanoi.jpeg
+++ /dev/null
@@ -1 +0,0 @@
-../common/Tower_of_Hanoi.jpeg
\ No newline at end of file
diff --git a/20221114/aufgabe-1.c b/20221114/aufgabe-1.c
deleted file mode 100644
index 2afae773ac2d564771ab6dfb473eed664070d3e2..0000000000000000000000000000000000000000
--- a/20221114/aufgabe-1.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-int main (void)
-{
- uint64_t x = 4262939000843297096;
- char *s = &x;
- printf ("%s\n", s);
- return 0;
-}
diff --git a/20221114/aufgabe-3.c b/20221114/aufgabe-3.c
deleted file mode 100644
index cb09b0e10aade5c202ed88fddcb2e52d700d9915..0000000000000000000000000000000000000000
--- a/20221114/aufgabe-3.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-typedef struct
-{
- uint32_t a;
- uint64_t b;
- uint8_t c;
-} three_numbers;
-
-int main (void)
-{
- three_numbers xyz = { 1819042120, 2410670883059281007, 0 };
- printf ("%s\n", &xyz);
- return 0;
-}
diff --git a/20221114/gtk-13.c b/20221114/gtk-13.c
deleted file mode 100644
index a91d9abf14066d773103a8fca1e2c41abad40be3..0000000000000000000000000000000000000000
--- a/20221114/gtk-13.c
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <gtk/gtk.h>
-
-#define WIDTH 640
-#define HEIGHT 480
-
-double x = 5;
-double y = 95;
-double vx = 50.0;
-double vy = 0.7;
-double dt = 0.05;
-double g = 9.81;
-
-gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
-{
- GdkRGBA blue = { 0.0, 0.5, 1.0, 1.0 };
- gdk_cairo_set_source_rgba (c, &blue);
- cairo_arc (c, x, HEIGHT - y, 5, 0, 2 * G_PI);
- cairo_fill (c);
- return FALSE;
-}
-
-gboolean timer (GtkWidget *widget)
-{
- x += vx * dt;
- y += vy * dt;
- vx += 0.0 * dt;
- vy += (-g) * dt;
- gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
-}
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
-
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_container_add (GTK_CONTAINER (vbox), drawing_area);
- g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
- gtk_widget_set_size_request (drawing_area, WIDTH, HEIGHT);
-
- g_timeout_add (50, (GSourceFunc) timer, drawing_area);
-
- gtk_widget_show (drawing_area);
- gtk_widget_show (button);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
-}
diff --git a/20221114/hanoi-0.c b/20221114/hanoi-0.c
deleted file mode 100644
index 83b5f081e33e699f2d5eaa1f858320530e1b2820..0000000000000000000000000000000000000000
--- a/20221114/hanoi-0.c
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <stdio.h>
-
-#define DISKS 4
-
-int n[3], tower[3][DISKS];
-
-void display (void)
-{
- printf ("\n");
- for (int i = 0; i < 3; i++)
- {
- printf ("tower %d:", i);
- for (int j = 0; j < n[i]; j++)
- printf (" %d", tower[i][j]);
- printf ("\n");
- }
-}
-
-int main (void)
-{
- n[0] = 0;
- n[1] = 0;
- n[2] = 0;
- display ();
- return 0;
-}
diff --git a/20221114/hanoi-1.c b/20221114/hanoi-1.c
deleted file mode 100644
index 6d005f0b12afa6086afb65e1794fb5c977b474e2..0000000000000000000000000000000000000000
--- a/20221114/hanoi-1.c
+++ /dev/null
@@ -1,30 +0,0 @@
-#include <stdio.h>
-
-#define DISKS 4
-
-int n[3], tower[3][DISKS];
-
-void display (void)
-{
- printf ("\n");
- for (int i = 0; i < 3; i++)
- {
- printf ("tower %d:", i);
- for (int j = 0; j < n[i]; j++)
- printf (" %d", tower[i][j]);
- printf ("\n");
- }
-}
-
-int main (void)
-{
- n[0] = 4;
- tower[0][0] = 4;
- tower[0][1] = 3;
- tower[0][2] = 2;
- tower[0][3] = 1;
- n[1] = 0;
- n[2] = 0;
- display ();
- return 0;
-}
diff --git a/20221114/hanoi-2.c b/20221114/hanoi-2.c
deleted file mode 100644
index c928c1130539da08d0882249bdffc877d72289b2..0000000000000000000000000000000000000000
--- a/20221114/hanoi-2.c
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <stdio.h>
-
-#define DISKS 4
-
-int n[3], tower[3][DISKS];
-
-void display (void)
-{
- printf ("\n");
- for (int i = 0; i < 3; i++)
- {
- printf ("tower %d:", i);
- for (int j = 0; j < n[i]; j++)
- printf (" %d", tower[i][j]);
- printf ("\n");
- }
-}
-
-int main (void)
-{
- n[0] = DISKS;
- for (int i = 0; i < DISKS; i++)
- tower[0][i] = DISKS - i;
- n[1] = 0;
- n[2] = 0;
- display ();
- return 0;
-}
diff --git a/20221114/hanoi-3.c b/20221114/hanoi-3.c
deleted file mode 100644
index 4b59c046962c1f79eca315882d93faf6b6c298c1..0000000000000000000000000000000000000000
--- a/20221114/hanoi-3.c
+++ /dev/null
@@ -1,44 +0,0 @@
-#include <stdio.h>
-#include <error.h>
-
-#define DISKS 4
-
-int n[3], tower[3][DISKS];
-
-void display (void)
-{
- printf ("\n");
- for (int i = 0; i < 3; i++)
- {
- printf ("tower %d:", i);
- for (int j = 0; j < n[i]; j++)
- printf (" %d", tower[i][j]);
- printf ("\n");
- }
-}
-
-void move (int from, int to, int disks)
-{
- if (disks == 1)
- {
- if (n[from] <= 0)
- error (1, 0, "trying to move disk from empty tower");
- if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1])
- error (1, 0, "trying to move larger disk on smaller one");
- tower[to][n[to]] = tower[from][n[from] - 1];
- n[to]++;
- n[from]--;
- }
-}
-
-int main (void)
-{
- n[0] = DISKS;
- for (int i = 0; i < DISKS; i++)
- tower[0][i] = DISKS - i;
- n[1] = 0;
- n[2] = 0;
- move (2, 0, 1);
- display ();
- return 0;
-}
diff --git a/20221114/hanoi-4.c b/20221114/hanoi-4.c
deleted file mode 100644
index 162a5ba7cccedf64bff8ae9a514aaf146088e3a4..0000000000000000000000000000000000000000
--- a/20221114/hanoi-4.c
+++ /dev/null
@@ -1,44 +0,0 @@
-#include <stdio.h>
-#include <error.h>
-
-#define DISKS 4
-
-int n[3], tower[3][DISKS];
-
-void display (void)
-{
- printf ("\n");
- for (int i = 0; i < 3; i++)
- {
- printf ("tower %d:", i);
- for (int j = 0; j < n[i]; j++)
- printf (" %d", tower[i][j]);
- printf ("\n");
- }
-}
-
-void move (int from, int to, int disks)
-{
- if (disks == 1)
- {
- if (n[from] <= 0)
- error (1, 0, "trying to move disk from empty tower");
- if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1])
- error (1, 0, "trying to move larger disk on smaller one");
- tower[to][n[to]] = tower[from][n[from] - 1];
- n[to]++;
- n[from]--;
- }
-}
-
-int main (void)
-{
- n[0] = DISKS;
- for (int i = 0; i < DISKS; i++)
- tower[0][i] = DISKS - i;
- n[1] = 0;
- n[2] = 0;
- move (0, 2, 1);
- display ();
- return 0;
-}
diff --git a/20221114/hanoi-5.c b/20221114/hanoi-5.c
deleted file mode 100644
index e04ad85f63fe92e5c15d22646beb9e9107bf78d6..0000000000000000000000000000000000000000
--- a/20221114/hanoi-5.c
+++ /dev/null
@@ -1,45 +0,0 @@
-#include <stdio.h>
-#include <error.h>
-
-#define DISKS 4
-
-int n[3], tower[3][DISKS];
-
-void display (void)
-{
- printf ("\n");
- for (int i = 0; i < 3; i++)
- {
- printf ("tower %d:", i);
- for (int j = 0; j < n[i]; j++)
- printf (" %d", tower[i][j]);
- printf ("\n");
- }
-}
-
-void move (int from, int to, int disks)
-{
- if (disks == 1)
- {
- if (n[from] <= 0)
- error (1, 0, "trying to move disk from empty tower");
- if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1])
- error (1, 0, "trying to move larger disk on smaller one");
- tower[to][n[to]] = tower[from][n[from] - 1];
- n[to]++;
- n[from]--;
- display ();
- }
-}
-
-int main (void)
-{
- n[0] = DISKS;
- for (int i = 0; i < DISKS; i++)
- tower[0][i] = DISKS - i;
- n[1] = 0;
- n[2] = 0;
- display ();
- move (0, 2, 1);
- return 0;
-}
diff --git a/20221114/hanoi-6.c b/20221114/hanoi-6.c
deleted file mode 100644
index 1267605f802246e857c32d29cc0a132609cb24ce..0000000000000000000000000000000000000000
--- a/20221114/hanoi-6.c
+++ /dev/null
@@ -1,52 +0,0 @@
-#include <stdio.h>
-#include <error.h>
-
-#define DISKS 4
-
-int n[3], tower[3][DISKS];
-
-void display (void)
-{
- printf ("\n");
- for (int i = 0; i < 3; i++)
- {
- printf ("tower %d:", i);
- for (int j = 0; j < n[i]; j++)
- printf (" %d", tower[i][j]);
- printf ("\n");
- }
-}
-
-void move (int from, int to, int disks)
-{
- if (disks == 1)
- {
- if (n[from] <= 0)
- error (1, 0, "trying to move disk from empty tower");
- if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1])
- error (1, 0, "trying to move larger disk on smaller one");
- tower[to][n[to]] = tower[from][n[from] - 1];
- n[to]++;
- n[from]--;
- display ();
- }
- else
- {
- int help = 0 + 1 + 2 - from - to;
- move (from, help, disks - 1);
- move (from, to, 1);
- move (help, to, disks - 1);
- }
-}
-
-int main (void)
-{
- n[0] = DISKS;
- for (int i = 0; i < DISKS; i++)
- tower[0][i] = DISKS - i;
- n[1] = 0;
- n[2] = 0;
- display ();
- move (0, 2, DISKS);
- return 0;
-}
diff --git a/20221114/hanoi-7.c b/20221114/hanoi-7.c
deleted file mode 100644
index f71fcdc0c3f66047ee3ad870d019a06eb328050f..0000000000000000000000000000000000000000
--- a/20221114/hanoi-7.c
+++ /dev/null
@@ -1,52 +0,0 @@
-#include <stdio.h>
-#include <error.h>
-
-#define DISKS 5
-
-int n[3], tower[3][DISKS];
-
-void display (void)
-{
- printf ("\n");
- for (int i = 0; i < 3; i++)
- {
- printf ("tower %d:", i);
- for (int j = 0; j < n[i]; j++)
- printf (" %d", tower[i][j]);
- printf ("\n");
- }
-}
-
-void move (int from, int to, int disks)
-{
- if (disks == 1)
- {
- if (n[from] <= 0)
- error (1, 0, "trying to move disk from empty tower");
- if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1])
- error (1, 0, "trying to move larger disk on smaller one");
- tower[to][n[to]] = tower[from][n[from] - 1];
- n[to]++;
- n[from]--;
- display ();
- }
- else
- {
- int help = 0 + 1 + 2 - from - to;
- move (from, help, disks - 1);
- move (from, to, 1);
- move (help, to, disks - 1);
- }
-}
-
-int main (void)
-{
- n[0] = DISKS;
- for (int i = 0; i < DISKS; i++)
- tower[0][i] = DISKS - i;
- n[1] = 0;
- n[2] = 0;
- display ();
- move (0, 2, DISKS);
- return 0;
-}
diff --git a/20221114/hanoi-8.c b/20221114/hanoi-8.c
deleted file mode 100644
index 6d804063531d424a82924a89d85424c33994793b..0000000000000000000000000000000000000000
--- a/20221114/hanoi-8.c
+++ /dev/null
@@ -1,52 +0,0 @@
-#include <stdio.h>
-#include <error.h>
-
-#define DISKS 64
-
-int n[3], tower[3][DISKS];
-
-void display (void)
-{
- printf ("\n");
- for (int i = 0; i < 3; i++)
- {
- printf ("tower %d:", i);
- for (int j = 0; j < n[i]; j++)
- printf (" %d", tower[i][j]);
- printf ("\n");
- }
-}
-
-void move (int from, int to, int disks)
-{
- if (disks == 1)
- {
- if (n[from] <= 0)
- error (1, 0, "trying to move disk from empty tower");
- if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1])
- error (1, 0, "trying to move larger disk on smaller one");
- tower[to][n[to]] = tower[from][n[from] - 1];
- n[to]++;
- n[from]--;
- display ();
- }
- else
- {
- int help = 0 + 1 + 2 - from - to;
- move (from, help, disks - 1);
- move (from, to, 1);
- move (help, to, disks - 1);
- }
-}
-
-int main (void)
-{
- n[0] = DISKS;
- for (int i = 0; i < DISKS; i++)
- tower[0][i] = DISKS - i;
- n[1] = 0;
- n[2] = 0;
- display ();
- move (0, 2, DISKS);
- return 0;
-}
diff --git a/20221114/hanoi-9.c b/20221114/hanoi-9.c
deleted file mode 100644
index 7694b373b7011e96f6be0ad0f00ba54b67086158..0000000000000000000000000000000000000000
--- a/20221114/hanoi-9.c
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stdio.h>
-#include <error.h>
-
-#define DISKS 64
-
-int n[3], tower[3][DISKS];
-
-void display (void)
-{
- printf ("\n");
- for (int i = 0; i < 3; i++)
- {
- printf ("tower %d:", i);
- for (int j = 0; j < n[i]; j++)
- printf (" %d", tower[i][j]);
- printf ("\n");
- }
-}
-
-void move (int from, int to, int disks)
-{
- if (disks == 1)
- {
- if (n[from] <= 0)
- error (1, 0, "trying to move disk from empty tower");
- if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1])
- error (1, 0, "trying to move larger disk on smaller one");
- tower[to][n[to]] = tower[from][n[from] - 1];
- n[to]++;
- n[from]--;
- static int counter = 1;
- if (counter++ >= 100000000)
- {
- display ();
- counter = 1;
- }
- }
- else
- {
- int help = 0 + 1 + 2 - from - to;
- move (from, help, disks - 1);
- move (from, to, 1);
- move (help, to, disks - 1);
- }
-}
-
-int main (void)
-{
- n[0] = DISKS;
- for (int i = 0; i < DISKS; i++)
- tower[0][i] = DISKS - i;
- n[1] = 0;
- n[2] = 0;
- display ();
- move (0, 2, DISKS);
- display ();
- return 0;
-}
diff --git a/20221114/hp-20221114.pdf b/20221114/hp-20221114.pdf
deleted file mode 100644
index 2ff7cc6338c108570a7e8b83acd64d317063c8d0..0000000000000000000000000000000000000000
Binary files a/20221114/hp-20221114.pdf and /dev/null differ
diff --git a/20221114/hp-20221114.tex b/20221114/hp-20221114.tex
deleted file mode 100644
index 585f6e28f5c6fd4c7c8697bc71cad34a580707ba..0000000000000000000000000000000000000000
--- a/20221114/hp-20221114.tex
+++ /dev/null
@@ -1,1308 +0,0 @@
-% hp-20221114.pdf - Lecture Slides on Low-Level Programming
-% Copyright (C) 2012, 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Binärdarstellung negativer Zahlen, Alignment, Differentialgleichungen, Rekursion
-
-\documentclass[10pt,t]{beamer}
-
-\usepackage{pgslides}
-\usepackage{pdftricks}
-\usepackage{tikz}
-
-\begin{psinputs}
- \usepackage[utf8]{inputenc}
- \usepackage[german]{babel}
- \usepackage[T1]{fontenc}
- \usepackage{helvet}
- \renewcommand*\familydefault{\sfdefault}
- \usepackage{pstricks,pst-grad}
-\end{psinputs}
-
-\newcommand{\redurl}[1]{\href{#1}{\color{red}\nolinkurl{#1}}}
-
-\title{Hardwarenahe Programmierung}
-\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
-\date{14.\ November 2022}
-
-\begin{document}
-
-\maketitleframe
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \begin{itemize}
- \item[4.1] Bit-Operationen
- \item[4.2] I/O-Ports
- \color{medgreen}
- \item[4.3] Interrupts
- \item[4.4] volatile-Variable
- \color{orange}
- \item[4.5] Byte-Reihenfolge -- Endianness
- \color{red}
- \item[4.6] Binärdarstellung negativer Zahlen
- \item[4.7] Speicherausrichtung -- Alignment
- \end{itemize}
- \item[\textbf{5}] \textbf{Algorithmen}
- \begin{itemize}
- \color{red}
- \item[5.1] Differentialgleichungen
- \color{black}
- \item[5.2] Rekursion
- \item[5.3] Aufwandsabschätzungen
- \end{itemize}
- \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
- \item[\textbf{7}] \textbf{Datenstrukturen}
- \end{itemize}
-
-\end{frame}
-
-\setcounter{section}{3}
-\section{Hardwarenahe Programmierung}
-\subsection{Bit-Operationen}
-\subsubsection{Zahlensysteme}
-
-\begin{frame}[fragile]
-
- \showsection
- \vspace*{-\smallskipamount}
- \showsubsection
- \vspace*{-\medskipamount}
- \showsubsubsection
-
- \begin{tabular}{rlrl}
- Basis & Name & Beispiel & Anwendung \\[\smallskipamount]
- 2 & Binärsystem & 1\,0000\,0011 & Bit-Operationen \\
- 8 & Oktalsystem & \lstinline,0403, & Dateizugriffsrechte (Unix) \\
- 10 & Dezimalsystem & \lstinline,259, & Alltag \\
- 16 & Hexadezimalsystem & \lstinline,0x103, & Bit-Operationen \\
- 256 & (keiner gebräuchlich) & 0.0.1.3 & IP-Adressen (IPv4)
- \end{tabular}
-
- \bigskip
-
- \begin{itemize}
- \item
- Computer rechnen im Binärsystem.
- \item
- Für viele Anwendungen (z.\,B.\ I/O-Ports, Grafik, \dots) ist es notwendig,\\
- Bits in Zahlen einzeln ansprechen zu können.
- \end{itemize}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsubsection
-
- \begin{tabular}{rlrlrc}
- \qquad 000 & \bf 0 \hspace*{1.5cm} & 0000 & \bf 0 & \quad 1000 & \bf 8\\
- 001 & \bf 1 & 0001 & \bf 1 & 1001 & \bf 9\\
- 010 & \bf 2 & 0010 & \bf 2 & 1010 & \bf A\\
- 011 & \bf 3 & 0011 & \bf 3 & 1011 & \bf B\\[\smallskipamount]
- 100 & \bf 4 & 0100 & \bf 4 & 1100 & \bf C\\
- 101 & \bf 5 & 0101 & \bf 5 & 1101 & \bf D\\
- 110 & \bf 6 & 0110 & \bf 6 & 1110 & \bf E\\
- 111 & \bf 7 & 0111 & \bf 7 & 1111 & \bf F\\
- \end{tabular}
-
- \medskip
-
- \begin{itemize}
- \item
- Oktal- und Hexadezimalzahlen lassen sich ziffernweise\\
- in Binär-Zahlen umrechnen.
- \item
- Hexadezimalzahlen sind eine Kurzschreibweise für Binärzahlen,\\
- gruppiert zu jeweils 4 Bits.
- \item
- Oktalzahlen sind eine Kurzschreibweise für Binärzahlen,\\
- gruppiert zu jeweils 3 Bits.
- \item
- Trotz Taschenrechner u.\,ä.\ lohnt es sich,\\
- die o.\,a.\ Umrechnungstabelle \textbf{auswendig} zu kennen.
- \end{itemize}
-
-\end{frame}
-
-\subsubsection{Bit-Operationen in C}
-
-\begin{frame}[fragile]
-
- \showsubsubsection
-
- \begin{tabular}{lll}
- C-Operator & Verknüpfung & Anwendung \\[\smallskipamount]
- \lstinline,&, & Und & Bits gezielt löschen \\
- \lstinline,|, & Oder & Bits gezielt setzen \\
- \lstinline,^, & Exklusiv-Oder & Bits gezielt invertieren \\
- \lstinline,~, & Nicht & Alle Bits invertieren \\[\smallskipamount]
- \lstinline,<<, & Verschiebung nach links & Maske generieren \\
- \lstinline,>>, & Verschiebung nach rechts & Bits isolieren
- \end{tabular}
-
- \bigskip
-
- Numerierung der Bits: von rechts ab 0
-
- \medskip
-
- \begin{tabular}{ll}
- Bit Nr.\ 3 auf 1 setzen: &
- \lstinline,a |= 1 << 3;, \\
- Bit Nr.\ 4 auf 0 setzen: &
- \lstinline,a &= ~(1 << 4);, \\
- Bit Nr.\ 0 invertieren: &
- \lstinline,a ^= 1 << 0;,
- \end{tabular}
-
- \smallskip
-
- ~~Abfrage, ob Bit Nr.\ 1 gesetzt ist:\quad
- \lstinline{if (a & (1 << 1))}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsubsection
-
- C-Datentypen für Bit-Operationen:
- \smallskip\par
- \lstinline{#include <stdint.h>}
- \medskip\par
- \begin{tabular}{lllll}
- & 8 Bit & 16 Bit & 32 Bit & 64 Bit \\
- mit Vorzeichen & \lstinline,int8_t,
- & \lstinline,int16_t,
- & \lstinline,int32_t,
- & \lstinline,int64_t, \\
- ohne Vorzeichen & \lstinline,uint8_t,
- & \lstinline,uint16_t,
- & \lstinline,uint32_t,
- & \lstinline,uint64_t,
- \end{tabular}
-
- \bigskip
- \bigskip
-
- Ausgabe:
- \smallskip\par
- \begin{lstlisting}
- #include <stdio.h>
- #include <stdint.h>
- #include <inttypes.h>
- ...
- uint64_t x = 42;
- printf ("Die Antwort lautet: %" PRIu64 "\n", x);
- \end{lstlisting}
-
-\end{frame}
-
-\subsection{I/O-Ports}
-
-\begin{frame}[fragile]
-
-% \showsection
- \showsubsection
- \vspace*{-1.5\medskipamount}
- {\large\textbf{\color{structure}4.3\quad Interrupts}}
-
- \bigskip
-
- Kommunikation mit externen Geräten
-
- \bigskip
-
- \begin{center}
- \includegraphics{io-ports-and-interrupts.pdf}
- \end{center}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- In Output-Port schreiben = Aktoren ansteuern
-
- Beispiel: LED
-
- \medskip
-
- \begin{lstlisting}
- #include <avr/io.h>
- ...
- DDRC = 0x70;
- PORTC = 0x40;
- \end{lstlisting}
- \begin{picture}(0,0)
- \put(3,0.67){\begin{minipage}{3cm}
- \color{red}%
- binär: 0111\,0000\\
- binär: 0100\,0000
- \end{minipage}}
- \put(10,0.67){\makebox(0,0)[r]{\color{red}Herstellerspezifisch!}}
- \end{picture}
-
- \bigskip
-
- \lstinline{DDR} = Data Direction Register\\
- Bit = 1 für Output-Port\\
- Bit = 0 für Input-Port
-
- \bigskip
-
- \emph{Details: siehe Datenblatt und Schaltplan}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Aus Input-Port lesen = Sensoren abfragen
-
- Beispiel: Taster
-
- \medskip
-
- \begin{lstlisting}
- #include <avr/io.h>
- ...
- DDRC = 0xfd;
- while ((PINC & 0x02) == 0)
- ; /* just wait */
- \end{lstlisting}
- \begin{picture}(0,0)(-1.5,-0.42)
- \put(3,0.67){\begin{minipage}{3cm}
- \color{red}%
- binär: 1111\,1101\\
- binär: 0000\,0010
- \end{minipage}}
- \put(10,0.67){\makebox(0,0)[r]{\color{red}Herstellerspezifisch!}}
- \end{picture}
-
- \bigskip
-
- \lstinline{DDR} = Data Direction Register\\
- Bit = 1 für Output-Port\\
- Bit = 0 für Input-Port
-
- \bigskip
-
- \emph{Details: siehe Datenblatt und Schaltplan}
-
- \bigskip
-
- Praktikumsaufgabe: Druckknopfampel
-
-\end{frame}
-
-\subsection{Interrupts}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Externes Gerät ruft (per Stromsignal) Unterprogramm auf
-
- Zeiger hinterlegen: "`Interrupt-Vektor"'
-
- Beispiel: eingebaute Uhr\hfill
- \makebox(0,0)[tr]{%
- \only<1->{\begin{minipage}[t]{4.7cm}
- \vspace*{-0.3cm}%
- statt Zählschleife (\lstinline{_delay_ms}):\\
- Hauptprogramm kann\\
- andere Dinge tun
- \end{minipage}}%
- }
-
- \medskip
-
- \begin{lstlisting}
- #include <avr/interrupt.h>
-
- ...
-
-
- ISR (TIMER0B_COMP_vect)
- {
- PORTD ^= 0x40;
- }
- \end{lstlisting}
- \begin{picture}(0,0)
- \color{red}
- \put(1.9,3.1){\makebox(0,0)[tr]{\tikz{\draw[-latex](0,0)--(-1.4,-1.0);}}}
- \put(2.0,3.2){\makebox(0,0)[l]{"`Dies ist ein Interrupt-Handler."'}}
- \put(2.3,2.6){\makebox(0,0)[tr]{\tikz{\draw[-latex](0,0)--(-0.6,-0.55);}}}
- \put(2.4,2.6){\makebox(0,0)[l]{Interrupt-Vektor darauf zeigen lassen}}
- \end{picture}
-
- Initialisierung über spezielle Ports:
- \lstinline{TCCR0B}, \lstinline{TIMSK0}
-
- \bigskip
-
- \emph{Details: siehe Datenblatt und Schaltplan}
-
- \vspace*{-2.5cm}\hfill
- {\color{red}Herstellerspezifisch!}%
- \hspace*{1cm}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Externes Gerät ruft (per Stromsignal) Unterprogramm auf
-
- Zeiger hinterlegen: "`Interrupt-Vektor"'
-
- Beispiel: Taster\hfill
- \makebox(0,0)[tr]{%
- \begin{minipage}[t]{4.7cm}
- \vspace*{-0.3cm}%
- statt \newterm{Busy Waiting\/}:\\
- Hauptprogramm kann\\
- andere Dinge tun
- \end{minipage}}
-
- \medskip
-
- \begin{lstlisting}
- #include <avr/interrupt.h>
- ...
-
- ISR (INT0_vect)
- {
- PORTD ^= 0x40;
- }
- \end{lstlisting}
-
- \medskip
-
- Initialisierung über spezielle Ports:
- \lstinline{EICRA}, \lstinline{EIMSK}
-
- \bigskip
-
- \emph{Details: siehe Datenblatt und Schaltplan}
-
- \vspace*{-2.5cm}\hfill
- {\color{red}Herstellerspezifisch!}%
- \hspace*{1cm}
-
-\end{frame}
-
-\subsection{volatile-Variable}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Externes Gerät ruft (per Stromsignal) Unterprogramm auf
-
- Zeiger hinterlegen: "`Interrupt-Vektor"'
-
- Beispiel: Taster
-
- \vspace*{-2.5pt}
-
- \begin{minipage}[t]{5cm}
- \begin{onlyenv}<1>
- \begin{lstlisting}[gobble=8]
- ¡#include <avr/interrupt.h>
- ...
-
- uint8_t key_pressed = 0;
-
- ISR (INT0_vect)
- {
- key_pressed = 1;
- }¿
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<2>
- \begin{lstlisting}[gobble=8]
- ¡#include <avr/interrupt.h>
- ...
-
- volatile uint8_t key_pressed = 0;
-
- ISR (INT0_vect)
- {
- key_pressed = 1;
- }¿
- \end{lstlisting}
- \end{onlyenv}
- \end{minipage}\hfill
- \begin{minipage}[t]{6cm}
- \begin{lstlisting}[gobble=6]
- ¡int main (void)
- {
- ...
-
- while (1)
- {
- while (!key_pressed)
- ; /* just wait */
- PORTD ^= 0x40;
- key_pressed = 0;
- }
- return 0;
- }¿
- \end{lstlisting}
- \end{minipage}
-
- \pause
- \begin{picture}(0,0)
- \color{red}
- \put(10.3,4.0){\makebox(0,0)[b]{\begin{minipage}{6cm}
- \begin{center}
- \textbf{volatile}:\\
- Speicherzugriff\\
- nicht wegoptimieren
- \end{center}
- \end{minipage}}}
- \put(10.3,3.95){\makebox(0,0)[tr]{\tikz{\draw[-latex](0,0)--(-0.5,-0.9);}}}
- \end{picture}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Was ist eigentlich \lstinline{PORTD}?
-
- \bigskip
-% \pause
-
- \lstinline[style=cmd]{avr-gcc -Wall -Os -mmcu=atmega328p blink-3.c -E}
-
- \bigskip
-% \pause
- \lstinline{PORTD = 0x01;}\\
- \textarrow\quad
- \lstinline[style=terminal]{(*(volatile uint8_t *)((0x0B) + 0x20)) = 0x01;}\\
-% \pause
- \begin{picture}(0,2)(0,-1.7)
- \color{red}
- \put(5.75,0.3){$\underbrace{\rule{2.95cm}{0pt}}_{\mbox{Zahl: \lstinline|0x2B|}}$}
-% \pause
- \put(1.55,0.3){$\underbrace{\rule{4.0cm}{0pt}}_{\mbox{\shortstack[t]{Umwandlung in Zeiger\\
- auf \lstinline|volatile uint8_t|}}}$}
-% \pause
- \put(1.32,-1){\makebox(0,0)[b]{\tikz{\draw[-latex](0,0)--(0,1.3)}}}
- \put(1.12,-1.1){\makebox(0,0)[tl]{Dereferenzierung des Zeigers}}
- \end{picture}
-
-% \pause
- \textarrow\quad
- \lstinline|volatile uint8_t|-Variable an Speicheradresse \lstinline|0x2B|
-
-% \pause
- \bigskip
- \bigskip
-
- \textarrow\quad
- \lstinline|PORTA = PORTB = PORTC = PORTD = 0| ist eine schlechte Idee.
-
-\end{frame}
-
-\subsection{Byte-Reihenfolge -- Endianness}
-\subsubsection{Konzept}
-
-\begin{frame}[fragile]
-
- \showsubsection
- \showsubsubsection
-
- Eine Zahl geht über mehrere Speicherzellen.\\
- Beispiel: 16-Bit-Zahl in 2 8-Bit-Speicherzellen
-
- \smallskip
-
- Welche Bits liegen wo?
-
-% \pause
- \bigskip
-
- $1027 = 1024 + 2 + 1 = 0000\,0100\,0000\,0011_2 = 0403_{16}$
-
-% \pause
- \bigskip
- Speicherzellen:
-
- \medskip
- \begin{tabular}{|c|c|l}\cline{1-2}
- \raisebox{-0.25ex}{04} & \raisebox{-0.25ex}{03} & \strut Big-Endian "`großes Ende zuerst"' \\\cline{1-2}
- \multicolumn{2}{c}{} & % \pause
- für Menschen leichter lesbar % \pause
- \\
- \multicolumn{3}{c}{} \\[-5pt]\cline{1-2}
- \raisebox{-0.25ex}{03} & \raisebox{-0.25ex}{04} & \strut Little-Endian "`kleines Ende zuerst"' \\\cline{1-2}
- \multicolumn{2}{c}{} & % \pause
- bei Additionen effizienter
- \end{tabular}
-
-% \pause
- \medskip
- \textarrow\ Geschmackssache
-% \pause\\
- \quad\textbf{\dots\ außer bei Datenaustausch!}
-
-% \pause
-% \bigskip
-%
-% Aber: nicht verwechseln! \qquad $0304_{16} = 772$
-
-\end{frame}
-
-\begin{frame}
-
- \showsubsection
- \showsubsubsection
-
- Eine Zahl geht über mehrere Speicherzellen.\\
- Beispiel: 16-Bit-Zahl in 2 8-Bit-Speicherzellen
-
- \smallskip
-
- Welche Bits liegen wo?
-
- \medskip
-
- \textarrow\ Geschmackssache\\
- \textbf{\dots\ außer bei Datenaustausch!}
-
- \begin{itemize}
- \item
- Dateiformate
- \item
- Datenübertragung
- \end{itemize}
-
-\end{frame}
-
-\subsubsection{Dateiformate}
-
-\begin{frame}
-
- \showsubsection
- \showsubsubsection
-
- Audio-Formate: Reihenfolge der Bytes in 16- und 32-Bit-Zahlen
- \begin{itemize}
- \item
- RIFF-WAVE-Dateien (\file{.wav}): Little-Endian
- \item
- Au-Dateien (\file{.au}): Big-Endian
-% \pause
- \item
- ältere AIFF-Dateien (\file{.aiff}): Big-Endian
- \item
- neuere AIFF-Dateien (\file{.aiff}): Little-Endian
- \end{itemize}
-
-% \pause
- \bigskip
-
- Grafik-Formate: Reihenfolge der Bits in den Bytes
- \begin{itemize}
- \item
- PBM-Dateien: Big-Endian\only<1->{, MSB first}
- \item
- XBM-Dateien: Little-Endian\only<1->{, LSB first}
- \end{itemize}
- \only<1->{MSB/LSB = most/least significant bit}
-
-\end{frame}
-
-\subsubsection{Datenübertragung}
-
-\begin{frame}
-
- \showsubsection
- \showsubsubsection
-
- \begin{itemize}
- \item
- RS-232 (serielle Schnittstelle): LSB first
- \item
- I$^2$C: MSB first
- \item
- USB: beides
- \pause
- \medskip
- \item
- Ethernet: LSB first
- \item
- TCP/IP (Internet): Big-Endian
- \end{itemize}
-
-\end{frame}
-
-\subsection{Binärdarstellung negativer Zahlen}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Speicher ist begrenzt!\\
- \textarrow\ feste Anzahl von Bits
-
- \medskip
-
- 8-Bit-Zahlen ohne Vorzeichen: \lstinline{uint8_t}\\
- \textarrow\ Zahlenwerte von \lstinline{0x00} bis \lstinline{0xff} = 0 bis 255\\
- \pause
- \textarrow\ 255 + 1 = 0
-
- \pause
- \medskip
-
- 8-Bit-Zahlen mit Vorzeichen: \lstinline{int8_t}\\
- \lstinline{0xff} = 255 ist die "`natürliche"' Schreibweise für $-1$.\\
- \pause
- \textarrow\ Zweierkomplement
-
- \pause
- \medskip
-
- Oberstes Bit = 1: negativ\\
- Oberstes Bit = 0: positiv\\
- \textarrow\ 127 + 1 = $-128$
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Speicher ist begrenzt!\\
- \textarrow\ feste Anzahl von Bits
-
- \medskip
-
- 16-Bit-Zahlen ohne Vorzeichen:
- \lstinline{uint16_t}\hfill\lstinline{uint8_t}\\
- \textarrow\ Zahlenwerte von \lstinline{0x0000} bis \lstinline{0xffff}
- = 0 bis 65535\hfill 0 bis 255\\
- \textarrow\ 65535 + 1 = 0\hfill 255 + 1 = 0
-
- \medskip
-
- 16-Bit-Zahlen mit Vorzeichen:
- \lstinline{int16_t}\hfill\lstinline{int8_t}\\
- \lstinline{0xffff} = 66535 ist die "`natürliche"' Schreibweise für $-1$.\hfill
- \lstinline{0xff} = 255 = $-1$\\
- \textarrow\ Zweierkomplement
-
- \medskip
-
- Oberstes Bit = 1: negativ\\
- Oberstes Bit = 0: positiv\\
- \textarrow\ 32767 + 1 = $-32768$
-
- \bigskip
- Literatur: \url{http://xkcd.com/571/}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Frage: \emph{Für welche Zahl steht der Speicherinhalt\,
- \raisebox{2pt}{%
- \tabcolsep0.25em
- \begin{tabular}{|c|c|}\hline
- \rule{0pt}{11pt}a3 & 90 \\\hline
- \end{tabular}}
- (hexadezimal)?}
-
- \pause
- \smallskip
- Antwort: \emph{Das kommt darauf an.} ;--)
-
- \pause
- \medskip
- Little-Endian:
-
- \smallskip
-
- \begin{tabular}{lrl}
- als \lstinline,int8_t,: & $-93$ & (nur erstes Byte)\\
- als \lstinline,uint8_t,: & $163$ & (nur erstes Byte)\\
- als \lstinline,int16_t,: & $-28509$\\
- als \lstinline,uint16_t,: & $37027$\\
- \lstinline,int32_t, oder größer: & $37027$
- & (zusätzliche Bytes mit Nullen aufgefüllt)
- \end{tabular}
-
- \pause
- \medskip
- Big-Endian:
-
- \smallskip
-
- \begin{tabular}{lrl}
- als \lstinline,int8_t,: & $-93$ & (nur erstes Byte)\\
- als \lstinline,uint8_t,: & $163$ & (nur erstes Byte)\\
- als \lstinline,int16_t,: & $-23664$\\
- als \lstinline,uint16_t,: & $41872$\\ als \lstinline,int32_t,: & $-1550843904$ & (zusätzliche Bytes\\
- als \lstinline,uint32_t,: & $2744123392$ & mit Nullen aufgefüllt)\\
- als \lstinline,int64_t,: & $-6660823848880963584$\\
- als \lstinline,uint64_t,: & $11785920224828588032$\\
- \end{tabular}
-
- \vspace*{-1cm}
-
-\end{frame}
-
-\subsection{Speicherausrichtung -- Alignment}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{lstlisting}
- #include <stdint.h>
-
- uint8_t a;
- uint16_t b;
- uint8_t c;
- \end{lstlisting}
-
- \pause
- \bigskip
-
- Speicheradresse durch 2 teilbar -- "`16-Bit-Alignment"'
- \begin{itemize}
- \item
- 2-Byte-Operation: effizienter
- \pause
- \item
- \dots\ oder sogar nur dann erlaubt
- \pause
- \arrowitem
- Compiler optimiert Speicherausrichtung
- \end{itemize}
-
- \medskip
-
- \pause
- \begin{minipage}{3cm}
- \begin{lstlisting}[gobble=6]
- ¡uint8_t a;
- uint8_t dummy;
- uint16_t b;
- uint8_t c;¿
- \end{lstlisting}
- \end{minipage}
- \pause
- \begin{minipage}{3cm}
- \begin{lstlisting}[gobble=6]
- ¡uint8_t a;
- uint8_t c;
- uint16_t b;¿
- \end{lstlisting}
- \end{minipage}
-
- \pause
- \vspace{-1.75cm}
- \strut\hfill
- \begin{minipage}{6.5cm}
- Fazit:
- \begin{itemize}
- \item
- \textbf{Adressen von Variablen\\
- sind systemabhängig}
- \item
- Bei Definition von Datenformaten\\
- Alignment beachten \textarrow\ effizienter
- \end{itemize}
- \end{minipage}
-
-\end{frame}
-
-\section{Algorithmen}
-\subsection{Differentialgleichungen}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \textbf{Beispiel 1: Gleichmäßig beschleunigte Bewegung}
-
- \strut\hfill
- \begin{minipage}{2.5cm}
- \vspace*{0.6cm}
- \begin{align*}
- x'(t) &= v_x(t) \\[0.65cm]
- y'(t) &= v_y(t) \\[0.75cm]
- v_x'(t) &= 0 \\[0.65cm]
- v_y'(t) &= -g
- \end{align*}
- \vspace*{0.0cm}
- \end{minipage}%
- \only<1>{\hspace*{9.49cm}}\strut
- \only<2->{\hfill$\Rightarrow$\hfill}%
- \begin{onlyenv}<2-8>
- \begin{minipage}{8.3cm}
- \begin{align*}
- x(t) &= \int v_x(t)\,dt
- \visible<4->{= \int v_{0x}\,dt}
- \visible<5->{= x_0 + v_{0x}\cdot t}\\[\medskipamount]
- y(t) &= \int v_y(t)\,dt
- \visible<7->{= \int v_{0y} - g\cdot t\,dt}
- \visible<8->{= y_0 + v_{0y}\cdot t
- - {\textstyle\frac12}gt^2}\\[\bigskipamount]
- v_x(t) &= \int 0\,dt
- \visible<3->{= v_{0x}} \\[\medskipamount]
- v_y(t) &= \int -g\,dt
- \visible<6->{= v_{0y} - g\cdot t}
- \end{align*}
- \end{minipage}%
- \end{onlyenv}%
- \begin{onlyenv}<9->
- \begin{minipage}{3.5cm}
- \vspace*{0.5cm}
- \begin{lstlisting}[gobble=8,xleftmargin=0.5em]
- ¡x += vx * dt;¿
- \end{lstlisting}
- \vspace{0.75cm}
- \begin{lstlisting}[gobble=8,xleftmargin=0.5em]
- ¡y += vy * dt;¿
- \end{lstlisting}
- \vspace{0.90cm}
- \begin{lstlisting}[gobble=8,xleftmargin=0.5em]
- ¡vx += 0 * dt;¿
- \end{lstlisting}
- \vspace{0.75cm}
- \begin{lstlisting}[gobble=8,xleftmargin=0.5em]
- ¡vy += -g * dt;¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}{5.13cm}
- Siehe: \file{gtk-13.c}
- \end{minipage}
- \end{onlyenv}%
- \hfill\strut
-
-\end{frame}
-
-\begin{frame}[fragile]
- \showsection
- \showsubsection
-
- \textbf{Beispiel 1: Gleichmäßig beschleunigte Bewegung}
-
- \medskip
-
- \textbf{Beispiel 2: Mathematisches Pendel}
-
- \vspace*{-2\bigskipamount}
-
- \begin{picture}(0,0)
- \put(8,-6.5){\includegraphics{pendulum.pdf}}
- \end{picture}
-
- \begin{eqnarray*}
- \varphi'(t) &=& \omega(t) \\[\smallskipamount]
- \omega'(t) &=& -\frac{g}{l}\cdot\sin\varphi(t)\hspace*{7.1cm}
- \end{eqnarray*}
- \vspace*{-1.5\medskipamount}
- \begin{itemize}
- \item
- Von Hand (analytisch):\\
- Lösung raten (Ansatz), Parameter berechnen
- \item
- Mit Computer (numerisch):\\
- Eulersches Polygonzugverfahren
- \end{itemize}
- \smallskip
- \begin{lstlisting}[gobble=0]
- phi += dt * omega;
- omega += - dt * g / l * sin (phi);
- \end{lstlisting}
-
- \pause
- \bigskip
-
- \textbf{Beispiel 3: Weltraum-Simulation}
-
- Praktikumsaufgabe
- \vspace*{-1cm}
-
-\end{frame}
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \begin{itemize}
- \item[4.1] Bit-Operationen
- \item[4.2] I/O-Ports
- \item[4.3] Interrupts
- \item[4.4] volatile-Variable
- \color{medgreen}
- \item[4.5] Byte-Reihenfolge -- Endianness
- \item[4.6] Binärdarstellung negativer Zahlen
- \item[4.7] Speicherausrichtung -- Alignment
- \end{itemize}
- \item[\textbf{5}] \textbf{Algorithmen}
- \begin{itemize}
- \color{medgreen}
- \item[5.1] Differentialgleichungen
- \color{red}
- \item[5.2] Rekursion
- \color{black}
- \item[5.3] Aufwandsabschätzungen
- \end{itemize}
- \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
- \item[\textbf{7}] \textbf{Datenstrukturen}
- \end{itemize}
-
-\end{frame}
-
-\setcounter{section}{4}
-\section{Algorithmen}
-\setcounter{subsection}{1}
-\subsection{Rekursion}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Vollständige Induktion:
- \vspace*{-0.725cm}
- \begin{displaymath}
- \hspace*{4cm}
- \left.
- \begin{array}{r}
- \mbox{Aussage gilt für $n = 1$}\\[2pt]
- \mbox{Schluß von $n - 1$ auf $n$}
- \end{array}
- \right\}
- \mbox{Aussage gilt für alle $n\in\mathbb{N}$}
- \end{displaymath}
- \vspace*{-0.5cm}
-
- \pause
-
- Türme von Hanoi
-
- \begin{onlyenv}<2>
- \begin{center}
- \includegraphics[width=12.2cm]{Tower_of_Hanoi.jpeg}
- \end{center}
- \end{onlyenv}
-
- \begin{onlyenv}<3->
- \begin{itemize}
- \item
- 64 Scheiben, 3 Plätze,
- \only<3-4>{\hfill\makebox(0,0)[rt]{\includegraphics[width=6cm]{Tower_of_Hanoi.jpeg}}}\\
- immer 1 Scheibe verschieben
- \item
- Ziel: Turm verschieben
- \item
- Es dürfen nur kleinere Scheiben\\
- auf größeren liegen.
- \bigskip
- \pause
- \pause
- \item
- $n = 1$ Scheibe: fertig
- \item
- Wenn $n - 1$ Scheiben verschiebbar:\\
- schiebe $n - 1$ Scheiben auf Hilfsplatz,\\
- verschiebe die darunterliegende,\\
- hole $n - 1$ Scheiben von Hilfsplatz
- \end{itemize}
- \begin{onlyenv}<5>
- \vspace{-4.3cm}
- \begin{lstlisting}[gobble=8,xleftmargin=6.4cm]
- void move (int from, int to, int disks)
- {
- if (disks == 1)
- move_one_disk (from, to);
- else
- {
- int help = 0 + 1 + 2 - from - to;
- move (from, help, disks - 1);
- move (from, to, 1);
- move (help, to, disks - 1);
- }
- }
- \end{lstlisting}
- \end{onlyenv}
-% \begin{onlyenv}<6->
-% \vspace{-5.0cm}
-% \hspace*{7.4cm}\begin{minipage}[t]{5cm}
-% 32 Scheiben:
-% \begin{lstlisting}[gobble=10,style=terminal]
-% $ ¡time ./hanoi-9b¿
-% ...
-% real 0m30,672s
-% user 0m30,662s
-% sys 0m0,008s
-% \end{lstlisting}
-% \pause[7]
-% \begin{itemize}
-% \arrowitem
-% etwas über 1 Minute\\
-% für 64 Scheiben
-% \end{itemize}
-% \pause
-% \vspace*{-0.5cm}
-% \begin{picture}(0,0)
-% \color{red}
-% \put(0,0){\makebox(0,0)[bl]{\tikz[line width=1pt]{\draw(0,0)--(4,0.8);}}}
-% \put(0,0.8){\makebox(0,0)[tl]{\tikz[line width=1pt]{\draw(0,0)--(4,-0.8);}}}
-% \end{picture}
-%
-% Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit!
-% % 30.672 * 2^32 / 3600 / 24 / 365.25 = 4174.43775518138261464750
-% \begin{itemize}
-% \arrowitem
-% $\frac{30,672\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4174$
-% Jahre\\[\smallskipamount]
-% für 64 Scheiben
-% \end{itemize}
-% \end{minipage}
-% \end{onlyenv}
- \end{onlyenv}
-
-\end{frame}
-
-\iffalse
-
-\subsection{Aufwandsabschätzungen \protect\color{gray}-- Komplexitätsanalyse}
-
-\begin{frame}[fragile]
-
-% \newcommand{\w}{\hspace*{0.75pt}}
-
- \showsubsection
-
- \begin{picture}(0,0)
- \put(7.6,-0.5){%
- \begin{minipage}[t]{5.3cm}
-% \vspace*{-1.0cm}\includegraphics{landau-symbols.pdf}
- \vspace*{-1.0cm}\alt<16->{\includegraphics{landau-symbols-3.pdf}}%
- {\alt<15->{\includegraphics{landau-symbols-2.pdf}}%
- {\includegraphics{landau-symbols.pdf}}}
- \small
- \begin{description}\itemsep0pt\leftskip-0.5cm
- \item[$n$:] Eingabedaten
- \item[$g(n)$:] Rechenzeit
- \end{description}
- \end{minipage}}
- \end{picture}
-
- \vspace*{-\bigskipamount}
-
- Wann ist ein Programm "`schnell"'?
-
- \medskip
-
- \begin{onlyenv}<1-2>
- Türme von Hanoi: $\mathcal{O}(2^n)$
- \par\medskip
- Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit!
- \begin{itemize}
- \arrowitem
- $\frac{30,672\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4174$
- Jahre\\[\smallskipamount]
- für 64 Scheiben
- \end{itemize}
-
- \bigskip
- \end{onlyenv}
-
- \begin{onlyenv}<2->
- Faustregel:\\Schachtelung der Schleifen zählen\\
- $k$ Schleifen ineinander \textarrow\ $\mathcal{O}(n^k)$
-
- \bigskip
- \end{onlyenv}
-
- \begin{onlyenv}<3-13>
- \textbf{Beispiel: Sortieralgorithmen}
-
- \smallskip
-
- Anzahl der Vergleiche bei $n$ Strings
- \begin{itemize}
- \item
- Maximum suchen \pause[4]mit Schummeln\pause: $\mathcal{O}(1)$
- \pause
- \item
- Maximum suchen\pause: $\mathcal{O}(n)$
- \pause
- \item
- Selection-Sort\pause: $\mathcal{O}(n^2)$
- \pause
- \item
- Bubble-Sort\pause: $\mathcal{O}(n)$ bis $\mathcal{O}(n^2)$
- \pause
- \item
- Quicksort\pause: $\mathcal{O}(n\log n)$ bis $\mathcal{O}(n^2)$
- \end{itemize}
-
- \end{onlyenv}
-
- \begin{onlyenv}<14>
- \textbf{Wie schnell ist RSA-Verschlüsselung?}
-
- \smallskip
-
- \begin{math}
- c = m^e\,\%\,N
- \end{math}
- \quad
- ("`$\%$"' = "`modulo"')
-
- \medskip
-
- \begin{lstlisting}[gobble=6,xleftmargin=2em]
- int c = 1;
- for (int i = 0; i < e; i++)
- c = (c * m) % N;
- \end{lstlisting}
-
- \smallskip
-
- \begin{itemize}
- \item
- $\mathcal{O}(e)$ Iterationen
-% \item
-% wenn $n$ die Anzahl der Binärziffern (Bits) von $e$ ist:
-% $\mathcal{O}(2^n)$ Iterationen
- \item
- mit Trick:
- $\mathcal{O}(\log e)$ Iterationen ($\log e$ = Anzahl der Ziffern von $e$)
- \end{itemize}
-
- \smallskip
-
- Jede Iteration enthält eine Multiplikation und eine Division.\\
- Aufwand dafür: $\mathcal{O}(\log e)$\\
- \textarrow\ Gesamtaufwand: $\mathcal{O}\bigl((\log e)^2\bigr)$
-
- \end{onlyenv}
-
- \begin{onlyenv}<15->
-
- \textbf{Wie schnell ist RSA?}\\
-
- \smallskip
-
- ($n$ = typische beteiligte Zahl, z.\,B. $e,p,q$)
-
- \begin{itemize}
- \item
- Ver- und Entschlüsselung (Exponentiation):\\
- \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\!\left((\log n)^2\right)$\hss}
- \only<16->{{\color{magenta}$\mathcal{O}(n^2)$}}
- \item
- Schlüsselerzeugung (Berechnung von $d$):\\
- \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\!\left((\log n)^2\right)$\hss}
- \only<16->{{\color{magenta}$\mathcal{O}(n^2)$}}
- \item
- Verschlüsselung brechen (Primfaktorzerlegung):\\
- \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\bigl(2^{\sqrt{\log n\,\cdot\,\log\log n}}\bigr)$\hss}
- \only<16->{{\color{magenta}$\mathcal{O}\bigl(2^{\sqrt{n\log n}}\bigr)$}}
- \end{itemize}
-
- \vspace{0cm plus 1filll}
-
- \textbf{Die Sicherheit von RSA beruht darauf,
- daß das Brechen der Verschlüsselung aufwendiger ist als
- \boldmath$\mathcal{O}\bigl((\log n)^k\bigr)$ (für beliebiges $k$).}
-
- \vspace*{0.65cm}
-
- \end{onlyenv}
-
-\end{frame}
-
-\fi
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \begin{itemize}
- \item[4.1] Bit-Operationen
- \item[4.2] I/O-Ports
- \item[4.3] Interrupts
- \item[4.4] volatile-Variable
- \color{medgreen}
- \item[4.5] Byte-Reihenfolge -- Endianness
- \item[4.6] Binärdarstellung negativer Zahlen
- \item[4.7] Speicherausrichtung -- Alignment
- \end{itemize}
- \item[\textbf{5}] \textbf{Algorithmen}
- \begin{itemize}
- \color{medgreen}
- \item[5.1] Differentialgleichungen
- \item[5.2] Rekursion
- \color{red}
- \item[5.3] Aufwandsabschätzungen
- \end{itemize}
- \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
- \item[\textbf{7}] \textbf{Datenstrukturen}
- \end{itemize}
-
-\end{frame}
-
-\end{document}
diff --git a/20221114/hp-2022ws-p3.pdf b/20221114/hp-2022ws-p3.pdf
deleted file mode 100644
index 798b215947f498d64b4ce1a884ede98669735dcb..0000000000000000000000000000000000000000
Binary files a/20221114/hp-2022ws-p3.pdf and /dev/null differ
diff --git a/20221114/hp-2022ws-p3.tex b/20221114/hp-2022ws-p3.tex
deleted file mode 100644
index d366456f39591a64cc89aae08697e7cef769718b..0000000000000000000000000000000000000000
--- a/20221114/hp-2022ws-p3.tex
+++ /dev/null
@@ -1,288 +0,0 @@
-% hp-2022ws-p3.pdf - Labor Notes on Low-Level Programming
-% Copyright (C) 2014, 2015, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Versuch 3: Weltraum-Simulation
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-\usepackage{multicol}
-%\usepackage{sfmath}
-
-\sloppy
-\raggedcolumns
-\pagestyle{empty}
-\addtolength{\textheight}{1cm}
-\newcommand{\sep}{~$\cdot$~}
-\newcommand{\mylicense}{CC BY-SA (Version 4.0) oder GNU GPL (Version 3 oder höher)}
-
-\begin{document}
-
- \makebox(0,0.005)[tl]{\includegraphics[scale=0.72]{logo-hochschule-bochum-cvh-text-v2.pdf}}\hfill
- \makebox(0,0)[tr]{\includegraphics[scale=0.5]{logo-hochschule-bochum.pdf}}
- \par\bigskip\bigskip
- \begin{center}
- \Large\textbf{Praktikumsversuch 3: Weltraum-Simulation}
- \par\medskip
- \normalsize Hardwarenahe Programmierung\sep
- Wintersemester 2022/23\sep
- Prof.~Dr.~Peter Gerwinski
- \end{center}
-
- Aufgabe: Schreiben Sie ein C-Programm,
- das die Bahnen von beliebig vielen Massenpunkten unter Einfluß der Gravitation
- simuliert und in bewegter Grafik darstellt.
-
- \begin{multicols}{2}
-
- \begin{itemize}
- \item
- Zwei Massenpunkte ("`Himmelskörper"') mit den Massen $m_i$ und $m_j$
- an den Orten $\vec{r}_i$ und $\vec{r}_j$ ziehen einander an.
- Diese Kraft heißt Gravitation. Sie hat den Betrag:
- \begin{equation}
- |\vec{F}_{ij}| = \frac{m_j\cdot m_i\cdot G}{|\vec{r}_j - \vec{r}_i|^2}
- \end{equation}
- Hierbei ist $G$ eine Konstante (Gravitationskonstante).
-
- \item
- Die auf einen Himmelskörper wirkende Gesamtkraft $\vec{F}_i$
- ergibt sich als Summe der von allen anderen Himmelskörpern herrührenden
- Gravitationskräfte:
- \begin{equation}
- \vec{F}_i = \sum_{j=0,\,j\ne i}^{N - 1} \vec{F}_{ij}
- \end{equation}
-
- \item
- Die Gravitationskraft beschleunigt jeden Himmelskörper gemäß:
- \begin{equation}
- \vec{F_i} = m_i\cdot \vec{a_i}
- \end{equation}
-
- \item
- Beispiel: Wir betrachten zwei Himmelskörper. Einer davon ("`Zentralgestirn"')
- ruht im Zentrum ($\vec{r}_0 = 0$, $\vec{v}_0 = 0$)
- und hat eine wesentlich größere Masse als der andere
- ("`Satellit"', $m_1 \ll m_0$). Mit geeignetem Anfangsort $\vec{r}_1$
- und geeigneter Anfangsgeschwindigkeit $\vec{v}_1$ beschreibt dann
- der Satellit eine elliptische Umlaufbahn um das Zentralgestirn.
-
- \item
- Wir rechnen in zwei Dimensionen $x$ und $y$.
-
- \item
- Für die Zerlegung einer Kraft $\vec{F}_{ij}$ in $x$- und $y$-Komponenten
- benötigen Sie nur die Grundrechenarten und die Wurzelfunktion,
- jedoch insbesondere \emph{keine} trigonometrischen Funktionen:
- \begin{equation}
- \vec{F}_{ij} = |\vec{F}_{ij}| \cdot \frac{\vec{r}_j - \vec{r}_i}{|\vec{r}_j - \vec{r}_i|}
- \end{equation}
-
- \item
- Die Wurzelfunktion \lstinline{sqrt()} finden Sie
- in der Mathematik-Bibliothek.
- Um diese zu nutzen, verwenden Sie \lstinline{#include <math.h>} im Quelltext,
- und geben Sie beim \lstinline[style=cmd]{gcc}-Aufruf
- \lstinline[style=cmd]{-lm} mit an.
-
- \item
- Speichern Sie die verschiedenen Körper nicht als separate Variable,
- sondern in einem Array. Ihr Programm wird dadurch nicht nur flexibler,
- sondern auch übersichtlicher und weniger fehleranfällig.
-
-% \columnbreak
-
- \item
- Für die Simulation betrachten wir das System in kurzen Zeitintervallen $dt$
- und berechnen die Änderungen des Ortes $\vec{r}_i = (x_i,y_i)$
- und der Geschwindigkeit $\vec{v}_i = (v_{xi},v_{yi})$ jedes Himmelskörpers
- mit Hilfe des expliziten Eulerschen Polygonzugverfahrens.
- \par
- (Wer möchte, darf natürlich auch andere Verfahren anwenden,
- beispielsweise das klassische Runge-Kutta-Verfahren 4.~Ordnung.)
-
- \item
- Für eine derartige Simulation
- einschließlich ihrer Darstellung als bewegte Grafik
- können Sie sich von dem Beispiel-Programm \gitfile{hp}{2022ws/20221114}{pendulum-1.c}
- inspirieren lassen.
-% (Compilieren mit:
-% \lstinline[style=cmd]{gcc}
-% \lstinline[style=cmd]{-Wall}
-% \lstinline[style=cmd]{-O}
-% \lstinline[style=cmd]{gtk-16.c}
-% \lstinline[style=cmd]{$(pkg-config}
-% \lstinline[style=cmd]{--cflags}
-% \lstinline[style=cmd]{--libs}
-% \lstinline[style=cmd]{gtk+-3.0)}
-% \lstinline[style=cmd]{-o}
-% \lstinline[style=cmd]{gtk-16})
-
- \item
- In einer \file{GTK+}-\lstinline{drawing_area}
- liegt der Nullpunkt der Zeichnung oben links,
- eine Längeneinheit entspricht einem Pixel,
- und die $y$-Koordinate wächst nach unten.
- Es empfiehlt sich, die Koordinaten so umzurechnen,
- daß der Nullpunkt in der Mitte der Zeichnung liegt,
- die Längeneinheit Ihrem persönlichen Geschmack entspricht
- und die $y$-Koordinate nach oben wächst.
-
- \item
- Beispiel-Szenarien für 3 oder mehr Körper:
- \vspace{-\smallskipamount}
- \begin{itemize}\itemsep0pt
- \item
- Planet mit Mond umkreist Sonne
- \item
- Sonne mit mehreren Planeten, die sich gegenseitig beeinflussen
- \item
- zwei Sonnen umkreisen sich gegenseitig, Planet kreist drumherum
- \item
- Raumsonde besucht nacheinander mehrere Planeten
- \end{itemize}
-
- \end{itemize}
-
- \end{multicols}
-
- \bigskip
- \textbf{GTK unter GNU/Linux}
- \begin{itemize}
- \item
- Installieren Sie das Entwickler-Paket für GTK-3,\\
- z.\,B.\ unter Debian GNU/Linux und darauf basierenden Systemen:
- \begin{lstlisting}[style=cmd,gobble=8]
- apt-get install libgtk-3-dev
- \end{lstlisting}
- \end{itemize}
-
- \bigskip
- \goodbreak
- \textbf{GTK unter MacOS X}
- \begin{itemize}
- \item
- Zuerst den Paketmanager "`Homebrew"' installieren:
- \begin{lstlisting}[style=cmd,gobble=8]
- ruby -e "$(curl -fsSL https://raw.githubusercontent.com/
- Homebrew/install/2020ws/install)"
- \end{lstlisting}
- (Die URL nicht trennen, sondern in einer Zeile schreiben.)
- \item
- Danach mit Hilfe von \lstinline[style=cmd]{brew} GTK installieren:
- \begin{lstlisting}[style=cmd,gobble=8]
- brew install gtk+3
- \end{lstlisting}
- \end{itemize}
-
- \bigskip
- \goodbreak
- \textbf{GTK unter Microsoft Windows: Cygwin}
- \begin{itemize}
- \item
- Im Cygwin-Setup-Programm die Pakete \file{libgtk3-devel},
- \file{xorg-server} und \file{dbus-x11} installieren.
- \item
- Bevor Sie GTK-Programme starten können,
- müssen Sie einmalig den X-Server starten:
- \begin{lstlisting}[style=cmd,gobble=8]
- XWin -multiwindow &
- \end{lstlisting}
- \item
- Bevor Sie GTK-Programme starten können,
- müssen Sie einmalig pro Shell-Sitzung\\
- die \lstinline[style=cmd]{DISPLAY}-Variable setzen:
- \begin{lstlisting}[style=cmd,gobble=8]
- export DISPLAY=:0.0
- \end{lstlisting}
- \end{itemize}
-
- \bigskip
- \goodbreak
- \textbf{GTK unter Microsoft Windows: MinGW}
- \begin{itemize}
- \item
- Installieren Sie \file{MSYS2} (Installer).
- \item
- Installieren Sie von der MinGW-Shell aus GTK
- und weitere Entwicklungswerkzeuge:
- \begin{lstlisting}[style=cmd,gobble=8]
- pacman -S mingw-w64-x86_64-gcc
- pacman -S mingw-w64-x86_64-gtk3
- pacman -S mingw-w64-x86_64-pkg-config
- \end{lstlisting}
- \item
- Falls nötig, ergänzen Sie in der MinGW-Shell
- den Pfad zu den neu installierten Programmen:
- \begin{lstlisting}[style=cmd,gobble=8]
- export PATH=$PATH:/mingw64/bin
- \end{lstlisting}
- \end{itemize}
-
- \bigskip
- \goodbreak
- \textbf{GTK unter Microsoft Windows: WSL}
- \begin{itemize}
- \item
- Installieren Sie die GTK-Entwicklungswerkzeuge in ihrer Linux-Umgebung (siehe oben).
- \item
- Installieren Sie einen X-Server für Ihr MS-Windows-System, z.\,B.\ \file{Xming}.
- \item
- Starten Sie Ihren X-Server mit \file{XLaunch}
- und wählen Sie \emph{no access control} aus.
- \item
- Bevor Sie GTK-Programme starten können,
- müssen Sie einmalig pro Shell-Sitzung\\
- die \lstinline[style=cmd]{DISPLAY}-Variable setzen:
- \begin{lstlisting}[style=cmd,gobble=8]
- export DISPLAY=$(cat /etc/resolv.conf \
- | grep nameserver | awk '{print $2}'):0
- \end{lstlisting}
- (Der Backslash ist ein Zeilen-Verlängerungszeichen. Wenn Sie den gesamten\\
- Befehl in einer Zeile eingeben, entfällt der Backslash.)
- \end{itemize}
-
- \vspace*{-\bigskipamount}
-
- \strut\hfill\emph{Viel Erfolg!}\qquad\qquad
-
- \vfill
-
- \begingroup
-
- \small
-
- \setlength{\leftskip}{3cm}
-
- Stand: 17.\ November 2022
-
-% Soweit nicht anders angegeben:\\
- Copyright \copyright\ 2014, 2015, 2018, 2019, 2020, 2021, 2022\quad Peter Gerwinski\\
- Lizenz: \mylicense
-
- Sie können diese Praktikumsunterlagen einschließlich \LaTeX-Quelltext
- und Beispielprogramm herunterladen unter:
- \url{https://gitlab.cvh-server.de/pgerwinski/hp}
-
- \endgroup
-
-\end{document}
diff --git a/20221114/hp-musterloesung-20221114.pdf b/20221114/hp-musterloesung-20221114.pdf
deleted file mode 100644
index 641f3edd6955f1e19955d2b1e9344178a903a268..0000000000000000000000000000000000000000
Binary files a/20221114/hp-musterloesung-20221114.pdf and /dev/null differ
diff --git a/20221114/hp-musterloesung-20221114.tex b/20221114/hp-musterloesung-20221114.tex
deleted file mode 100644
index 6a752bf49af2c27b551e498ef2cb485b127d628d..0000000000000000000000000000000000000000
--- a/20221114/hp-musterloesung-20221114.tex
+++ /dev/null
@@ -1,484 +0,0 @@
-% hp-musterloesung-20221031.pdf - Solutions to the Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Trickprogrammierung, Thermometer-Baustein an I²C-Bus, Speicherformate von Zahlen
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-\usepackage{gensymb}
-
-\newcommand{\ItwoC}{I\raisebox{0.5ex}{\footnotesize 2}C}
-\newcommand{\ITWOC}{I\raisebox{0.5ex}{\normalsize 2}C}
-
-\begin{document}
-
- \section*{Hardwarenahe Programmierung\\
- Musterlösung zu den Übungsaufgaben -- 14.\ November 2022}
-
- \exercise{Trickprogrammierung}
-
- Wir betrachten das folgende Programm (Datei: \gitfile{hp}{2022ws/20221114}{aufgabe-1.c}):
- \begin{lstlisting}
- #include <stdio.h>
- #include <stdint.h>
-
- int main (void)
- {
- uint64_t x = 4262939000843297096;
- char *s = &x;
- printf ("%s\n", s);
- return 0;
- }
- \end{lstlisting}
- Das Programm wird compiliert und auf einem 64-Bit-Little-Endian-Computer ausgeführt:
- \begin{lstlisting}[style=terminal]
- $ ¡gcc -Wall -O aufgabe-1.c -o aufgabe-1¿
- aufgabe-1.c: In function `main':
- aufgabe-1.c:7:13: warning: initialization from incompatible pointer type [...]
- $ ¡./aufgabe-1¿
- Hallo
- \end{lstlisting}
-
- \begin{itemize}
- \item[(a)]
- Erklären Sie die Warnung beim Compilieren. \points{2}
- \item[(b)]
- Erklären Sie die Ausgabe des Programms. \points{5}
- \item[(c)]
- Wie würde die Ausgabe des Programms auf einem 64-Bit-Big-Endian-Computer lauten? \points{3}
- \end{itemize}
- Hinweis: Modifizieren Sie das Programm
- und lassen Sie sich Speicherinhalte ausgeben.
-
- \solution
-
- \begin{itemize}
- \item[(a)]
- \textbf{Erklären Sie die Warnung beim Compilieren.}
-
- Zeile 7 des Programms enthält eine Zuweisung von \lstinline{&x}
- an die Variable \lstinline{s}.
- Der Ausdruck \lstinline{&x} steht für die Speicheradresse der Variablen \lstinline{x},
- ist also ein Zeiger auf \lstinline{x},
- also ein Zeiger auf eine \lstinline{uint64_t}.
- Die Variable \lstinline{s} hingegen ist ein Zeiger auf \lstinline{char},
- also ein Zeiger auf eine viel kleinere Zahl,
- also ein anderer Zeigertyp.
-
- \item[(b)]
- \textbf{Erklären Sie die Ausgabe des Programms.}
-
- Die 64-Bit-Zahl (\lstinline{uint64_t}) \lstinline{x}
- belegt 8 Speicherzellen (Bytes) von jeweils 8 Bit.
- Um herauszufinden, was diese enthalten,
- lassen wir uns \lstinline{x} als Hexadezimalzahl ausgeben,
- z.\,B.\ mittels \lstinline{printf ("%lx\n", x)}
- (auf 32-Bit-Rechnern: \lstinline{"%llx\n"})
- oder mittels \lstinline{printf ("%" PRIx64 "\n", x)}
- (erfordert \lstinline{#include <inttypes.h>}
- -- siehe die Datei \gitfile{hp}{2022ws/20221114}{loesung-1-1.c}).
- Das Ergebnis lautet:
- \begin{lstlisting}[style=terminal,gobble=8]
- 3b29006f6c6c6148
- \end{lstlisting}
- Auf einzelne Bytes verteilt:
- \begin{lstlisting}[style=terminal,gobble=8]
- 3b 29 00 6f 6c 6c 61 48
- \end{lstlisting}
- Auf einem Little-Endian-Rechner
- ist die Reihenfolge der Bytes in den Speicherzellen genau umgekehrt:
- \begin{lstlisting}[style=terminal,gobble=8]
- 48 61 6c 6c 6f 00 29 3b
- \end{lstlisting}
- Wenn wir uns diese Bytes als Zeichen ausgeben lassen
- (\lstinline{printf()} mit \lstinline{%c} -- siehe die Datei \gitfile{hp}{2022ws/20221114}{loesung-1-2.c}),
- erhalten wir:
- \begin{lstlisting}[style=terminal,gobble=8]
- H a l l o ) ;
- \end{lstlisting}
- Das Zeichen hinter "`Hallo"' ist ein Null-Symbol (Zahlenwert 0)
- und wird von \lstinline{printf ("%s")} als Ende des Strings erkannt.
- Damit ist die Ausgabe \lstinline[style=terminal]{Hallo}
- des Programms erklärt.
-
- \goodbreak
- \item[(c)]
- \textbf{Wie würde die Ausgabe des Programms auf einem 64-Bit-Big-Endian-Computer lauten?}
-
- Auf einem Big-Endian-Computer (egal, wieviele Bits die Prozessorregister haben)
- ist die Reihenfolge der Bytes in den Speicherzellen genau umgekehrt
- wie auf einem Little-Endian-Computer, hier also:
- \begin{lstlisting}[style=terminal,gobble=8]
- 3b 29 00 6f 6c 6c 61 48
- \end{lstlisting}
- \lstinline{printf ("%s")} gibt in diesem Fall die Hexadezimalzahlen
- \lstinline[style=terminal]{3b} und \lstinline[style=terminal]{29}
- als Zeichen aus. Danach steht das String-Ende-Symbol mit Zahlenwert 0,
- und die Ausgabe bricht ab.
- Da, wie oben ermittelt, die Hexadezimalzahl \lstinline[style=terminal]{3b}
- für das Zeichen \lstinline[style=terminal]{;}
- und \lstinline[style=terminal]{29}
- für das Zeichen \lstinline[style=terminal]{)} steht,
- lautet somit die Ausgabe:
- \begin{lstlisting}[style=terminal,gobble=8]
- ;)
- \end{lstlisting}
- Um die Aufgabe zu lösen, können Sie übrigens auch
- auf einem Little-Endian-Computer (Standard-Notebook)
- einen Big-Endian-Computer simulieren,
- indem Sie die Reihenfolge der Bytes in der Zahl \lstinline{x} umdrehen
- -- siehe die Datei \gitfile{hp}{2022ws/20221114}{loesung-1-3.c}.
- \end{itemize}
-
- \exercise{Thermometer-Baustein an \ITWOC-Bus}
-
- Eine Firma stellt einen elektronischen Thermometer-Baustein her,
- den man über die serielle Schnittstelle (RS-232) an einen PC anschließen kann,
- um die Temperatur auszulesen.
- Nun wird eine Variante des Thermo"-meter-Bausteins entwickelt,
- die die Temperatur zusätzlich über einen \ItwoC-Bus bereitstellt.
-
- Um das neue Thermometer zu testen, wird es in ein Gefäß mit heißem Wasser gelegt,
- das langsam auf Zimmertemperatur abkühlt.
- Alle 10 Minuten liest ein Programm, das auf dem PC läuft,
- die gemessene Temperatur über beide Schnittstellen aus
- und erzeugt daraus die folgende Tabelle:
-
- \begin{center}
- \renewcommand{\arraystretch}{1.2}
- \begin{tabular}{|c|c|c|}\hline
- Zeit /\,min. & Temperatur per RS-232 /\,\degree C & Temperatur per \ItwoC\ /\,\degree C \\\hline\hline
- \phantom{0}0 & 94 & 122 \\\hline
- 10 & 47 & 244 \\\hline
- 20 & 30 & 120 \\\hline
- 30 & 24 & \phantom{0}24 \\\hline
- 40 & 21 & 168 \\\hline
- \end{tabular}
- \end{center}
-
- \begin{itemize}
- \item[(a)]
- Aus dem Vergleich der Meßdaten läßt sich
- auf einen Fehler bei der \ItwoC-Übertragung schließen.\\
- Um welchen Fehler handelt es sich,
- und wie ergibt sich dies aus den Meßdaten?
- \points{5}
- \item[(b)]
- Schreiben Sie eine C-Funktion \lstinline{uint8_t repair (uint8_t data)},
- die eine über den \ItwoC-Bus empfangene fehlerhafte Temperatur \lstinline{data} korrigiert.
- \points{5}
- \end{itemize}
-
- \solution
-
- \begin{itemize}
- \item[(a)]
- \textbf{Aus dem Vergleich der Meßdaten läßt sich
- auf einen Fehler bei der \ItwoC-Übertragung schließen.
- Um welchen Fehler handelt es sich,
- und wie ergibt sich dies aus den Meßdaten?}
-
- Sowohl RS-232 als auch \ItwoC\ übertragen die Daten Bit für Bit.
- Für die Fehlersuche ist es daher sinnvoll,
- die Meßwerte als Binärzahlen zu betrachten:
-
- \begin{center}
- \renewcommand{\arraystretch}{1.2}
- \begin{tabular}{|c|c|c|}\hline
- Zeit /\,min. & Temperatur per RS-232 /\,\degree C & Temperatur per \ItwoC\ /\,\degree C \\\hline\hline
- \phantom{0}0 & 94$_{10}$ = 01011110$_2$ & 122$_{10}$ = 01111010$_2$ \\\hline
- 10 & 47$_{10}$ = 00101111$_2$ & 244$_{10}$ = 11110100$_2$ \\\hline
- 20 & 30$_{10}$ = 00011110$_2$ & 120$_{10}$ = 01111000$_2$ \\\hline
- 30 & 24$_{10}$ = 00011000$_2$ & \phantom{0}24$_{10}$ = 00011000$_2$ \\\hline
- 40 & 21$_{10}$ = 00010101$_2$ & 168$_{10}$ = 10101000$_2$ \\\hline
- \end{tabular}
- \end{center}
-
- Man erkennt, daß die Reihenfolge der Bits in den (fehlerhaften) \ItwoC-Meßwerten
- genau die umgekehrte Reihenfolge der Bits in den (korrekten) RS-232-Mewßwerten ist.
- Der Übertragungsfehler besteht also darin,
- daß die Bits in der falschen Reihenfolge übertragen wurden.
-
- Dies paßt gut damit zusammen,
- daß die Bit-Reihenfolge von \ItwoC\ \emph{MSB First}, die von RS-232 hingegen \emph{LSB First\/} ist.
- Offenbar haben die Entwickler der \ItwoC-Schnittstelle dies übersehen
- und die \ItwoC-Daten ebenfalls \emph{LSB First\/} übertragen.
-
- \goodbreak
- \item[(b)]
- \textbf{Schreiben Sie eine C-Funktion \lstinline{uint8_t repair (uint8_t data)},
- die eine über den \ItwoC-Bus empfangene fehlerhafte Temperatur \lstinline{data} korrigiert.}
-
- Die Aufgabe der Funktion besteht darin,
- eine 8-Bit-Zahl \lstinline{data} entgegenzunehmen,
- die Reihenfolge der 8 Bits genau umzudrehen
- und das Ergebnis mittels \lstinline{return} zurückzugeben.
-
- Zu diesem Zweck gehen wir die 8 Bits in einer Schleife durch
- -- siehe die Datei \gitfile{hp}{2022ws/20221114}{loesung-2.c}.
- Wir lassen eine Lese-Maske \lstinline{mask_data} von rechts nach links
- und gleichzeitig eine Schreib-Maske \lstinline{mask_result}
- von links nach rechts wandern.
- Immer wenn die Lese-Maske in \lstinline{data} eine 1 findet,
- schreibt die Schreib-Maske diese in die Ergebnisvariable \lstinline{result}.
-
- Da \lstinline{result} auf 0 initialisiert wurde,
- brauchen wir Nullen nicht hineinzuschreiben.
- Ansonsten wäre dies mit \lstinline{result &= ~mask_result} möglich.
-
- Um die Schleife bis 8 zählen zu lassen,
- könnte man eine weitere Zähler-Variable von 0 bis 7 zählen lassen,
- z.\,B.\ \lstinline{for (int i = 0; i < 8; i++)}.
- Dies ist jedoch nicht nötig, wenn man beachtet,
- daß die Masken den Wert 0 annehmen,
- sobald das Bit aus der 8-Bit-Variablen herausgeschoben wurde.
- In \gitfile{hp}{2022ws/20221114}{loesung-2.c} wird \lstinline{mask_data} auf 0 geprüft;
- genausogut könnte man auch \lstinline{mask_result} prüfen.
-
- Das \lstinline{return result} ist notwendig.
- Eine Ausgabe des Ergebnisses per \lstinline{printf()} o.\,ä.\
- erfüllt \emph{nicht\/} die Aufgabenstellung.
- (In \gitfile{hp}{2022ws/20221114}{loesung-2.c} erfolgt entsprechend \lstinline{printf()}
- nur im Testprogramm \lstinline{main()}.)
- \end{itemize}
-
- \exercise{Speicherformate von Zahlen}
-
- Wir betrachten das folgende Programm (\gitfile{hp}{2022ws/20221114}{aufgabe-3.c}):
- \begin{lstlisting}
- #include <stdio.h>
- #include <stdint.h>
-
- typedef struct
- {
- uint32_t a;
- uint64_t b;
- uint8_t c;
- } three_numbers;
-
- int main (void)
- {
- three_numbers xyz = { 1819042120, 2410670883059281007, 0 };
- printf ("%s\n", &xyz);
- return 0;
- }
- \end{lstlisting}
-
- Das Programm wird für einen 32-Bit-Rechner compiliert und ausgeführt.\\
- (Die \lstinline[style=cmd]{gcc}-Option \lstinline[style=cmd]{-m32} sorgt dafür,
- daß \lstinline[style=cmd]{gcc} Code für einen 32-Bit-Prozessor erzeugt.)
-
- \begin{lstlisting}[style=terminal]
- $ ¡gcc -Wall -m32 aufgabe-2.c -o aufgabe-2¿
- aufgabe-2.c: In function "main":
- aufgabe-2.c:14:13: warning: format "%s" expects argument of type "char *", but
- argument 2 has type "three_numbers * {aka struct <anonymous> *}" [-Wformat=]
- printf ("%s\n", &xyz);
- ^
- $ ¡./aufgabe-2¿
- Hallo, Welt!
- \end{lstlisting}
-
- \begin{enumerate}[\quad(a)]
- \item
- Erklären Sie die beim Compilieren auftretende Warnung.
- \points{2}
- \item
- Erklären Sie die Ausgabe des Programms.
- \points{4}
- \item
- Welche Endianness hat der verwendete Rechner?
- Wie sähe die Ausgabe auf einem Rechner mit entgegengesetzter Endianness aus?
- \points{2}
- \item
- Dasselbe Programm wird nun für einen 64-Bit-Rechner compiliert und ausgeführt.\\
- (Die \lstinline[style=cmd]{gcc}-Option \lstinline[style=cmd]{-m64} sorgt dafür,
- daß \lstinline[style=cmd]{gcc} Code für einen 64-Bit-Prozessor erzeugt.)
- \begin{lstlisting}[style=terminal,gobble=8]
- $ ¡gcc -Wall -m64 aufgabe-2.c -o aufgabe-2¿
- aufgabe-2.c: In function "main":
- aufgabe-2.c:14:13: warning: format "%s" expects argument of type "char *",
- but argument 2 has type "three_numbers * {aka struct <anonymous> *}"
- [-Wformat=]
- printf ("%s\n", &xyz);
- ^
- $ ¡./aufgabe-2¿
- Hall5V
- \end{lstlisting}
- (Es ist möglich, daß die konkrete Ausgabe auf Ihrem Rechner anders aussieht.)\par
- Erklären Sie die geänderte Ausgabe des Programms.
- \points{3}
- \end{enumerate}
-
- \solution
-
- \begin{enumerate}[\quad(a)]
- \item
- \textbf{Erklären Sie die beim Compilieren auftretende Warnung.}
-
- Die Funktion \lstinline{printf()} mit der Formatspezifikation \lstinline{%s}
- erwartet als Parameter einen String, d.\,h.\ einen Zeiger auf \lstinline{char}.
- Die Adresse (\lstinline{&}) der Variablen \lstinline{xyz}
- ist zwar ein Zeiger, aber nicht auf \lstinline{char},
- sondern auf einen \lstinline{struct} vom Typ \lstinline{three_numbers}.
- Eine implizite Umwandlung des Zeigertyps ist zwar möglich,
- aber normalerweise nicht das, was man beabsichtigt.
-
- \item
- \textbf{Erklären Sie die Ausgabe des Programms.}
-
- Ein String in C ist ein Array von \lstinline{char}s
- bzw.\ ein Zeiger auf \lstinline{char}.
- Da die Funktion \lstinline{printf()} mit der Formatspezifikation \lstinline{%s}
- einen String erwartet, wird sie das, worauf der übergebene Zeiger zeigt,
- als ein Array von \lstinline{char}s interpretieren.
- Ein \lstinline{char} entspricht einer 8-Bit-Speicherzelle.
- Um die Ausgabe des Programms zu erklären, müssen wir daher
- die Speicherung der Zahlen in den einzelnen 8-Bit-Speicherzellen betrachten.
-
- Hierfür wandeln wir zunächst die Zahlen von Dezimal nach Hexadezimal um.
- Sofern nötig (hier nicht der Fall) füllen wir von links mit Nullen auf,
- um den gesamten von der Variablen belegten Speicherplatz zu füllen
- (hier: 32 Bit, 64 Bit, 8 Bit).
- Jeweils 2 Hex-Ziffern stehen für 8 Bit.
- \begin{center}
- \begin{tabular}{rcl}
- dezimal & & hexadezimal \\[\smallskipamount]
- 1\,819\,042\,120 & = & 6C\,6C\,61\,48 \\
- 2\,410\,670\,883\,059\,281\,007 & = & 21\,74\,6C\,65\,57\,20\,2C\,6F \\
- 0 & = & 00
- \end{tabular}
- \end{center}
- Die Anordnung dieser 8-Bit-Zellen im Speicher lautet
- \textbf{auf einem Big-Endian-Rechner} wie folgt:
- \begin{center}
- \begin{tabular}{|c|c|c|c|c|c|c|c|c|c|c|c|c|}\hline
- \raisebox{0.5ex}{\strut}
- 6C & 6C & 61 & 48 &
- 21 & 74 & 6C & 65 & 57 & 20 & 2C & 6F &
- 00
- \\\hline
- \end{tabular}\\[-4.2ex]
- \kern1.7em%
- $\underbrace{\rule{9.8em}{0pt}}_{\mbox{\lstinline{a}}}$\kern1pt%
- $\underbrace{\rule{18.8em}{0pt}}_{\mbox{\lstinline{b}}}$\kern1pt%
- $\underbrace{\rule{2.2em}{0pt}}_{\mbox{\lstinline{c}}}$%
- \end{center}
- \textbf{Auf einem Little-Endian-Rechner} lautet sie hingegen:
- \begin{center}
- \begin{tabular}{|c|c|c|c|c|c|c|c|c|c|c|c|c|}\hline
-% \raisebox{0.5ex}{\strut}
-% H & a & l & l &
-% o & , & & W & e & l & t & ! & \\\hline
- \raisebox{0.5ex}{\strut}
- 48 & 61 & 6C & 6C &
- 6F & 2C & 20 & 57 & 65 & 6C & 74 & 21 &
- 00
- \\\hline
- \end{tabular}\\[-4.2ex]
- \kern1.7em%
- $\underbrace{\rule{9.8em}{0pt}}_{\mbox{\lstinline{a}}}$\kern1pt%
- $\underbrace{\rule{18.8em}{0pt}}_{\mbox{\lstinline{b}}}$\kern1pt%
- $\underbrace{\rule{2.2em}{0pt}}_{\mbox{\lstinline{c}}}$%
- \end{center}
- Anhand einer ASCII-Tabelle erkennt man,
- daß die Big-Endian-Variante dem String \lstinline{"llaH!tleW ,o"}
- und die Little-Endian-Variante dem String \lstinline{"Hallo, Welt!"}
- entspricht -- jeweils mit einem Null-Symbol am Ende,
- das von der Variablen \lstinline{c} herrührt.
-
- Auf einem Little-Endian-Rechner wird daher
- \lstinline[style=terminal]{Hallo, Welt!} ausgegeben.
-
- \item
- \textbf{Welche Endianness hat der verwendete Rechner?}
-
- Little-Endian (Begründung siehe oben)
-
- \textbf{Wie sähe die Ausgabe auf einem Rechner mit entgegengesetzter Endianness aus?}
-
- \lstinline[style=terminal]{llaH!tleW ,o} (Begründung siehe oben)
-
- \item
- \textbf{Dasselbe Programm wird nun für einen 64-Bit-Rechner compiliert und ausgeführt.\\
- (Die \lstinline[style=cmd]{gcc}-Option \lstinline[style=cmd]{-m64} sorgt dafür,
- daß \lstinline[style=cmd]{gcc} Code für einen 64-Bit-Prozessor erzeugt.)}
- \begin{lstlisting}[style=terminal,gobble=8]
- $ ¡gcc -Wall -m64 aufgabe-2.c -o aufgabe-2¿
- aufgabe-2.c: In function "main":
- aufgabe-2.c:14:13: warning: format "%s" expects argument of type "char *",
- but argument 2 has type "three_numbers * {aka struct <anonymous> *}"
- [-Wformat=]
- printf ("%s\n", &xyz);
- ^
- $ ¡./aufgabe-2¿
- Hall5V
- \end{lstlisting}
- \textbf{(Es ist möglich, daß die konkrete Ausgabe auf Ihrem Rechner anders aussieht.)}\par
- \textbf{Erklären Sie die geänderte Ausgabe des Programms.}
-
- \goodbreak
-
- Auf einem 64-Bit-Rechner hat eine 64-Bit-Variable
- ein \textbf{64-Bit-Alignment},
- d.\,h.\ ihre Speicheradresse muß durch 8 teilbar sein.
-
- Der Compiler legt die Variablen daher wie folgt im Speicher ab (Little-Endian):
- \begin{center}
- \begin{tabular}{|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|}\hline
- \raisebox{0.5ex}{\strut}
- 48 & 61 & 6C & 6C & ?? & ?? & ?? & ?? &
- 6F & 2C & 20 & 57 & 65 & 6C & 74 & 21 &
- 00
- \\\hline
- \end{tabular}\\[-4.2ex]
- \kern1.7em%
- $\underbrace{\rule{9.8em}{0pt}}_{\mbox{\lstinline{a}}}$\kern1pt%
- $\underbrace{\rule{9.1em}{0pt}}_{\mbox{Füll-Bytes}}$\kern1pt%
- $\underbrace{\rule{18.8em}{0pt}}_{\mbox{\lstinline{b}}}$\kern1pt%
- $\underbrace{\rule{2.2em}{0pt}}_{\mbox{\lstinline{c}}}$%
- \end{center}
- Der Inhalt der Füll-Bytes ist undefiniert.
- Im Beispiel aus der Aufgabenstellung entsteht hier die Ausgabe
- \lstinline[style=terminal]{5V}, was den (zufälligen) hexadezimalen Werten
- 35 56 entspricht:
- \begin{center}
- \begin{tabular}{|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|}\hline
- \raisebox{0.5ex}{\strut}
- 48 & 61 & 6C & 6C & 35 & 56 & 00 & ?? &
- 6F & 2C & 20 & 57 & 65 & 6C & 74 & 21 &
- 00
- \\\hline
- \end{tabular}\\[-4.2ex]
- \kern1.7em%
- $\underbrace{\rule{9.8em}{0pt}}_{\mbox{\lstinline{a}}}$\kern1pt%
- $\underbrace{\rule{9.1em}{0pt}}_{\mbox{Füll-Bytes}}$\kern1pt%
- $\underbrace{\rule{18.8em}{0pt}}_{\mbox{\lstinline{b}}}$\kern1pt%
- $\underbrace{\rule{2.2em}{0pt}}_{\mbox{\lstinline{c}}}$%
- \end{center}
- Da danach die Ausgabe aufhört, muß an der nächsten Stelle
- ein Null-Symbol stehen, das das Ende des Strings anzeigt.
- Der Inhalt der darauf folgenden Speicherzelle bleibt unbekannt.
- \end{enumerate}
-
-\end{document}
diff --git a/20221114/hp-uebung-20221114.pdf b/20221114/hp-uebung-20221114.pdf
deleted file mode 100644
index 57a4c759a68b52b76d40bb817db8714a5d104115..0000000000000000000000000000000000000000
Binary files a/20221114/hp-uebung-20221114.pdf and /dev/null differ
diff --git a/20221114/hp-uebung-20221114.tex b/20221114/hp-uebung-20221114.tex
deleted file mode 100644
index 57dc0cae2dda333b357627600968f550e4573ddf..0000000000000000000000000000000000000000
--- a/20221114/hp-uebung-20221114.tex
+++ /dev/null
@@ -1,195 +0,0 @@
-% hp-uebung-20221114.pdf - Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Trickprogrammierung, Thermometer-Baustein an I²C-Bus, Speicherformate von Zahlen
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-\usepackage{gensymb}
-
-\newcommand{\ItwoC}{I\raisebox{0.5ex}{\footnotesize 2}C}
-\newcommand{\ITWOC}{I\raisebox{0.5ex}{\normalsize 2}C}
-
-\begin{document}
-
- \thispagestyle{empty}
-
- \section*{Hardwarenahe Programmierung\\
- Übungsaufgaben -- 14.\ November 2022}
-
- Diese Übung enthält Punkteangaben wie in einer Klausur.
- Um zu "`bestehen"', müssen Sie innerhalb von 90 Minuten
- unter Verwendung ausschließlich zugelassener Hilfsmittel
- 15 Punkte (von insgesamt \totalpoints) erreichen.
-
- \exercise{Trickprogrammierung}
-
- Wir betrachten das folgende Programm (Datei: \gitfile{hp}{2022ws/20221114}{aufgabe-1.c}):
- \begin{lstlisting}
- #include <stdio.h>
- #include <stdint.h>
-
- int main (void)
- {
- uint64_t x = 4262939000843297096;
- char *s = &x;
- printf ("%s\n", s);
- return 0;
- }
- \end{lstlisting}
- Das Programm wird compiliert und auf einem 64-Bit-Little-Endian-Computer ausgeführt:
- \begin{lstlisting}[style=terminal]
- $ ¡gcc -Wall -O aufgabe-1.c -o aufgabe-1¿
- aufgabe-1.c: In function `main':
- aufgabe-1.c:7:13: warning: initialization from incompatible pointer type [...]
- $ ¡./aufgabe-1¿
- Hallo
- \end{lstlisting}
-
- \begin{itemize}
- \item[(a)]
- Erklären Sie die Warnung beim Compilieren. \points{2}
- \item[(b)]
- Erklären Sie die Ausgabe des Programms. \points{5}
- \item[(c)]
- Wie würde die Ausgabe des Programms auf einem 64-Bit-Big-Endian-Computer lauten? \points{3}
- \end{itemize}
- Hinweis: Modifizieren Sie das Programm
- und lassen Sie sich Speicherinhalte ausgeben.
-
- \exercise{Thermometer-Baustein an \ITWOC-Bus}
-
- Eine Firma stellt einen elektronischen Thermometer-Baustein her,
- den man über die serielle Schnittstelle (RS-232) an einen PC anschließen kann,
- um die Temperatur auszulesen.
- Nun wird eine Variante des Thermo"-meter-Bausteins entwickelt,
- die die Temperatur zusätzlich über einen \ItwoC-Bus bereitstellt.
-
- Um das neue Thermometer zu testen, wird es in ein Gefäß mit heißem Wasser gelegt,
- das langsam auf Zimmertemperatur abkühlt.
- Alle 10 Minuten liest ein Programm, das auf dem PC läuft,
- die gemessene Temperatur über beide Schnittstellen aus
- und erzeugt daraus die folgende Tabelle:
-
- \begin{center}
- \renewcommand{\arraystretch}{1.2}
- \begin{tabular}{|c|c|c|}\hline
- Zeit /\,min. & Temperatur per RS-232 /\,\degree C & Temperatur per \ItwoC\ /\,\degree C \\\hline\hline
- \phantom{0}0 & 94 & 122 \\\hline
- 10 & 47 & 244 \\\hline
- 20 & 30 & 120 \\\hline
- 30 & 24 & \phantom{0}24 \\\hline
- 40 & 21 & 168 \\\hline
- \end{tabular}
- \end{center}
-
- \begin{itemize}
- \item[(a)]
- Aus dem Vergleich der Meßdaten läßt sich
- auf einen Fehler bei der \ItwoC-Übertragung schließen.\\
- Um welchen Fehler handelt es sich,
- und wie ergibt sich dies aus den Meßdaten?
- \points{5}
- \item[(b)]
- Schreiben Sie eine C-Funktion \lstinline{uint8_t repair (uint8_t data)},
- die eine über den \ItwoC-Bus empfangene fehlerhafte Temperatur \lstinline{data} korrigiert.
- \points{5}
- \end{itemize}
-
- \exercise{Speicherformate von Zahlen}
-
- Wir betrachten das folgende Programm (\gitfile{hp}{2022ws/20221114}{aufgabe-3.c}):
- \begin{lstlisting}
- #include <stdio.h>
- #include <stdint.h>
-
- typedef struct
- {
- uint32_t a;
- uint64_t b;
- uint8_t c;
- } three_numbers;
-
- int main (void)
- {
- three_numbers xyz = { 1819042120, 2410670883059281007, 0 };
- printf ("%s\n", &xyz);
- return 0;
- }
- \end{lstlisting}
-
- Das Programm wird für einen 32-Bit-Rechner compiliert und ausgeführt.\\
- (Die \lstinline[style=cmd]{gcc}-Option \lstinline[style=cmd]{-m32} sorgt dafür,
- daß \lstinline[style=cmd]{gcc} Code für einen 32-Bit-Prozessor erzeugt.)
-
- \begin{lstlisting}[style=terminal]
- $ ¡gcc -Wall -m32 aufgabe-2.c -o aufgabe-2¿
- aufgabe-2.c: In function "main":
- aufgabe-2.c:14:13: warning: format "%s" expects argument of type "char *", but
- argument 2 has type "three_numbers * {aka struct <anonymous> *}" [-Wformat=]
- printf ("%s\n", &xyz);
- ^
- $ ¡./aufgabe-2¿
- Hallo, Welt!
- \end{lstlisting}
-
- \begin{enumerate}[\quad(a)]
- \item
- Erklären Sie die beim Compilieren auftretende Warnung.
- \points{2}
- \item
- Erklären Sie die Ausgabe des Programms.
- \points{4}
- \item
- Welche Endianness hat der verwendete Rechner?
- Wie sähe die Ausgabe auf einem Rechner mit entgegengesetzter Endianness aus?
- \points{2}
- \item
- Dasselbe Programm wird nun für einen 64-Bit-Rechner compiliert und ausgeführt.\\
- (Die \lstinline[style=cmd]{gcc}-Option \lstinline[style=cmd]{-m64} sorgt dafür,
- daß \lstinline[style=cmd]{gcc} Code für einen 64-Bit-Prozessor erzeugt.)
- \begin{lstlisting}[style=terminal,gobble=8]
- $ ¡gcc -Wall -m64 aufgabe-2.c -o aufgabe-2¿
- aufgabe-2.c: In function "main":
- aufgabe-2.c:14:13: warning: format "%s" expects argument of type "char *",
- but argument 2 has type "three_numbers * {aka struct <anonymous> *}"
- [-Wformat=]
- printf ("%s\n", &xyz);
- ^
- $ ¡./aufgabe-2¿
- Hall5V
- \end{lstlisting}
- (Es ist möglich, daß die konkrete Ausgabe auf Ihrem Rechner anders aussieht.)\par
- Erklären Sie die geänderte Ausgabe des Programms.
- \points{3}
- \end{enumerate}
-
- \begin{flushright}
- \textit{Viel Erfolg!}
- \end{flushright}
-
- \makeatletter
- \immediate\write\@mainaux{\string\gdef\string\totalpoints{\arabic{points}}}
- \makeatother
-
-\end{document}
diff --git a/20221114/input-01.c b/20221114/input-01.c
deleted file mode 100644
index 6a3d39ec2434d46f6a913da381a6b5e9504c7a49..0000000000000000000000000000000000000000
--- a/20221114/input-01.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-int main (void)
-{
- uint8_t PINC = 0;
- if (PINC & 0x02 == 0)
- printf ("Input is OFF\n");
- else
- printf ("Input is ON\n");
- return 0;
-}
diff --git a/20221114/input-02.c b/20221114/input-02.c
deleted file mode 100644
index 92b2d6c6dcd4095fc0ba37a86e6d9670c89f9d61..0000000000000000000000000000000000000000
--- a/20221114/input-02.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-int main (void)
-{
- uint8_t PINC = 0;
- if ((PINC & 0x02) == 0)
- printf ("Input is OFF\n");
- else
- printf ("Input is ON\n");
- return 0;
-}
diff --git a/20221114/io-ports-and-interrupts.pdf b/20221114/io-ports-and-interrupts.pdf
deleted file mode 120000
index bcd46f7afb35605b20bdb05637e6de0a039893ec..0000000000000000000000000000000000000000
--- a/20221114/io-ports-and-interrupts.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/io-ports-and-interrupts.pdf
\ No newline at end of file
diff --git a/20221114/loesung-1-1.c b/20221114/loesung-1-1.c
deleted file mode 100644
index 26fcc817796b3da118b5dda92f45bfb870e315b6..0000000000000000000000000000000000000000
--- a/20221114/loesung-1-1.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-#include <inttypes.h>
-
-int main (void)
-{
- uint64_t x = 4262939000843297096;
- char *s = &x;
- printf ("%lx\n", x);
- printf ("%" PRIx64 "\n", x);
- printf ("%s\n", s);
- return 0;
-}
diff --git a/20221114/loesung-1-2.c b/20221114/loesung-1-2.c
deleted file mode 100644
index 7151db69b2e675f17517d7b7c3814bbda3b1fa89..0000000000000000000000000000000000000000
--- a/20221114/loesung-1-2.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-#include <inttypes.h>
-
-int main (void)
-{
- uint64_t x = 4262939000843297096;
- char *s = &x;
- printf ("%lx\n", x);
- printf ("%" PRIx64 "\n", x);
- printf ("%c %c %c %c %c %c %c %c\n",
- 0x48, 0x61, 0x6c, 0x6c, 0x6f, 0x00, 0x29, 0x3b);
- printf ("%s\n", s);
- return 0;
-}
diff --git a/20221114/loesung-1-3.c b/20221114/loesung-1-3.c
deleted file mode 100644
index fadccdef1155e4d16b5da0c8a82d8e7ae76ca3cc..0000000000000000000000000000000000000000
--- a/20221114/loesung-1-3.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-#include <inttypes.h>
-
-int main (void)
-{
- uint64_t x = 0x48616c6c6f00293b;
- char *s = &x;
- printf ("%s\n", s);
- return 0;
-}
diff --git a/20221114/loesung-2.c b/20221114/loesung-2.c
deleted file mode 100644
index b02d98b51b9bc525a567afea2f0dce5a8e6413a5..0000000000000000000000000000000000000000
--- a/20221114/loesung-2.c
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-uint8_t repair (uint8_t data)
-{
- uint8_t result = 0;
- uint8_t mask_data = 0x01;
- uint8_t mask_result = 0x80;
- while (mask_data)
- {
- if (data & mask_data)
- result |= mask_result;
- mask_data <<= 1;
- mask_result >>= 1;
- }
- return result;
-}
-
-int main (void)
-{
- int data[] = { 122, 244, 120, 24, 168, -1 };
- int i = 0;
- while (data[i] >= 0)
- printf ("%d\n", repair (data[i++]));
- return 0;
-}
diff --git a/20221114/logo-hochschule-bochum-cvh-text-v2.pdf b/20221114/logo-hochschule-bochum-cvh-text-v2.pdf
deleted file mode 120000
index 4aa99b8f81061aca6dcaf43eed2d9efef40555f8..0000000000000000000000000000000000000000
--- a/20221114/logo-hochschule-bochum-cvh-text-v2.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
diff --git a/20221114/logo-hochschule-bochum.pdf b/20221114/logo-hochschule-bochum.pdf
deleted file mode 120000
index b6b9491e370e499c9276918182cdb82cb311bcd1..0000000000000000000000000000000000000000
--- a/20221114/logo-hochschule-bochum.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20221114/mic-on.au b/20221114/mic-on.au
deleted file mode 100644
index f0b26945f1037a5c30c0a19bde51d06de22c75ed..0000000000000000000000000000000000000000
Binary files a/20221114/mic-on.au and /dev/null differ
diff --git a/20221114/mic-on.wav b/20221114/mic-on.wav
deleted file mode 100644
index 45f912ee264f52f888a63b94c37ec25123ad7f3a..0000000000000000000000000000000000000000
Binary files a/20221114/mic-on.wav and /dev/null differ
diff --git a/20221114/pendulum-0.c b/20221114/pendulum-0.c
deleted file mode 100644
index 6faebdc7ad779d89ab8e2eacd189240ace1fb406..0000000000000000000000000000000000000000
--- a/20221114/pendulum-0.c
+++ /dev/null
@@ -1,69 +0,0 @@
-#include <gtk/gtk.h>
-#include <math.h>
-
-int width = 320;
-int height = 240;
-int gap = height / 20;
-int r = gap;
-double visual_length = height - 2 * gap - r;
-
-double phi0 = -0.5;
-double omega0 = 0.0;
-double t0 = 0.0;
-double g = 9.81;
-double l = 1.0;
-double dt = 0.02;
-
-double t = t0;
-double phi = phi0;
-double omega = omega0;
-
-gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
-{
- GdkRGBA blue = { 0.0, 0.5, 1.0, 1.0 };
-
- int x = width / 2 + visual_length * sin (phi);
- int y = gap + visual_length * cos (phi);
-
- gdk_cairo_set_source_rgba (c, &blue);
- cairo_move_to (c, width / 2, gap);
- cairo_line_to (c, x, y);
- cairo_stroke (c);
- cairo_arc (c, x, y, r, 0, 2 * G_PI);
- cairo_fill (c);
-
- return FALSE; /* TRUE to stop other handlers from being invoked for the event.
- FALSE to propagate the event further. */
-}
-
-gboolean timer (GtkWidget *widget)
-{
- t += dt;
- phi += omega * dt;
- omega += - dt * g / l * sin (phi);
-
- gtk_widget_queue_draw_area (widget, 0, 0, width, height);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
-}
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
-
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_widget_show (window);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_widget_show (drawing_area);
- gtk_container_add (GTK_CONTAINER (window), drawing_area);
- gtk_widget_set_size_request (drawing_area, width, height);
- g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
-
- g_timeout_add (50, (GSourceFunc) timer, drawing_area);
-
- gtk_main ();
- return 0;
-}
diff --git a/20221114/pendulum-1.c b/20221114/pendulum-1.c
deleted file mode 100644
index 0024b2bc283c5d9b76a3148359254aab38fca282..0000000000000000000000000000000000000000
--- a/20221114/pendulum-1.c
+++ /dev/null
@@ -1,69 +0,0 @@
-#include <gtk/gtk.h>
-#include <math.h>
-
-#define WIDTH 320
-#define HEIGHT 240
-#define GAP (HEIGHT / 20)
-#define r GAP
-#define visual_length (HEIGHT - 2 * GAP - r)
-
-#define phi0 (-0.5)
-#define omega0 0.0
-#define t0 0.0
-#define g 9.81
-#define l 1.0
-#define dt 0.02
-
-double t = t0;
-double phi = phi0;
-double omega = omega0;
-
-gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
-{
- GdkRGBA blue = { 0.0, 0.5, 1.0, 1.0 };
-
- int x = WIDTH / 2 + visual_length * sin (phi);
- int y = GAP + visual_length * cos (phi);
-
- gdk_cairo_set_source_rgba (c, &blue);
- cairo_move_to (c, WIDTH / 2, GAP);
- cairo_line_to (c, x, y);
- cairo_stroke (c);
- cairo_arc (c, x, y, r, 0, 2 * G_PI);
- cairo_fill (c);
-
- return FALSE; /* TRUE to stop other handlers from being invoked for the event.
- FALSE to propagate the event further. */
-}
-
-gboolean timer (GtkWidget *widget)
-{
- t += dt;
- phi += omega * dt;
- omega += - dt * g / l * sin (phi);
-
- gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
-}
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
-
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_widget_show (window);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_widget_show (drawing_area);
- gtk_container_add (GTK_CONTAINER (window), drawing_area);
- gtk_widget_set_size_request (drawing_area, WIDTH, HEIGHT);
- g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
-
- g_timeout_add (50, (GSourceFunc) timer, drawing_area);
-
- gtk_main ();
- return 0;
-}
diff --git a/20221114/pendulum-2.c b/20221114/pendulum-2.c
deleted file mode 100644
index 6c318a03cd89d21d09259201ffcccb673983fe3b..0000000000000000000000000000000000000000
--- a/20221114/pendulum-2.c
+++ /dev/null
@@ -1,69 +0,0 @@
-#include <gtk/gtk.h>
-#include <math.h>
-
-#define WIDTH 320
-#define HEIGHT 240
-#define GAP (HEIGHT / 20)
-#define r GAP
-#define visual_length (HEIGHT - 2 * GAP - r)
-
-#define phi0 (-0.5)
-#define omega0 0.0
-#define t0 0.0
-#define g 9.81
-#define l 1.0
-#define dt 0.02
-
-double t = t0;
-double phi = phi0;
-double omega = omega0;
-
-gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
-{
- GdkRGBA orange = { 1.0, 0.5, 0.0, 1.0 };
-
- int x = WIDTH / 2 + visual_length * sin (phi);
- int y = GAP + visual_length * cos (phi);
-
- gdk_cairo_set_source_rgba (c, &orange);
- cairo_move_to (c, WIDTH / 2, GAP);
- cairo_line_to (c, x, y);
- cairo_stroke (c);
- cairo_arc (c, x, y, r, 0, 2 * G_PI);
- cairo_fill (c);
-
- return FALSE; /* TRUE to stop other handlers from being invoked for the event.
- FALSE to propagate the event further. */
-}
-
-gboolean timer (GtkWidget *widget)
-{
- t += dt;
- phi += omega * dt;
- omega += - dt * g / l * phi;
-
- gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
-}
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
-
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_widget_show (window);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_widget_show (drawing_area);
- gtk_container_add (GTK_CONTAINER (window), drawing_area);
- gtk_widget_set_size_request (drawing_area, WIDTH, HEIGHT);
- g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
-
- g_timeout_add (50, (GSourceFunc) timer, drawing_area);
-
- gtk_main ();
- return 0;
-}
diff --git a/20221114/pendulum-3.c b/20221114/pendulum-3.c
deleted file mode 100644
index b6bc9793b3b7c0166df678cccdf8a4ae9170d886..0000000000000000000000000000000000000000
--- a/20221114/pendulum-3.c
+++ /dev/null
@@ -1,87 +0,0 @@
-#include <gtk/gtk.h>
-#include <math.h>
-
-#define WIDTH 320
-#define HEIGHT 240
-#define GAP (HEIGHT / 20)
-#define r GAP
-#define visual_length (HEIGHT - 2 * GAP - r)
-
-#define phi0 (-0.5)
-#define omega0 0.0
-#define t0 0.0
-#define g 9.81
-#define l 1.0
-#define dt 0.02
-
-double t = t0;
-double phi_with_sin = phi0;
-double omega_with_sin= omega0;
-double phi_without_sin = phi0;
-double omega_without_sin= omega0;
-
-void draw_pendulum (cairo_t *c, double phi, GdkRGBA *colour)
-{
- int x = WIDTH / 2 + visual_length * sin (phi);
- int y = GAP + visual_length * cos (phi);
-
- gdk_cairo_set_source_rgba (c, colour);
- cairo_move_to (c, WIDTH / 2, GAP);
- cairo_line_to (c, x, y);
- cairo_stroke (c);
- cairo_arc (c, x, y, r, 0, 2 * G_PI);
- cairo_fill (c);
-}
-
-gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
-{
- GdkRGBA blue = { 0.0, 0.5, 1.0, 1.0 };
- GdkRGBA orange = { 1.0, 0.5, 0.0, 1.0 };
- GdkRGBA green = { 0.0, 0.5, 0.0, 1.0 };
-
- double A = phi0;
- double B = 0.5 * M_PI; /* 90° */
- double phi_analytic = A * sin (sqrt (g / l) * t + B);
-
- /* Näherungen: Kleinwinkel dt */
- draw_pendulum (c, phi_with_sin, &blue); /* blau nein ja */
- draw_pendulum (c, phi_without_sin, &orange); /* orange ja ja */
- draw_pendulum (c, phi_analytic, &green); /* grün ja nein */
-
- return FALSE; /* TRUE to stop other handlers from being invoked for the event.
- FALSE to propagate the event further. */
-}
-
-gboolean timer (GtkWidget *widget)
-{
- t += dt;
- phi_with_sin += omega_with_sin * dt;
- omega_with_sin += - dt * g / l * sin (phi_with_sin);
- phi_without_sin += omega_without_sin * dt;
- omega_without_sin += - dt * g / l * phi_without_sin;
-
- gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
-}
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
-
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_widget_show (window);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_widget_show (drawing_area);
- gtk_container_add (GTK_CONTAINER (window), drawing_area);
- gtk_widget_set_size_request (drawing_area, WIDTH, HEIGHT);
- g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
-
- g_timeout_add (50, (GSourceFunc) timer, drawing_area);
-
- gtk_main ();
- return 0;
-}
diff --git a/20221114/pendulum-4.c b/20221114/pendulum-4.c
deleted file mode 100644
index 1a08e32735336064af72ce6f332299d14ff66218..0000000000000000000000000000000000000000
--- a/20221114/pendulum-4.c
+++ /dev/null
@@ -1,86 +0,0 @@
-#include <gtk/gtk.h>
-#include <math.h>
-
-#define WIDTH 320
-#define HEIGHT 240
-#define GAP (HEIGHT / 20)
-#define r GAP
-#define visual_length (HEIGHT - 2 * GAP - r)
-
-#define phi0 (-5.0 / 180.0 * M_PI)
-#define omega0 0.0
-#define t0 0.0
-#define g 9.81
-#define l 1.0
-#define dt 0.02
-
-double t = t0;
-double phi_with_sin = phi0;
-double omega_with_sin= omega0;
-double phi_without_sin = phi0;
-double omega_without_sin= omega0;
-
-void draw_pendulum (cairo_t *c, double phi, GdkRGBA *colour)
-{
- int x = WIDTH / 2 + visual_length * sin (phi);
- int y = GAP + visual_length * cos (phi);
-
- gdk_cairo_set_source_rgba (c, colour);
- cairo_move_to (c, WIDTH / 2, 10);
- cairo_line_to (c, x, y);
- cairo_stroke (c);
- cairo_arc (c, x, y, r, 0, 2 * G_PI);
- cairo_fill (c);
-}
-
-gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
-{
- GdkRGBA blue = { 0.0, 0.5, 1.0, 1.0 };
- GdkRGBA orange = { 1.0, 0.5, 0.0, 1.0 };
- GdkRGBA green = { 0.0, 0.5, 0.0, 1.0 };
-
- double A = phi0;
- double B = 0.5 * M_PI; /* 90° */
- double phi_analytic = A * sin (sqrt (g / l) * t + B);
-
- draw_pendulum (c, phi_with_sin, &blue);
- draw_pendulum (c, phi_without_sin, &orange);
- draw_pendulum (c, phi_analytic, &green);
-
- return FALSE; /* TRUE to stop other handlers from being invoked for the event.
- FALSE to propagate the event further. */
-}
-
-gboolean timer (GtkWidget *widget)
-{
- t += dt;
- phi_with_sin += omega_with_sin * dt;
- omega_with_sin += - dt * g / l * sin (phi_with_sin);
- phi_without_sin += omega_without_sin * dt;
- omega_without_sin += - dt * g / l * phi_without_sin;
-
- gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
-}
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
-
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_widget_show (window);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_widget_show (drawing_area);
- gtk_container_add (GTK_CONTAINER (window), drawing_area);
- gtk_widget_set_size_request (drawing_area, WIDTH, HEIGHT);
- g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
-
- g_timeout_add (50, (GSourceFunc) timer, drawing_area);
-
- gtk_main ();
- return 0;
-}
diff --git a/20221114/pendulum.pdf b/20221114/pendulum.pdf
deleted file mode 120000
index 7d1d87305cdb8840a248ff2207538d758464f452..0000000000000000000000000000000000000000
--- a/20221114/pendulum.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/pendulum.pdf
\ No newline at end of file
diff --git a/20221114/pgscript.sty b/20221114/pgscript.sty
deleted file mode 120000
index 95c888478c99ea7fda0fd11ccf669ae91be7178b..0000000000000000000000000000000000000000
--- a/20221114/pgscript.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgscript.sty
\ No newline at end of file
diff --git a/20221114/pgslides.sty b/20221114/pgslides.sty
deleted file mode 120000
index 5be1416f4216f076aa268901f52a15d775e43f64..0000000000000000000000000000000000000000
--- a/20221114/pgslides.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgslides.sty
\ No newline at end of file
diff --git a/20221121/Tower_of_Hanoi.jpeg b/20221121/Tower_of_Hanoi.jpeg
deleted file mode 120000
index a1a794afda08596ffa2f46f278db53455de25b6c..0000000000000000000000000000000000000000
--- a/20221121/Tower_of_Hanoi.jpeg
+++ /dev/null
@@ -1 +0,0 @@
-../common/Tower_of_Hanoi.jpeg
\ No newline at end of file
diff --git a/20221121/aufgabe-2.c b/20221121/aufgabe-2.c
deleted file mode 100644
index 47595ef0658e94d76a42263e82200f94895cdeea..0000000000000000000000000000000000000000
--- a/20221121/aufgabe-2.c
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-typedef struct
-{
- char first_name[10];
- char family_name[20];
- char day, month;
- int year;
-} person;
-
-int main (void)
-{
- person sls;
- sls.day = 26;
- sls.month = 7;
- sls.year = 1951;
- strcpy (sls.first_name, "Sabine");
- strcpy (sls.family_name, "Leutheusser-Schnarrenberger");
- printf ("%s %s wurde am %d.%d.%d geboren.\n",
- sls.first_name, sls.family_name, sls.day, sls.month, sls.year);
- return 0;
-}
diff --git a/20221121/aufgabe-3.c b/20221121/aufgabe-3.c
deleted file mode 100644
index abbf364a3db17611e41d086591826e98a8a3672b..0000000000000000000000000000000000000000
--- a/20221121/aufgabe-3.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <stdio.h>
-
-int fak (int n)
-{
- if (n <= 0)
- return 1;
- else
- return n * fak (n - 1);
-}
-
-int main (void)
-{
- for (int n = 0; n <= 5; n++)
- printf ("%d\n", fak (n));
- return 0;
-}
diff --git a/20221121/bsort-1.c b/20221121/bsort-1.c
deleted file mode 100644
index 3c02adc72e6a7e702e2c7c68c838fc94cc8ef547..0000000000000000000000000000000000000000
--- a/20221121/bsort-1.c
+++ /dev/null
@@ -1,48 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, int left, int right)
-{
- int result = strcmp (name[left], name[right]);
- comparisons++;
- display (name, left, right);
- usleep (200000);
- return result;
-}
-
-void sort (char **name)
-{
- for (int i = 1; name[i]; i++)
- if (compare (name, i - 1, i) > 0)
- {
- char *temp = name[i - 1];
- name[i - 1] = name[i];
- name[i] = temp;
- }
-}
-
-int main (void)
-{
- char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
- "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
- "Thomas", "Ulrich", "Zacharias", NULL };
- sort (name);
- display (name, -1, -1);
- return 0;
-}
diff --git a/20221121/bsort-1a.c b/20221121/bsort-1a.c
deleted file mode 100644
index 348b638843002926f57cdcf1d4fbc9bd88d2a10c..0000000000000000000000000000000000000000
--- a/20221121/bsort-1a.c
+++ /dev/null
@@ -1,48 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, int left, int right)
-{
- int result = strcmp (name[left], name[right]);
- comparisons++;
- display (name, left, right);
- usleep (200000);
- return result;
-}
-
-void sort (char **name)
-{
- for (int i = 1; name[i]; i++)
- if (compare (name, i - 1, i) > 0)
- {
- char *temp = name[i - 1];
- name[i - 1] = name[i];
- name[i] = temp;
- }
-}
-
-int main (void)
-{
- char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
- "Dieter", "Hugo", "Zacharias", "Berta", "Maria", "Fritz", "Box", "Hans",
- "Thomas", "Ulrich", NULL };
- sort (name);
- display (name, -1, -1);
- return 0;
-}
diff --git a/20221121/bsort-2.c b/20221121/bsort-2.c
deleted file mode 100644
index d277be0182a40ecd0c66eaeef94d7aebac6aa542..0000000000000000000000000000000000000000
--- a/20221121/bsort-2.c
+++ /dev/null
@@ -1,55 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, int left, int right)
-{
- int result = strcmp (name[left], name[right]);
- comparisons++;
- display (name, left, right);
- usleep (200000);
- return result;
-}
-
-void sort (char **name)
-{
- int sorted = 0;
- while (name[sorted])
- sorted++;
- while (sorted > 0)
- {
- for (int i = 1; i < sorted; i++)
- if (compare (name, i - 1, i) > 0)
- {
- char *temp = name[i - 1];
- name[i - 1] = name[i];
- name[i] = temp;
- }
- sorted--;
- }
-}
-
-int main (void)
-{
- char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
- "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
- "Thomas", "Ulrich", "Zacharias", NULL };
- sort (name);
- display (name, -1, -1);
- return 0;
-}
diff --git a/20221121/bsort-3.c b/20221121/bsort-3.c
deleted file mode 100644
index 67d0097b913171b4523f4f04b6b6ff494046dabd..0000000000000000000000000000000000000000
--- a/20221121/bsort-3.c
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, int left, int right)
-{
- int result = strcmp (name[left], name[right]);
- comparisons++;
- display (name, left, right);
- usleep (200000);
- return result;
-}
-
-void sort (char **name)
-{
- int done = 0;
- int sorted = 0;
- while (name[sorted])
- sorted++;
- while (sorted > 0 && !done)
- {
- done = 1;
- for (int i = 1; i < sorted; i++)
- if (compare (name, i - 1, i) > 0)
- {
- done = 0;
- char *temp = name[i - 1];
- name[i - 1] = name[i];
- name[i] = temp;
- }
- sorted--;
- }
-}
-
-int main (void)
-{
- char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
- "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
- "Thomas", "Ulrich", "Zacharias", NULL };
- sort (name);
- display (name, -1, -1);
- return 0;
-}
diff --git a/20221121/bsort-4.c b/20221121/bsort-4.c
deleted file mode 100644
index 241270a46f4ffa005d252207d769c3c4059ed7e2..0000000000000000000000000000000000000000
--- a/20221121/bsort-4.c
+++ /dev/null
@@ -1,57 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, int left, int right)
-{
- int result = strcmp (name[left], name[right]);
- comparisons++;
- display (name, left, right);
- usleep (200000);
- return result;
-}
-
-void sort (char **name)
-{
- int sorted = 0;
- while (name[sorted])
- sorted++;
- while (sorted > 0)
- {
- int new_sorted = 0;
- for (int i = 1; i < sorted; i++)
- if (compare (name, i - 1, i) > 0)
- {
- new_sorted = i;
- char *temp = name[i - 1];
- name[i - 1] = name[i];
- name[i] = temp;
- }
- sorted = new_sorted;
- }
-}
-
-int main (void)
-{
- char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
- "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
- "Thomas", "Ulrich", "Zacharias", NULL };
- sort (name);
- display (name, -1, -1);
- return 0;
-}
diff --git a/20221121/bsort-4a.c b/20221121/bsort-4a.c
deleted file mode 100644
index b65fe873bdfdccd4bb20a96aba43d61746527267..0000000000000000000000000000000000000000
--- a/20221121/bsort-4a.c
+++ /dev/null
@@ -1,57 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, int left, int right)
-{
- int result = strcmp (name[left], name[right]);
- comparisons++;
- display (name, left, right);
- usleep (200000);
- return result;
-}
-
-void sort (char **name)
-{
- int sorted = 0;
- while (name[sorted])
- sorted++;
- while (sorted > 0)
- {
- int new_sorted = 0;
- for (int i = 1; i < sorted; i++)
- if (compare (name, i - 1, i) > 0)
- {
- new_sorted = i;
- char *temp = name[i - 1];
- name[i - 1] = name[i];
- name[i] = temp;
- }
- sorted = new_sorted;
- }
-}
-
-int main (void)
-{
- char *name[] = { "Zacharias", "Ulrich", "Thomas", "Siegfried", "Peter", "Otto", "Maria",
- "Lisa", "Hugo", "Heinrich", "Hans", "Fritz", "Dieter", "Box", "Berta",
- "Anna", NULL };
- sort (name);
- display (name, -1, -1);
- return 0;
-}
diff --git a/20221121/bsort-4b.c b/20221121/bsort-4b.c
deleted file mode 100644
index bc2b2d193a68f4a701fecceeeffbb77f9b8117c5..0000000000000000000000000000000000000000
--- a/20221121/bsort-4b.c
+++ /dev/null
@@ -1,57 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, int left, int right)
-{
- int result = strcmp (name[left], name[right]);
- comparisons++;
- display (name, left, right);
- usleep (200000);
- return result;
-}
-
-void sort (char **name)
-{
- int sorted = 0;
- while (name[sorted])
- sorted++;
- while (sorted > 0)
- {
- int new_sorted = 0;
- for (int i = 1; i < sorted; i++)
- if (compare (name, i - 1, i) > 0)
- {
- new_sorted = i;
- char *temp = name[i - 1];
- name[i - 1] = name[i];
- name[i] = temp;
- }
- sorted = new_sorted;
- }
-}
-
-int main (void)
-{
- char *name[] = { "Anna", "Berta", "Box", "Dieter", "Fritz", "Hans", "Heinrich", "Hugo",
- "Lisa", "Maria", "Otto", "Peter", "Siegfried", "Thomas", "Ulrich",
- "Zacharias", NULL };
- sort (name);
- display (name, -1, -1);
- return 0;
-}
diff --git a/20221121/bsort-4c.c b/20221121/bsort-4c.c
deleted file mode 100644
index 89bc0d302ce027d5c5ae6949f73aa91b9992ef24..0000000000000000000000000000000000000000
--- a/20221121/bsort-4c.c
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, int left, int right)
-{
- int result = strcmp (name[left], name[right]);
- comparisons++;
-// display (name, left, right);
-// usleep (200000);
- return result;
-}
-
-void sort (char **name)
-{
- int sorted = 0;
- while (name[sorted])
- sorted++;
- while (sorted > 0)
- {
- int new_sorted = 0;
- for (int i = 1; i < sorted; i++)
- if (compare (name, i - 1, i) > 0)
- {
- new_sorted = i;
- char *temp = name[i - 1];
- name[i - 1] = name[i];
- name[i] = temp;
- }
- sorted = new_sorted;
- }
-}
-
-int main (void)
-{
- char *name[] = {
- #include "names.h"
- NULL
- };
- sort (name);
- display (name, -1, -1);
- return 0;
-}
diff --git a/20221121/hanoi-9a.c b/20221121/hanoi-9a.c
deleted file mode 100644
index 55e8d74db6d7284d6db225a6f8f3e08ab4efdc06..0000000000000000000000000000000000000000
--- a/20221121/hanoi-9a.c
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stdio.h>
-#include <error.h>
-
-#define DISKS 32
-
-int n[3], tower[3][DISKS];
-
-void display (void)
-{
- printf ("\n");
- for (int i = 0; i < 3; i++)
- {
- printf ("tower %d:", i);
- for (int j = 0; j < n[i]; j++)
- printf (" %d", tower[i][j]);
- printf ("\n");
- }
-}
-
-void move (int from, int to, int disks)
-{
- if (disks == 1)
- {
- if (n[from] <= 0)
- error (1, 0, "trying to move disk from empty tower");
- if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1])
- error (1, 0, "trying to move larger disk on smaller one");
- tower[to][n[to]] = tower[from][n[from] - 1];
- n[to]++;
- n[from]--;
- static int counter = 1;
- if (counter++ >= 100000000)
- {
- display ();
- counter = 1;
- }
- }
- else
- {
- int help = 0 + 1 + 2 - from - to;
- move (from, help, disks - 1);
- move (from, to, 1);
- move (help, to, disks - 1);
- }
-}
-
-int main (void)
-{
- n[0] = DISKS;
- for (int i = 0; i < DISKS; i++)
- tower[0][i] = DISKS - i;
- n[1] = 0;
- n[2] = 0;
- display ();
- move (0, 2, DISKS);
- display ();
- return 0;
-}
diff --git a/20221121/hanoi-9b.c b/20221121/hanoi-9b.c
deleted file mode 100644
index 3f2322d75bdc4c3c24a65938b4b9f0b4ca544ef2..0000000000000000000000000000000000000000
--- a/20221121/hanoi-9b.c
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stdio.h>
-#include <error.h>
-
-#define DISKS 32
-
-int n[3], tower[3][DISKS];
-
-void display (void)
-{
- printf ("\n");
- for (int i = 0; i < 3; i++)
- {
- printf ("tower %d:", i);
- for (int j = 0; j < n[i]; j++)
- printf (" %d", tower[i][j]);
- printf ("\n");
- }
-}
-
-void move (int from, int to, int disks)
-{
- if (disks == 1)
- {
-// if (n[from] <= 0)
-// error (1, 0, "trying to move disk from empty tower");
-// if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1])
-// error (1, 0, "trying to move larger disk on smaller one");
- tower[to][n[to]] = tower[from][n[from] - 1];
- n[to]++;
- n[from]--;
- static int counter = 1;
- if (counter++ >= 100000000)
- {
- display ();
- counter = 1;
- }
- }
- else
- {
- int help = 0 + 1 + 2 - from - to;
- move (from, help, disks - 1);
- move (from, to, 1);
- move (help, to, disks - 1);
- }
-}
-
-int main (void)
-{
- n[0] = DISKS;
- for (int i = 0; i < DISKS; i++)
- tower[0][i] = DISKS - i;
- n[1] = 0;
- n[2] = 0;
- display ();
- move (0, 2, DISKS);
- display ();
- return 0;
-}
diff --git a/20221121/hex-1.c b/20221121/hex-1.c
deleted file mode 100644
index 5e212d63393e2f29faada3a5f8938bddc46b51b2..0000000000000000000000000000000000000000
--- a/20221121/hex-1.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf ("Die Antwort lautet: %x bzw. %X\n", 0xAffe, 0xaFfE);
- return 0;
-}
diff --git a/20221121/hp-20221121.pdf b/20221121/hp-20221121.pdf
deleted file mode 100644
index 7a6837e8bf0053fc389341ad0539d23760241dc7..0000000000000000000000000000000000000000
Binary files a/20221121/hp-20221121.pdf and /dev/null differ
diff --git a/20221121/hp-20221121.tex b/20221121/hp-20221121.tex
deleted file mode 100644
index b8f143461d1e9a947b3597d2a67c80ac382f81a1..0000000000000000000000000000000000000000
--- a/20221121/hp-20221121.tex
+++ /dev/null
@@ -1,1421 +0,0 @@
-% hp-20221121.pdf - Lecture Slides on Low-Level Programming
-% Copyright (C) 2012, 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Aufwandsabschätzungen, Objektorientierte Programmierung
-
-\documentclass[10pt,t]{beamer}
-
-\usepackage{pgslides}
-\usepackage{pdftricks}
-\usepackage{tikz}
-\usepackage{rotating}
-
-\begin{psinputs}
- \usepackage[utf8]{inputenc}
- \usepackage[german]{babel}
- \usepackage[T1]{fontenc}
- \usepackage{helvet}
- \renewcommand*\familydefault{\sfdefault}
- \usepackage{pstricks,pst-grad}
-\end{psinputs}
-
-\newcommand{\redurl}[1]{\href{#1}{\color{red}\nolinkurl{#1}}}
-
-\title{Hardwarenahe Programmierung}
-\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
-\date{21.\ November 2022}
-
-\begin{document}
-
-\maketitleframe
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \begin{itemize}
- \item[4.1] Bit-Operationen
- \item[4.2] I/O-Ports
- \item[4.3] Interrupts
- \item[4.4] volatile-Variable
- \color{medgreen}
- \item[4.5] Byte-Reihenfolge -- Endianness
- \item[4.6] Binärdarstellung negativer Zahlen
- \item[4.7] Speicherausrichtung -- Alignment
- \end{itemize}
- \item[\textbf{5}] \textbf{Algorithmen}
- \begin{itemize}
- \color{medgreen}
- \item[5.1] Differentialgleichungen
- \item[5.2] Rekursion
- \color{red}
- \item[5.3] Aufwandsabschätzungen
- \end{itemize}
- \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
- \item[\textbf{7}] \textbf{Datenstrukturen}
- \end{itemize}
- \vspace*{-1cm}
-
-\end{frame}
-
-\setcounter{section}{3}
-\section{Hardwarenahe Programmierung}
-\setcounter{subsection}{4}
-\subsection{Byte-Reihenfolge -- Endianness}
-\subsubsection{Konzept}
-
-\begin{frame}[fragile]
-
- \showsubsection
- \showsubsubsection
-
- Eine Zahl geht über mehrere Speicherzellen.\\
- Beispiel: 16-Bit-Zahl in 2 8-Bit-Speicherzellen
-
- \smallskip
-
- Welche Bits liegen wo?
-
-% \pause
- \bigskip
-
- $1027 = 1024 + 2 + 1 = 0000\,0100\,0000\,0011_2 = 0403_{16}$
-
-% \pause
- \bigskip
- Speicherzellen:
-
- \medskip
- \begin{tabular}{|c|c|l}\cline{1-2}
- \raisebox{-0.25ex}{04} & \raisebox{-0.25ex}{03} & \strut Big-Endian "`großes Ende zuerst"' \\\cline{1-2}
- \multicolumn{2}{c}{} & % \pause
- für Menschen leichter lesbar % \pause
- \\
- \multicolumn{3}{c}{} \\[-5pt]\cline{1-2}
- \raisebox{-0.25ex}{03} & \raisebox{-0.25ex}{04} & \strut Little-Endian "`kleines Ende zuerst"' \\\cline{1-2}
- \multicolumn{2}{c}{} & % \pause
- bei Additionen effizienter
- \end{tabular}
-
-% \pause
- \medskip
- \textarrow\ Geschmackssache
-% \pause\\
- \quad\textbf{\dots\ außer bei Datenaustausch!}
-
-% \pause
-% \bigskip
-%
-% Aber: nicht verwechseln! \qquad $0304_{16} = 772$
-
-\end{frame}
-
-\begin{frame}
-
- \showsubsection
- \showsubsubsection
-
- Eine Zahl geht über mehrere Speicherzellen.\\
- Beispiel: 16-Bit-Zahl in 2 8-Bit-Speicherzellen
-
- \smallskip
-
- Welche Bits liegen wo?
-
- \medskip
-
- \textarrow\ Geschmackssache\\
- \textbf{\dots\ außer bei Datenaustausch!}
-
- \begin{itemize}
- \item
- Dateiformate
- \item
- Datenübertragung
- \end{itemize}
-
-\end{frame}
-
-\subsubsection{Dateiformate}
-
-\begin{frame}
-
- \showsubsection
- \showsubsubsection
-
- Audio-Formate: Reihenfolge der Bytes in 16- und 32-Bit-Zahlen
- \begin{itemize}
- \item
- RIFF-WAVE-Dateien (\file{.wav}): Little-Endian
- \item
- Au-Dateien (\file{.au}): Big-Endian
-% \pause
- \item
- ältere AIFF-Dateien (\file{.aiff}): Big-Endian
- \item
- neuere AIFF-Dateien (\file{.aiff}): Little-Endian
- \end{itemize}
-
-% \pause
- \bigskip
-
- Grafik-Formate: Reihenfolge der Bits in den Bytes
- \begin{itemize}
- \item
- PBM-Dateien: Big-Endian\only<1->{, MSB first}
- \item
- XBM-Dateien: Little-Endian\only<1->{, LSB first}
- \end{itemize}
- \only<1->{MSB/LSB = most/least significant bit}
-
-\end{frame}
-
-\subsubsection{Datenübertragung}
-
-\begin{frame}
-
- \showsubsection
- \showsubsubsection
-
- \begin{itemize}
- \item
- RS-232 (serielle Schnittstelle): LSB first
- \item
- I$^2$C: MSB first
- \item
- USB: beides
-% \pause
- \medskip
- \item
- Ethernet: LSB first
- \item
- TCP/IP (Internet): Big-Endian
- \end{itemize}
-
-\end{frame}
-
-\subsection{Binärdarstellung negativer Zahlen}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Speicher ist begrenzt!\\
- \textarrow\ feste Anzahl von Bits
-
- \medskip
-
- 8-Bit-Zahlen ohne Vorzeichen: \lstinline{uint8_t}\\
- \textarrow\ Zahlenwerte von \lstinline{0x00} bis \lstinline{0xff} = 0 bis 255\\
-% \pause
- \textarrow\ 255 + 1 = 0
-
-% \pause
- \medskip
-
- 8-Bit-Zahlen mit Vorzeichen: \lstinline{int8_t}\\
- \lstinline{0xff} = 255 ist die "`natürliche"' Schreibweise für $-1$.\\
-% \pause
- \textarrow\ Zweierkomplement
-
-% \pause
- \medskip
-
- Oberstes Bit = 1: negativ\\
- Oberstes Bit = 0: positiv\\
- \textarrow\ 127 + 1 = $-128$
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Speicher ist begrenzt!\\
- \textarrow\ feste Anzahl von Bits
-
- \medskip
-
- 16-Bit-Zahlen ohne Vorzeichen:
- \lstinline{uint16_t}\hfill\lstinline{uint8_t}\\
- \textarrow\ Zahlenwerte von \lstinline{0x0000} bis \lstinline{0xffff}
- = 0 bis 65535\hfill 0 bis 255\\
- \textarrow\ 65535 + 1 = 0\hfill 255 + 1 = 0
-
- \medskip
-
- 16-Bit-Zahlen mit Vorzeichen:
- \lstinline{int16_t}\hfill\lstinline{int8_t}\\
- \lstinline{0xffff} = 66535 ist die "`natürliche"' Schreibweise für $-1$.\hfill
- \lstinline{0xff} = 255 = $-1$\\
- \textarrow\ Zweierkomplement
-
- \medskip
-
- Oberstes Bit = 1: negativ\\
- Oberstes Bit = 0: positiv\\
- \textarrow\ 32767 + 1 = $-32768$
-
- \bigskip
- Literatur: \url{http://xkcd.com/571/}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Frage: \emph{Für welche Zahl steht der Speicherinhalt\,
- \raisebox{2pt}{%
- \tabcolsep0.25em
- \begin{tabular}{|c|c|}\hline
- \rule{0pt}{11pt}a3 & 90 \\\hline
- \end{tabular}}
- (hexadezimal)?}
-
-% \pause
- \smallskip
- Antwort: \emph{Das kommt darauf an.} ;--)
-
-% \pause
- \medskip
- Little-Endian:
-
- \smallskip
-
- \begin{tabular}{lrl}
- als \lstinline,int8_t,: & $-93$ & (nur erstes Byte)\\
- als \lstinline,uint8_t,: & $163$ & (nur erstes Byte)\\
- als \lstinline,int16_t,: & $-28509$\\
- als \lstinline,uint16_t,: & $37027$\\
- \lstinline,int32_t, oder größer: & $37027$
- & (zusätzliche Bytes mit Nullen aufgefüllt)
- \end{tabular}
-
-% \pause
- \medskip
- Big-Endian:
-
- \smallskip
-
- \begin{tabular}{lrl}
- als \lstinline,int8_t,: & $-93$ & (nur erstes Byte)\\
- als \lstinline,uint8_t,: & $163$ & (nur erstes Byte)\\
- als \lstinline,int16_t,: & $-23664$\\
- als \lstinline,uint16_t,: & $41872$\\ als \lstinline,int32_t,: & $-1550843904$ & (zusätzliche Bytes\\
- als \lstinline,uint32_t,: & $2744123392$ & mit Nullen aufgefüllt)\\
- als \lstinline,int64_t,: & $-6660823848880963584$\\
- als \lstinline,uint64_t,: & $11785920224828588032$\\
- \end{tabular}
-
- \vspace*{-1cm}
-
-\end{frame}
-
-\subsection{Speicherausrichtung -- Alignment}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \begin{lstlisting}
- #include <stdint.h>
-
- uint8_t a;
- uint16_t b;
- uint8_t c;
- \end{lstlisting}
-
-% \pause
- \bigskip
-
- Speicheradresse durch 2 teilbar -- "`16-Bit-Alignment"'
- \begin{itemize}
- \item
- 2-Byte-Operation: effizienter
-% \pause
- \item
- \dots\ oder sogar nur dann erlaubt
-% \pause
- \arrowitem
- Compiler optimiert Speicherausrichtung
- \end{itemize}
-
- \medskip
-
-% \pause
- \begin{minipage}{3cm}
- \begin{lstlisting}[gobble=6]
- ¡uint8_t a;
- uint8_t dummy;
- uint16_t b;
- uint8_t c;¿
- \end{lstlisting}
- \end{minipage}
-% \pause
- \begin{minipage}{3cm}
- \begin{lstlisting}[gobble=6]
- ¡uint8_t a;
- uint8_t c;
- uint16_t b;¿
- \end{lstlisting}
- \end{minipage}
-
-% \pause
- \vspace{-1.75cm}
- \strut\hfill
- \begin{minipage}{6.5cm}
- Fazit:
- \begin{itemize}
- \item
- \textbf{Adressen von Variablen\\
- sind systemabhängig}
- \item
- Bei Definition von Datenformaten\\
- Alignment beachten \textarrow\ effizienter
- \end{itemize}
- \end{minipage}
-
-\end{frame}
-
-\section{Algorithmen}
-\subsection{Differentialgleichungen}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \textbf{Beispiel 1: Gleichmäßig beschleunigte Bewegung}
-
- \strut\hfill
- \begin{minipage}{2.5cm}
- \vspace*{0.6cm}
- \begin{align*}
- x'(t) &= v_x(t) \\[0.65cm]
- y'(t) &= v_y(t) \\[0.75cm]
- v_x'(t) &= 0 \\[0.65cm]
- v_y'(t) &= -g
- \end{align*}
- \vspace*{0.0cm}
- \end{minipage}%
-% \only<1>{\hspace*{9.49cm}}\strut
- \only<1->{\hfill$\Rightarrow$\hfill}%
- \begin{onlyenv}<1>
- \begin{minipage}{8.3cm}
- \begin{align*}
- x(t) &= \int v_x(t)\,dt
- \visible<1->{= \int v_{0x}\,dt}
- \visible<1->{= x_0 + v_{0x}\cdot t}\\[\medskipamount]
- y(t) &= \int v_y(t)\,dt
- \visible<1->{= \int v_{0y} - g\cdot t\,dt}
- \visible<1->{= y_0 + v_{0y}\cdot t
- - {\textstyle\frac12}gt^2}\\[\bigskipamount]
- v_x(t) &= \int 0\,dt
- \visible<1->{= v_{0x}} \\[\medskipamount]
- v_y(t) &= \int -g\,dt
- \visible<1->{= v_{0y} - g\cdot t}
- \end{align*}
- \end{minipage}%
- \end{onlyenv}%
- \begin{onlyenv}<2->
- \begin{minipage}{3.5cm}
- \vspace*{0.5cm}
- \begin{lstlisting}[gobble=8,xleftmargin=0.5em]
- ¡x += vx * dt;¿
- \end{lstlisting}
- \vspace{0.75cm}
- \begin{lstlisting}[gobble=8,xleftmargin=0.5em]
- ¡y += vy * dt;¿
- \end{lstlisting}
- \vspace{0.90cm}
- \begin{lstlisting}[gobble=8,xleftmargin=0.5em]
- ¡vx += 0 * dt;¿
- \end{lstlisting}
- \vspace{0.75cm}
- \begin{lstlisting}[gobble=8,xleftmargin=0.5em]
- ¡vy += -g * dt;¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}{5.13cm}
- Siehe: \file{gtk-13.c}
- \end{minipage}
- \end{onlyenv}%
- \hfill\strut
-
-\end{frame}
-
-\begin{frame}[fragile]
- \showsection
- \showsubsection
-
- \textbf{Beispiel 1: Gleichmäßig beschleunigte Bewegung}
-
- \medskip
-
- \textbf{Beispiel 2: Mathematisches Pendel}
-
- \vspace*{-2\bigskipamount}
-
- \begin{picture}(0,0)
- \put(8,-6.5){\includegraphics{pendulum.pdf}}
- \end{picture}
-
- \begin{eqnarray*}
- \varphi'(t) &=& \omega(t) \\[\smallskipamount]
- \omega'(t) &=& -\frac{g}{l}\cdot\sin\varphi(t)\hspace*{7.1cm}
- \end{eqnarray*}
- \vspace*{-1.5\medskipamount}
- \begin{itemize}
- \item
- Von Hand (analytisch):\\
- Lösung raten (Ansatz), Parameter berechnen
- \item
- Mit Computer (numerisch):\\
- Eulersches Polygonzugverfahren
- \end{itemize}
- \smallskip
- \begin{lstlisting}[gobble=0]
- phi += dt * omega;
- omega += - dt * g / l * sin (phi);
- \end{lstlisting}
-
- \pause
- \bigskip
-
- \textbf{Beispiel 3: Weltraum-Simulation}
-
- Praktikumsaufgabe
- \vspace*{-1cm}
-
-\end{frame}
-
-\setcounter{section}{4}
-\section{Algorithmen}
-\setcounter{subsection}{1}
-\subsection{Rekursion}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Vollständige Induktion:
- \vspace*{-0.725cm}
- \begin{displaymath}
- \hspace*{4cm}
- \left.
- \begin{array}{r}
- \mbox{Aussage gilt für $n = 1$}\\[2pt]
- \mbox{Schluß von $n - 1$ auf $n$}
- \end{array}
- \right\}
- \mbox{Aussage gilt für alle $n\in\mathbb{N}$}
- \end{displaymath}
- \vspace*{-0.5cm}
-
- \pause
-
- Türme von Hanoi
-
- \begin{onlyenv}<2>
- \begin{center}
- \includegraphics[width=12.2cm]{Tower_of_Hanoi.jpeg}
- \end{center}
- \end{onlyenv}
-
- \begin{onlyenv}<3->
- \begin{itemize}
- \item
- 64 Scheiben, 3 Plätze,
- \only<3-4>{\hfill\makebox(0,0)[rt]{\includegraphics[width=6cm]{Tower_of_Hanoi.jpeg}}}\\
- immer 1 Scheibe verschieben
- \item
- Ziel: Turm verschieben
- \item
- Es dürfen nur kleinere Scheiben\\
- auf größeren liegen.
- \bigskip
- \pause
- \pause
- \item
- $n = 1$ Scheibe: fertig
- \item
- Wenn $n - 1$ Scheiben verschiebbar:\\
- schiebe $n - 1$ Scheiben auf Hilfsplatz,\\
- verschiebe die darunterliegende,\\
- hole $n - 1$ Scheiben von Hilfsplatz
- \end{itemize}
- \begin{onlyenv}<5>
- \vspace{-4.3cm}
- \begin{lstlisting}[gobble=8,xleftmargin=6.4cm]
- void move (int from, int to, int disks)
- {
- if (disks == 1)
- move_one_disk (from, to);
- else
- {
- int help = 0 + 1 + 2 - from - to;
- move (from, help, disks - 1);
- move (from, to, 1);
- move (help, to, disks - 1);
- }
- }
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<6->
- \vspace{-5.0cm}
- \hspace*{7.4cm}\begin{minipage}[t]{5cm}
- 32 Scheiben:
- \begin{lstlisting}[gobble=10,style=terminal]
- $ ¡time ./hanoi-9b¿
- ...
- real 0m30,672s
- user 0m30,662s
- sys 0m0,008s
- \end{lstlisting}
- \pause[7]
- \begin{itemize}
- \arrowitem
- etwas über 1 Minute\\
- für 64 Scheiben
- \end{itemize}
- \pause
- \vspace*{-0.5cm}
- \begin{picture}(0,0)
- \color{red}
- \put(0,0){\makebox(0,0)[bl]{\tikz[line width=1pt]{\draw(0,0)--(4,0.8);}}}
- \put(0,0.8){\makebox(0,0)[tl]{\tikz[line width=1pt]{\draw(0,0)--(4,-0.8);}}}
- \end{picture}
-
- Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit!
- % 30.672 * 2^32 / 3600 / 24 / 365.25 = 4174.43775518138261464750
- \begin{itemize}
- \arrowitem
- $\frac{30,672\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4174$
- Jahre\\[\smallskipamount]
- für 64 Scheiben
- \end{itemize}
- \end{minipage}
- \end{onlyenv}
- \end{onlyenv}
-
-\end{frame}
-
-\subsection{Aufwandsabschätzungen \protect\color{gray}-- Komplexitätsanalyse}
-
-\begin{frame}[fragile]
-
-% \newcommand{\w}{\hspace*{0.75pt}}
-
- \showsubsection
-
- \begin{picture}(0,0)
- \put(7.6,-0.5){%
- \begin{minipage}[t]{5.3cm}
-% \vspace*{-1.0cm}\includegraphics{landau-symbols.pdf}
- \vspace*{-1.0cm}\alt<16->{\includegraphics{landau-symbols-3.pdf}}%
- {\alt<15->{\includegraphics{landau-symbols-2.pdf}}%
- {\includegraphics{landau-symbols.pdf}}}
- \small
- \begin{description}\itemsep0pt\leftskip-0.5cm
- \item[$n$:] Eingabedaten
- \item[$g(n)$:] Rechenzeit
- \end{description}
- \end{minipage}}
- \end{picture}
-
- \vspace*{-\bigskipamount}
-
- Wann ist ein Programm "`schnell"'?
-
- \medskip
-
- \begin{onlyenv}<1-2>
- Türme von Hanoi: $\mathcal{O}(2^n)$
- \par\medskip
- Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit!
- \begin{itemize}
- \arrowitem
- $\frac{30,672\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4174$
- Jahre\\[\smallskipamount]
- für 64 Scheiben
- \end{itemize}
-
- \bigskip
- \end{onlyenv}
-
- \begin{onlyenv}<2->
- Faustregel:\\Schachtelung der Schleifen zählen\\
- $k$ Schleifen ineinander \textarrow\ $\mathcal{O}(n^k)$
-
- \bigskip
- \end{onlyenv}
-
- \begin{onlyenv}<3-13>
- \textbf{Beispiel: Sortieralgorithmen}
-
- \smallskip
-
- Anzahl der Vergleiche bei $n$ Strings
- \begin{itemize}
- \item
- Maximum suchen \pause[4]mit Schummeln\pause: $\mathcal{O}(1)$
- \pause
- \item
- Maximum suchen\pause: $\mathcal{O}(n)$
- \pause
- \item
- Selection-Sort\pause: $\mathcal{O}(n^2)$
- \pause
- \item
- Bubble-Sort\pause: $\mathcal{O}(n)$ bis $\mathcal{O}(n^2)$
- \pause
- \item
- Quicksort\pause: $\mathcal{O}(n\log n)$ bis $\mathcal{O}(n^2)$
- \end{itemize}
-
- \end{onlyenv}
-
- \begin{onlyenv}<14>
- \textbf{Wie schnell ist RSA-Verschlüsselung?}
-
- \smallskip
-
- \begin{math}
- c = m^e\,\%\,N
- \end{math}
- \quad
- ("`$\%$"' = "`modulo"')
-
- \medskip
-
- \begin{lstlisting}[gobble=6,xleftmargin=2em]
- int c = 1;
- for (int i = 0; i < e; i++)
- c = (c * m) % N;
- \end{lstlisting}
-
- \smallskip
-
- \begin{itemize}
- \item
- $\mathcal{O}(e)$ Iterationen
-% \item
-% wenn $n$ die Anzahl der Binärziffern (Bits) von $e$ ist:
-% $\mathcal{O}(2^n)$ Iterationen
- \item
- mit Trick:
- $\mathcal{O}(\log e)$ Iterationen ($\log e$ = Anzahl der Ziffern von $e$)
- \end{itemize}
-
- \smallskip
-
- Jede Iteration enthält eine Multiplikation und eine Division.\\
- Aufwand dafür: $\mathcal{O}(\log e)$\\
- \textarrow\ Gesamtaufwand: $\mathcal{O}\bigl((\log e)^2\bigr)$
-
- \end{onlyenv}
-
- \begin{onlyenv}<15->
-
- \textbf{Wie schnell ist RSA?}\\
-
- \smallskip
-
- ($n$ = typische beteiligte Zahl, z.\,B. $e,p,q$)
-
- \begin{itemize}
- \item
- Ver- und Entschlüsselung (Exponentiation):\\
- \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\!\left((\log n)^2\right)$\hss}
- \only<16->{{\color{magenta}$\mathcal{O}(n^2)$}}
- \item
- Schlüsselerzeugung (Berechnung von $d$):\\
- \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\!\left((\log n)^2\right)$\hss}
- \only<16->{{\color{magenta}$\mathcal{O}(n^2)$}}
- \item
- Verschlüsselung brechen (Primfaktorzerlegung):\\
- \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\bigl(2^{\sqrt{\log n\,\cdot\,\log\log n}}\bigr)$\hss}
- \only<16->{{\color{magenta}$\mathcal{O}\bigl(2^{\sqrt{n\log n}}\bigr)$}}
- \end{itemize}
-
- \vspace{0cm plus 1filll}
-
- \textbf{Die Sicherheit von RSA beruht darauf,
- daß das Brechen der Verschlüsselung aufwendiger ist als
- \boldmath$\mathcal{O}\bigl((\log n)^k\bigr)$ (für beliebiges $k$).}
-
- \vspace*{0.65cm}
-
- \end{onlyenv}
-
-\end{frame}
-
-\section{Objektorientierte Programmierung}
-
-\addtocounter{subsection}{-1}
-\subsection{Dynamische Speicherverwaltung}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \begin{itemize}
- \item
- Array: feste Anzahl von Elementen desselben Typs (z.\,B.\ 3 ganze Zahlen)
- \item
- Dynamisches Array: variable Anzahl von Elementen desselben Typs
- \end{itemize}
-
- \bigskip
-
- \begin{lstlisting}
- char *name[] = { "Anna", "Berthold", "Caesar" };
-
- ...
-
- name[3] = "Dieter";
- \end{lstlisting}
-
- \begin{picture}(0,0)
- \color{red}
- \put(0,0){\line(3,1){3.5}}
- \put(0,1){\line(3,-1){3.5}}
- \end{picture}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \bigskip
-
- \begin{lstlisting}
- #include <stdlib.h>
-
- ...
-
- char **name = malloc (3 * sizeof (char *));
- /* Speicherplatz für 3 Zeiger anfordern */
-
- ...
-
- free (name);
- /* Speicherplatz freigeben */
-
- \end{lstlisting}
-
-\end{frame}
-
-\subsection{Konzepte und Ziele}
-
-\begin{frame}
-
- \showsection
- \showsubsection
-
- \begin{itemize}
- \item
-% Array: feste Anzahl von Elementen desselben Typs (z.\,B.\ 3 ganze Zahlen)
- Array: Elemente desselben Typs (z.\,B.\ 3 ganze Zahlen)
-% \item
-% Dynamisches Array: variable Anzahl von Elementen desselben Typs
- \item
- Problem: Elemente unterschiedlichen Typs
- \item
- Lösung: den Typ des Elements zusätzlich speichern \textarrow\ \newterm{Objekt}
- \item
- Problem: Die Elemente sind unterschiedlich groß (Speicherplatz).
- \item
- Lösung: Im Array nicht die Objekte selbst speichern, sondern Zeiger darauf.
- \end{itemize}
- \begin{itemize}
- \item
- Funktionen, die mit dem Objekt arbeiten: \newterm{Methoden}
- \begin{onlyenv}<1>
- \item
- Was die Funktion bewirkt,\\
- hängt vom Typ des Objekts ab
- \item
- Realisierung über endlose \lstinline{if}-Ketten
- \end{onlyenv}
- \begin{onlyenv}<2>
- \item
- Was die Funktion bewirkt
- \begin{picture}(0,0)
- \color{red}
- \put(-4.00,-0.05){\tikz{\draw[thick](0,0.25)--(3.75,-0.05);%
- \draw[thick](-0.1,-0.05)--(3.75,0.3);}}
- \end{picture}%
- Welche Funktion aufgerufen wird,\\
- hängt vom Typ des Objekts ab: \newterm{virtuelle Methode}
- \item
- Realisierung über endlose \lstinline{if}-Ketten%
- \begin{picture}(0,0)
- \color{red}
- \put(-2.75,-0.05){\tikz{\draw[thick](0,0.25)--(2.5,-0.05);%
- \draw[thick](-0.1,-0.05)--(2.5,0.3);}}
- \put(1.5,-1.1){\begin{rotate}{7}\large\bf\textarrow\
-% kommt gleich
- nächste Woche
- \end{rotate}}
- \end{picture}
- Zeiger, die im Objekt gespeichert sind\\
- (Genaugenommen: Tabelle von Zeigern)
- \end{onlyenv}
- \end{itemize}
-
-\end{frame}
-
-\begin{frame}
-
- \showsection
- \showsubsection
-
- \begin{itemize}
- \item
- Problem: Elemente unterschiedlichen Typs
- \item
- Lösung: den Typ des Elements zusätzlich speichern \textarrow\ \newterm{Objekt}
- \item
- \newterm{Methoden\/} und \newterm{virtuelle Methoden}
- \end{itemize}
-
- \begin{itemize}
- \item
- Zeiger auf verschiedene Strukturen\\
- mit einem gemeinsamen Anteil von Datenfeldern\\
- \textarrow\ "`verwandte"' \newterm{Objekte}, \newterm{Klassenhierarchie} von Objekten
- \item
- Struktur, die \emph{nur\/} den gemeinsamen Anteil enthält\\
- \textarrow\ "`Vorfahr"', \newterm{Basisklasse}, \newterm{Vererbung}
- \item
-% Explizite Typumwandlung eines Zeigers auf die Basisklasse\\
-% in einen Zeiger auf die \newterm{abgeleitete Klasse}\\
-% \textarrow\ Man kann ein Array unterschiedlicher Objekte\\
-% \strut\phantom{\textarrow} in einer Schleife abarbeiten.\\
- Zeiger auf die Basisklasse dürfen auf Objekte\\
- der \newterm{abgeleiteten Klasse} zeigen\\
- \textarrow\ \newterm{Polymorphie}
- \end{itemize}
-
-\end{frame}
-
-\subsection{Beispiel: Zahlen und Buchstaben}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \begin{center}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- } t_base;¿
- \end{lstlisting}
- \end{minipage}\\[0.5cm]
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- int content;
- } t_integer;¿
- \end{lstlisting}
- \end{minipage}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- char *content;
- } t_string;¿
- \end{lstlisting}
- \end{minipage}
- \end{center}
-
-\end{frame}
-
-\begin{frame}[fragile]
- \begin{center}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- } t_base;¿
- \end{lstlisting}
- \end{minipage}\\[0.5cm]
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- int content;
- } t_integer;¿
- \end{lstlisting}
- \end{minipage}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- char *content;
- } t_string;¿
- \end{lstlisting}
- \end{minipage}\\[0.7cm]
- \begin{onlyenv}<1>
- \begin{minipage}{8cm}
- \begin{lstlisting}[gobble=10]
- ¡t_integer i = { 1, 42 };
- t_string s = { 2, "Hello, world!" };
-
- t_base *object[] = { (t_base *) &i, (t_base *) &s };¿
- \end{lstlisting}
- \end{minipage}%
- \begin{picture}(0,0)
- \color{red}
- \put(-5.4,-0.8){\mbox{$\underbrace{\rule{1.45cm}{0pt}}_{\shortstack{\strut explizite\\Typumwandlung}}$}}
- \end{picture}
- \end{onlyenv}
-% \begin{onlyenv}<2>
-% \begin{minipage}{5cm}
-% \begin{lstlisting}[gobble=10]
-% ¡typedef union
-% {
-% t_base base;
-% t_integer integer;
-% t_string string;
-% } t_object;¿
-% \end{lstlisting}
-% \end{minipage}
-% \end{onlyenv}
- \end{center}
-
-\end{frame}
-
-\iffalse
-
-\subsection{Unions}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Variable teilen sich denselben Speicherplatz.
-
- \medskip
-
- \begin{minipage}[t]{3.7cm}
- \begin{lstlisting}[gobble=6]
- ¡typedef union
- {
- int8_t i;
- uint8_t u;
- } num8_t;¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{4.5cm}
- \begin{lstlisting}[gobble=6]
- ¡int main (void)
- {
- num8_t test;
- test.i = -1;
- printf ("%d\n", test.u);
- return 0;
- }¿
- \end{lstlisting}
- \end{minipage}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Variable teilen sich denselben Speicherplatz.
-
- \medskip
-
- \begin{minipage}[t]{3.7cm}
- \begin{lstlisting}[gobble=6]
- ¡typedef union
- {
- char s[8];
- uint64_t x;
- } num_char_t;¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{4.5cm}
- \begin{lstlisting}[gobble=6]
- ¡int main (void)
- {
- num_char_t test = { "Hello!" };
- printf ("%lx\n", test.x);
- return 0;
- }¿
- \end{lstlisting}
- \end{minipage}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Variable teilen sich denselben Speicherplatz.
-
- \medskip
-
- \begin{minipage}[t]{3.7cm}
- \begin{lstlisting}[gobble=6]
- ¡typedef union
- {
- t_base base;
- t_integer integer;
- t_string string;
- } t_object;¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{3.0cm}
- \begin{lstlisting}[gobble=6]
-
- ¡typedef struct
- {
- int type;
- } t_base;¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{3.0cm}
- \begin{lstlisting}[gobble=6]
-
- ¡typedef struct
- {
- int type;
- int content;
- } t_integer;¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{3.0cm}
- \begin{lstlisting}[gobble=6]
-
- ¡typedef struct
- {
- int type;
- char *content;
- } t_string;¿
- \end{lstlisting}
- \end{minipage}
-
- \bigskip
-
- \begin{center}
- \begin{minipage}{8.5cm}
- \begin{lstlisting}[gobble=8]
- ¡if (this->base.type == T_INTEGER)
- printf ("Integer: %d\n", this->integer.content);
- else if (this->base.type == T_STRING)
- printf ("String: \"%s\"\n", this->string.content);¿
- \end{lstlisting}
- \end{minipage}
- \end{center}
-
-\end{frame}
-
-\subsection{Virtuelle Methoden}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{lstlisting}
- void print_object (t_object *this)
- {
- if (this->base.type == T_INTEGER)
- printf ("Integer: %d\n", this->integer.content);
- else if (this->base.type == T_STRING)
- printf ("String: \"%s\"\n", this->string.content);
- }
- \end{lstlisting}
-
- \begin{picture}(0,0)
- \color{red}
- \put(9,1.7){\shortstack[l]{if-Kette:\\\strut wird unübersichtlich}}
- \put(1,-2){\mbox{\textarrow}}
- \put(0,-3){\mbox{Zeiger auf Funktionen}}
- \end{picture}
-
- \begin{lstlisting}[xleftmargin=4cm]
- void print_integer (t_object *this)
- {
- printf ("Integer: %d\n", this->integer.content);
- }
-
- void print_string (t_object *this)
- {
- printf ("String: \"%s\"\n", this->string.content);
- }
- \end{lstlisting}
-
-\end{frame}
-
-\begin{frame}[fragile]
- \showsubsection
-
- Zeiger auf Funktionen
-
- \medskip
-
- \begin{lstlisting}
- void (* print) (t_object *this);
- \end{lstlisting}
- \begin{picture}(0,1.2)(0,-0.9)
- \color{red}
- \put(0.95,0.3){\mbox{$\underbrace{\rule{1cm}{0pt}}$}}
- \put(0.2,-0.7){\shortstack{das, worauf print zeigt,\\ist eine Funktion}}
- \end{picture}
-
- \begin{itemize}
- \item
- Objekt enthält Zeiger auf Funktion
- \begin{onlyenv}<1>
- \medskip
- \begin{lstlisting}[gobble=10]
- typedef struct
- {
- void (* print) (union t_object *this);
- int content;
- } t_integer;
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<2->
- \vspace*{-3.5cm} % Why doesn't a picture environment work here??? :-(
- \begin{lstlisting}[gobble=10,xleftmargin=5.5cm]
- typedef struct
- {
- void (* print) (union t_object *this);
- int content;
- } t_integer;
- \end{lstlisting}
- \vspace*{0.85cm}
- \bigskip
- \smallskip
- \end{onlyenv}
- \pause
- \item
- Konstruktor initialisiert diesen Zeiger
- \begin{onlyenv}<2>
- \medskip
- \begin{lstlisting}[gobble=10]
- t_object *new_integer (int i)
- {
- t_object *p = malloc (sizeof (t_integer));
- p->integer.print = print_integer;
- p->integer.content = i;
- return p;
- }
- \end{lstlisting}
- \vspace*{-2cm}
- \end{onlyenv}
- \pause
- \item
- Aufruf: "`automatisch"' die richtige Funktion
- \begin{onlyenv}<3>
- \medskip
- \begin{lstlisting}[gobble=10]
- for (int i = 0; object[i]; i++)
- object[i]->base.print (object[i]);
- \end{lstlisting}
- \end{onlyenv}
- \pause
- \medskip
- \item
- in größeren Projekten:\\
- Objekt enthält Zeiger auf Tabelle von Funktionen
- \end{itemize}
-\end{frame}
-
-\subsection{Beispiel: Graphische Benutzeroberfläche (GUI)}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \scriptsize
- \begin{lstlisting}
- #include <gtk/gtk.h>
-
- int main (int argc, char **argv)
- {
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
- gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
- GtkWidget *label = gtk_label_new ("Hello, world!");
- gtk_container_add (GTK_CONTAINER (vbox), label);
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
- gtk_widget_show (button);
- gtk_widget_show (label);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
- }
- \end{lstlisting}
-
- \vspace*{-6cm}\strut\hfill
- \includegraphics[scale=0.85]{hello-gtk.png}\\[2cm]
- \begin{flushright}
- \normalsize\bf Praktikumsversuch:\\
- Objektorientiertes Zeichenprogramm
- \end{flushright}
-
-\end{frame}
-
-\subsection{Ausblick: C++}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{center}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- void (* print) (union t_object *this);
- } t_base;¿
- \end{lstlisting}
- \end{minipage}\\[0.5cm]
- \begin{minipage}{5.5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- void (* print) (...);
- int content;
- } t_integer;¿
- \end{lstlisting}
- \end{minipage}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- void (* print) (union t_object *this);
- char *content;
- } t_string;¿
- \end{lstlisting}
- \end{minipage}
- \end{center}
-
-\end{frame}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{center}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡struct TBase
- {
- virtual void print (void);
- };¿
- \end{lstlisting}
- \end{minipage}\\[0.5cm]
- \begin{minipage}{5.5cm}
- \begin{lstlisting}[gobble=8]
- ¡struct TInteger: public TBase
- {
- virtual void print (void);
- int content;
- };¿
- \end{lstlisting}
- \end{minipage}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡struct TString: public TBase
- {
- virtual void print (void);
- char *content;
- };¿
- \end{lstlisting}
- \end{minipage}
- \end{center}
-
-\end{frame}
-
-\fi
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \item[\textbf{5}] \textbf{Algorithmen}
- \begin{itemize}
- \item[5.1] Differentialgleichungen
- \item[5.2] Rekursion
- \color{medgreen}
- \item[5.3] Aufwandsabschätzungen
- \end{itemize}
- \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
- \begin{itemize}
- \color{medgreen}
- \item[6.0] Dynamische Speicherverwaltung
- \item[6.1] Konzepte und Ziele
- \item[6.2] Beispiel: Zahlen und Buchstaben
- \color{red}
- \item[6.3] Unions
- \item[6.4] Virtuelle Methoden
- \item[6.5] Beispiel: Graphische Benutzeroberfläche (GUI)
- \item[6.6] Ausblick: C++
- \end{itemize}
- \item[\textbf{7}] \textbf{Datenstrukturen}
- \vspace*{-1cm}
- \end{itemize}
-
-\end{frame}
-
-\end{document}
diff --git a/20221121/hp-musterloesung-20221121.pdf b/20221121/hp-musterloesung-20221121.pdf
deleted file mode 100644
index 0212d7bf439848a345bd333663313bb13818b6c2..0000000000000000000000000000000000000000
Binary files a/20221121/hp-musterloesung-20221121.pdf and /dev/null differ
diff --git a/20221121/hp-musterloesung-20221121.tex b/20221121/hp-musterloesung-20221121.tex
deleted file mode 100644
index cdc410d755bc7e105d8711bdffa53b637cf3aa08..0000000000000000000000000000000000000000
--- a/20221121/hp-musterloesung-20221121.tex
+++ /dev/null
@@ -1,433 +0,0 @@
-% hp-musterloesung-20221121.pdf - Solutions to the Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Kondensator, Personen-Datenbank, Fakultät
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-\usepackage{gnuplot-lua-tikz}
-
-\begin{document}
-
- \section*{Hardwarenahe Programmierung\\
- Musterlösung zu den Übungsaufgaben -- 21.\ November 2022}
-
- \exercise{Kondensator}
-
- Ein Kondensator der Kapazität $C = 100\,\mu{\rm F}$
- ist auf die Spannung $U_0 = 5\,{\rm V}$ aufgeladen
- und wird über einen Widerstand $R = 33\,{\rm k}\Omega$ entladen.
-
- \begin{enumerate}[(a)]
- \item
- Schreiben Sie ein C-Programm, das
- den zeitlichen Spannungsverlauf in einer Tabelle darstellt.
- \points{5}
- \item
- Schreiben Sie ein C-Programm, das ermittelt,
- wie lange es dauert, bis die Spannung unter $0.1\,{\rm V}$ gefallen ist.
- \points{4}
- \item
- Vergleichen Sie die berechneten Werte mit der exakten theoretischen Entladekurve:
- \begin{math}
- U(t) = U_0 \cdot e^{-\frac{t}{RC}}
- \end{math}\\
- \points{3}
- \end{enumerate}
-
- Hinweise:
- \begin{itemize}
- \item
- Für die Simulation zerlegen wir den Entladevorgang in kurze Zeitintervalle $dt$.
- Innerhalb jedes Zeitintervalls betrachten wir den Strom $I$ als konstant
- und berechnen, wieviel Ladung $Q$ innerhalb des Zeitintervalls
- aus dem Kondensator herausfließt.
- Aus der neuen Ladung berechnen wir die Spannung am Ende des Zeitintervalls.
- \item
- Für den Vergleich mit der exakten theoretischen Entladekurve
- benötigen Sie die Exponentialfunktion \lstinline{exp()}.
- Diese finden Sie in der Mathematik-Bibliothek:
- \lstinline{#include <math.h>} im Quelltext,
- beim \lstinline[style=cmd]{gcc}-Aufruf \lstinline[style=cmd]{-lm} mit angeben.
- \item
- $Q = C \cdot U$,\quad $U = R \cdot I$,\quad $I = \frac{dQ}{dt}$
- \end{itemize}
-
- \solution
-
- \begin{itemize}
- \item
- \textbf{Schreiben Sie ein C-Programm, das
- den zeitlichen Spannungsverlauf in einer Tabelle darstellt.}
-
- In dem Programm \gitfile{hp}{2022ws/20221121}{loesung-1a.c}
- arbeiten wir, dem ersten Hinweis folgend,
- mit einem Zeitintervall von \lstinline{dt = 0.01}.
- Mit dieser Schrittweite lassen wir uns eine Tabelle ausgeben,
- die jeweils die Zeit und durch die Simulation berechnete Spannung ausgibt.
-
- Wir simulieren, wie die Ladung $Q = C \cdot U$ des Kondensators
- im Laufe der Zeit abfließt.
- Dazu berechnen wir in jedem Zeitschritt zunächst den Strom $I = U / R$,
- der aus dem Kondensator fließt.
- Dieser Strom bewirkt, daß innerhalb des Zeitintervalls $dt$
- die Ladung $dQ = I \cdot dt$ aus dem Kondensator abfließt.
- Am Ende des Zeitintervalls berechnen wir die zur neuen Ladung $Q$
- gehörende neue Spannung $U = Q / C$.
-
- Für eine einfache Ausgabe der Tabelle
- verwenden wir die Formatspezifikationen \lstinline{%10.3lf} für drei
- bzw.\ \lstinline{%15.8lf} für acht Nachkommastellen Genauigkeit.
- Damit schreiben wir jeweils eine \emph{lange Fließkommazahl\/} (\lstinline{%lf})
- rechtsbündig in ein Feld der Breite 10 bzw.\ 15
- und lassen uns 3 bzw.\ 8 Nachkommastellen ausgeben.
-
- Wir compilieren das Programm mit:
- \lstinline[style=cmd]{gcc -Wall -O loesung-1a.c -o loesung-1a}
-
- \item
- \textbf{Schreiben Sie ein C-Programm, das ermittelt,
- wie lange es dauert, bis die Spannung unter \boldmath $0.1\,{\rm V}$ gefallen ist.}
-
- Wir ändern das Programm \gitfile{hp}{2022ws/20221121}{loesung-1a.c} so ab,
- daß zum einen die Schleife abbricht, sobald die Spannung
- den Wert $0.1\,{\rm V}$ unterschreitet (\gitfile{hp}{2022ws/20221121}{loesung-1b.c}),
- und daß zum anderen nicht jedesmal eine Zeile für die Tabelle ausgegeben wird,
- sondern erst am Ende die Zeit (und die Spannung).
-
- Der Ausgabe entnehmen wir, daß die Spannung bei etwa $t = 12.90\,{\rm s}$
- den Wert $0.1\,{\rm V}$ unterschreitet.
-
- \item
- \textbf{Vergleichen Sie die berechneten Werte
- mit der exakten theoretischen Entladekurve:\\[0.5\smallskipamount]
- \boldmath
- \begin{math}
- U(t) = U_0 \cdot e^{-\frac{t}{RC}}
- \end{math}}
-
- Wir ändern das Programm \gitfile{hp}{2022ws/20221121}{loesung-1a.c} so ab,
- daß es zusätzlich zur Zeit und zur simulierten Spannung
- die exakte Spannung $U_0 \cdot e^{-\frac{t}{RC}}$
- gemäß der theoretischen Entladekurve ausgibt (\gitfile{hp}{2022ws/20221121}{loesung-1c.c}),
-
- Da dieses Programm die Exponentialfunktion verwendet, müssen wir nun
- beim Compilieren zusätzlich \lstinline[style=cmd]{-lm}\hspace{1pt}
- für das Einbinden der Mathematik-Bibliothek angeben.
-
- Der erweiterten Tabelle können wir entnehmen,
- daß die durch die Simulation berechnete Spannung
- mit der Spannung $U_0 \cdot e^{-\frac{t}{RC}}$
- gemäß der theoretischen Entladekurve
- bis auf wenige Prozent übereinstimmt.
- Dies ist für viele praktische Anwendungen ausreichend,
- wenn auch nicht für Präzisionsmessungen.
-
- Wenn Sie die Ausgabe des Programms, z.\,B.\ mit
- \lstinline[style=cmd]{./loesung-1c > loesung-1c.dat},
- in einer Datei \gitfile{hp}{2022ws/20221121}{loesung-1c.dat} speichern,
- können Sie sich die beiden Kurven graphisch darstellen lassen,
- z.\,B.\ mit \file{gnuplot} und dem folgenden Befehl:
- \begin{lstlisting}[style=cmd,gobble=8]
- plot "loesung-1c.dat" using 1:2 with lines title "Simulation",
- "loesung-1c.dat" using 1:3 with lines title "Theorie"
- \end{lstlisting}
- \vspace*{-\bigskipamount}
- \begin{center}
- \input{loesung-1c.tikz}
- \end{center}
- Der Unterschied zwischen der simulierten und der theoretischen Entladungskurve
- ist mit bloßem Auge nicht sichtbar.
- \end{itemize}
-
- \exercise{Personen-Datenbank}
-
- Wir betrachten das folgende Programm (\gitfile{hp}{2022ws/20221121}{aufgabe-2.c}):
- \begin{lstlisting}
- #include <stdio.h>
- #include <string.h>
-
- typedef struct
- {
- char first_name[10];
- char family_name[20];
- char day, month;
- int year;
- } person;
-
- int main (void)
- {
- person sls;
- sls.day = 26;
- sls.month = 7;
- sls.year = 1951;
- strcpy (sls.first_name, "Sabine");
- strcpy (sls.family_name, "Leutheusser-Schnarrenberger");
- printf ("%s %s wurde am %d.%d.%d geboren.\n",
- sls.first_name, sls.family_name, sls.day, sls.month, sls.year);
- return 0;
- }
- \end{lstlisting}
-
- Die Standard-Funktion \lstinline{strcpy()} bewirkt ein Kopieren eines Strings
- von rechts nach links, hier also z.\,B.\ die Zuweisung der String-Konstanten
- \lstinline{"Sabine"} an die String-Variable \lstinline{sls.first_name[]}.
-
- Das Programm wird für einen 32-Bit-Rechner compiliert und ausgeführt.\\
- (Die \lstinline[style=cmd]{gcc}-Option \lstinline[style=cmd]{-m32} sorgt dafür,
- daß \lstinline[style=cmd]{gcc} Code für einen 32-Bit-Prozessor erzeugt.)
-
- \begin{lstlisting}[style=terminal]
- $ ¡gcc -Wall -O -m32 aufgabe-2.c -o aufgabe-2¿
- $ ¡./aufgabe-2¿
- Sabine Leutheusser-Schnarrenberger wurde am 110.98.1701278309 geboren.
- Speicherzugriffsfehler
- \end{lstlisting}
-
- \begin{enumerate}[\quad(a)]
- \item
- Erklären Sie die Ausgabe des Programms einschließlich der Zahlenwerte.
- \points{4}
- \item
- Welche Endianness hat der verwendete Rechner?
- Begründen Sie Ihre Antwort.
- \points{1}
- \item
- Wie sähe die Ausgabe auf einem Rechner mit entgegengesetzter Endianness aus?
- \points{2}
- \item
- Erklären Sie den Speicherzugriffsfehler.
- (Es kann sein, daß sich der Fehler auf Ihrem Rechner nicht bemerkbar macht.
- Er ist aber trotzdem vorhanden.)
- \points{2}
- \end{enumerate}
-
- \goodbreak
-
- \solution
-
- \begin{enumerate}[\quad(a)]
- \item
- \textbf{Erklären Sie die Ausgabe des Programms einschließlich der Zahlenwerte.}
-
- Der String \lstinline{"Leutheusser-Schnarrenberger"}
- hat 27 Zeichen und daher mehr als die in der Variablen
- \lstinline{sls.family_name} vorgesehenen 20 Zeichen.
- Das \lstinline{"nberger"} paßt nicht mehr in die String-Variable.
-
- Die Zuweisung \lstinline{strcpy (sls.family_name, "Leutheusser-Schnarrenberger")}
- überschreibt daher 8 Speicherzellen außerhalb der String-Variablen
- \lstinline{sls.family_name} mit dem String \lstinline{"nberger"}
- (7 Buchstaben zzgl.\ String-Ende-Symbol) -- und damit insbesondere die Variablen
- \lstinline{sls.day}, \lstinline{sls.month} und \lstinline{sls.year}.
-
- Die überschriebenen Speicherzellen sehen demnach folgendermaßen aus:
- \begin{center}
- \begin{picture}(8,1.5)(0,-0.5)
- \put(0,0){\line(1,0){8}}
- \put(0,1){\line(1,0){8}}
- \multiput(0,0)(1,0){9}{\line(0,1){1}}
- \put(0.4,0.38){\lstinline{n}}
- \put(1.4,0.38){\lstinline{b}}
- \put(2.4,0.38){\lstinline{e}}
- \put(3.4,0.38){\lstinline{r}}
- \put(4.4,0.38){\lstinline{g}}
- \put(5.4,0.38){\lstinline{e}}
- \put(6.4,0.38){\lstinline{r}}
- \put(7.5,0.5){\makebox(0,0){\lstinline{0x00}}}
- \put(0.5,-0.1){\makebox(0,0)[t]{$\underbrace{\rule{0.95cm}{0pt}}_{\mbox{\lstinline{day}}}$}}
- \put(1.5,-0.1){\makebox(0,0)[t]{$\underbrace{\rule{0.95cm}{0pt}}_{\mbox{\lstinline{month}}}$}}
- \put(4.0,-0.1){\makebox(0,0)[t]{$\underbrace{\rule{3.95cm}{0pt}}_{\mbox{\lstinline{year}}}$}}
- \put(7.0,-0.1){\makebox(0,0)[t]{$\underbrace{\rule{1.95cm}{0pt}}_{\mbox{?}}$}}
- \end{picture}
- \end{center}
- ("`?"' steht für zwei Speicherzellen, von denen wir nicht wissen,
- wofür sie genutzt werden.)
-
- Wenn wir die ASCII-Zeichen in Hexadezimalzahlen umrechnen, entspricht dies:
- \begin{center}
- \begin{picture}(7,1.5)(0,-0.5)
- \put(0,0){\line(1,0){8}}
- \put(0,1){\line(1,0){8}}
- \multiput(0,0)(1,0){9}{\line(0,1){1}}
- \put(0.5,0.5){\makebox(0,0){\lstinline{0x6e}}}
- \put(1.5,0.5){\makebox(0,0){\lstinline{0x62}}}
- \put(2.5,0.5){\makebox(0,0){\lstinline{0x65}}}
- \put(3.5,0.5){\makebox(0,0){\lstinline{0x72}}}
- \put(4.5,0.5){\makebox(0,0){\lstinline{0x67}}}
- \put(5.5,0.5){\makebox(0,0){\lstinline{0x65}}}
- \put(6.5,0.5){\makebox(0,0){\lstinline{0x72}}}
- \put(7.5,0.5){\makebox(0,0){\lstinline{0x00}}}
- \put(0.5,-0.1){\makebox(0,0)[t]{$\underbrace{\rule{0.95cm}{0pt}}_{\mbox{\lstinline{day}}}$}}
- \put(1.5,-0.1){\makebox(0,0)[t]{$\underbrace{\rule{0.95cm}{0pt}}_{\mbox{\lstinline{month}}}$}}
- \put(4.0,-0.1){\makebox(0,0)[t]{$\underbrace{\rule{3.95cm}{0pt}}_{\mbox{\lstinline{year}}}$}}
- \put(7.0,-0.1){\makebox(0,0)[t]{$\underbrace{\rule{1.95cm}{0pt}}_{\mbox{?}}$}}
- \end{picture}
- \end{center}
- Dies entspricht bereits genau den Werten \lstinline{110} und \lstinline{98}
- für die Variablen \lstinline{sls.day} bzw.\ \lstinline{sls.month}.
-
- Für die Variable \lstinline{sls.year} müssen wir ihre vier Speicherzellen
- unter der Berücksichtigung der Endianness des Rechners zusammenziehen.
- Für Big-Endian ergibt dies \lstinline{0x65726765 == 1701996389}.
- Für Little-Endian ergibt sich der Wert \lstinline{0x65677265 == 1701278309},
- der auch in der Ausgabe des Programms auftaucht.
-
- \item
- \textbf{Welche Endianness hat der verwendete Rechner?
- Begründen Sie Ihre Antwort.}
-
- Wie in (a) begründet, ergibt sich die Ausgabe von
- \lstinline[style=terminal]{1701278309} für das Jahr
- aus dem Speicherformat Little-Endian.
-
- \item
- \textbf{Wie sähe die Ausgabe auf einem Rechner mit entgegengesetzter Endianness aus?}
-
- Wie in (a) begründet, ergäbe sich aus dem Speicherformat Big-Endian
- die Ausgabe von \lstinline[style=terminal]{1701996389} für das Jahr.
-
- \item
- \textbf{Erklären Sie den Speicherzugriffsfehler.
- (Es kann sein, daß sich der Fehler auf Ihrem Rechner nicht bemerkbar macht.
- Er ist aber trotzdem vorhanden.)}
-
- Die zwei in (a) mit "`?"' bezeichneten Speicherzellen
- wurden ebenfalls überschrieben.
- Dies ist in der Ausgabe zunächst nicht sichtbar,
- bewirkt aber später den Speicherzugriffsfehler.
-
- (Tatsächlich handelt es sich bei den überschriebenen Speicherzellen
- um einen Teil der Rücksprungadresse, die \lstinline{main()} verwendet,
- um mit \lstinline{return 0} an das Betriebssystem zurückzugeben.)
-
- \end{enumerate}
-
- \textbf{Hinweis 1:}
- Um auf einen solchen Lösungsweg zu kommen, wird empfohlen,
- "`geheimnisvolle"' Zahlen nach hexadezimal umzurechnen
- und in Speicherzellen (Zweiergruppen von Hex-Ziffern) zu zerlegen.
- Oft erkennt man dann direkt ASCII-Zeichen:
- Großbuchstaben beginnen mit der Hex-Ziffer \lstinline{4} oder \lstinline{5},
- Kleinbuchstaben mit \lstinline{6} oder \lstinline{7}.
-
- \textbf{Hinweis 2:}
- Um derartige Programmierfehler in der Praxis von vorneherein zu vermeiden,
- wird empfohlen, anstelle von \lstinline{strcpy()}
- grundsätzlich die Funktion \lstinline{strncpy()} zu verwenden.
- Diese erwartet einen zusätzlichen Parameter,
- der die maximal zulässige Länge des Strings enthält.
- Ohne einen derartigen expliziten Parameter kann die Funktion nicht wissen,
- wie lang die Variable ist, in der der String gespeichert werden soll.
-
- \exercise{Fakultät}
-
- Die Fakultät $n!$ einer ganzen Zahl $n \ge 0$ ist definiert als:
- \begin{eqnarray*}
- 1 & \mbox{für} & n = 0, \\
- n \cdot (n-1)! & \mbox{für} & n > 0.
- \end{eqnarray*}
-
- Mit anderen Worten: $n! = 1\cdot2\cdot3\cdot\dots\cdot n$.
-
- Die folgende Funktion \lstinline{fak()} berechnet die Fakultät \emph{rekursiv}
- (Datei: \gitfile{hp}{2022ws/20221121}{aufgabe-3.c}):
-
- \begin{lstlisting}
- int fak (int n)
- {
- if (n <= 0)
- return 1;
- else
- return n * fak (n - 1);
- }
- \end{lstlisting}
-
- \begin{enumerate}[\quad(a)]
- \item
- Schreiben Sie eine Funktion, die die Fakultät \emph{iterativ} berechnet,\\
- d.\,h.\ mit Hilfe einer Schleife anstelle von Rekursion.
- \points{3}
- \item
- Wie viele Multiplikationen (Landau-Symbol)
- erfordern beide Versionen der Fakultätsfunktion\\
- in Abhängigkeit von \lstinline$n$?
- Begründen Sie Ihre Antwort.
- \points{2}
- \item
- Wieviel Speicherplatz (Landau-Symbol)
- erfordern beide Versionen der Fakultätsfunktion\\
- in Abhängigkeit von \lstinline$n$?
- Begründen Sie Ihre Antwort.
- \points{3}
- \end{enumerate}
-
- \solution
-
- \begin{itemize}
- \item[(a)]
- \textbf{Schreiben Sie eine Funktion, die die Fakultät \emph{iterativ} berechnet,\\
- d.\,h.\ mit Hilfe einer Schleife anstelle von Rekursion.}
-
- Datei: \gitfile{hp}{2022ws/20221121}{loesung-3.c}
- \begin{lstlisting}[gobble=8]
- int fak (int n)
- {
- int f = 1;
- for (int i = 2; i <= n; i++)
- f *= i;
- return f;
- }
- \end{lstlisting}
-
- \item[(b)]
- \textbf{Wie viele Multiplikationen (Landau-Symbol)
- erfordern beide Versionen der Fakultätsfunktion\\
- in Abhängigkeit von \lstinline$n$?
- Begründen Sie Ihre Antwort.}
-
- In beiden Fällen werden $n$ Zahlen miteinander multipliziert --
- oder $n - 1$, wenn man Multiplikationen mit 1 ausspart.
- In jedem Fall hängt die Anzahl der Multiplikationen
- linear von $n$ ab; es sind $\mathcal{O}(n)$ Multiplikationen.
- Insbesondere arbeiten also beide Versionen gleich schnell.
-
- \item[(c)]
- \textbf{Wieviel Speicherplatz (Landau-Symbol)
- erfordern beide Versionen der Fakultätsfunktion\\
- in Abhängigkeit von \lstinline$n$?
- Begründen Sie Ihre Antwort.}
-
- Die iterative Version der Funktion benötigt 2 Variable vom Typ \lstinline{int},
- nämlich \lstinline{n} und \lstinline{f}.
- Dies ist eine konstante Zahl;
- der Speicherplatzverbrauch ist daher $\mathcal{O}(1)$.
-
- Die rekursive Version der Funktion erzeugt
- jedesmal, wenn sie sich selbst aufruft,
- eine zusätzliche Variable \lstinline{n}.
- Es sind $n + 1$ Aufrufe; die Anzahl der Variablen \lstinline{n}
- hängt linear von $n$ ab; der Speicherplatzverbrauch ist also $\mathcal{O}(n)$.
- \end{itemize}
-
-\end{document}
diff --git a/20221121/hp-uebung-20221121.pdf b/20221121/hp-uebung-20221121.pdf
deleted file mode 100644
index ee7b3fedfbebeb8bb67b1b9bab08b5d60ad8563b..0000000000000000000000000000000000000000
Binary files a/20221121/hp-uebung-20221121.pdf and /dev/null differ
diff --git a/20221121/hp-uebung-20221121.tex b/20221121/hp-uebung-20221121.tex
deleted file mode 100644
index 0c3a7d5c188ef529c5652858f67158bb8f95ae91..0000000000000000000000000000000000000000
--- a/20221121/hp-uebung-20221121.tex
+++ /dev/null
@@ -1,194 +0,0 @@
-% hp-uebung-20221121.pdf - Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Kondensator, Personen-Datenbank, Fakultät
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\begin{document}
-
- \thispagestyle{empty}
-
- \section*{Hardwarenahe Programmierung\\
- Übungsaufgaben -- 21.\ November 2022}
-
- Diese Übung enthält Punkteangaben wie in einer Klausur.
- Um zu "`bestehen"', müssen Sie innerhalb von 85 Minuten
- unter Verwendung ausschließlich zugelassener Hilfsmittel
- 15 Punkte (von insgesamt \totalpoints) erreichen.
-
- \exercise{Kondensator}
-
- Ein Kondensator der Kapazität $C = 100\,\mu{\rm F}$
- ist auf die Spannung $U_0 = 5\,{\rm V}$ aufgeladen
- und wird über einen Widerstand $R = 33\,{\rm k}\Omega$ entladen.
-
- \begin{enumerate}[(a)]
- \item
- Schreiben Sie ein C-Programm, das
- den zeitlichen Spannungsverlauf in einer Tabelle darstellt.
- \points{5}
- \item
- Schreiben Sie ein C-Programm, das ermittelt,
- wie lange es dauert, bis die Spannung unter $0.1\,{\rm V}$ gefallen ist.
- \points{4}
- \item
- Vergleichen Sie die berechneten Werte mit der exakten theoretischen Entladekurve:
- \begin{math}
- U(t) = U_0 \cdot e^{-\frac{t}{RC}}
- \end{math}\\
- \points{3}
- \end{enumerate}
-
- Hinweise:
- \begin{itemize}
- \item
- Für die Simulation zerlegen wir den Entladevorgang in kurze Zeitintervalle $dt$.
- Innerhalb jedes Zeitintervalls betrachten wir den Strom $I$ als konstant
- und berechnen, wieviel Ladung $Q$ innerhalb des Zeitintervalls
- aus dem Kondensator herausfließt.
- Aus der neuen Ladung berechnen wir die Spannung am Ende des Zeitintervalls.
- \item
- Für den Vergleich mit der exakten theoretischen Entladekurve
- benötigen Sie die Exponentialfunktion \lstinline{exp()}.
- Diese finden Sie in der Mathematik-Bibliothek:
- \lstinline{#include <math.h>} im Quelltext,
- beim \lstinline[style=cmd]{gcc}-Aufruf \lstinline[style=cmd]{-lm} mit angeben.
- \item
- $Q = C \cdot U$,\quad $U = R \cdot I$,\quad $I = \frac{dQ}{dt}$
- \end{itemize}
-
- \exercise{Personen-Datenbank}
-
- Wir betrachten das folgende Programm (\gitfile{hp}{2022ws/20221121}{aufgabe-2.c}):
- \begin{lstlisting}
- #include <stdio.h>
- #include <string.h>
-
- typedef struct
- {
- char first_name[10];
- char family_name[20];
- char day, month;
- int year;
- } person;
-
- int main (void)
- {
- person sls;
- sls.day = 26;
- sls.month = 7;
- sls.year = 1951;
- strcpy (sls.first_name, "Sabine");
- strcpy (sls.family_name, "Leutheusser-Schnarrenberger");
- printf ("%s %s wurde am %d.%d.%d geboren.\n",
- sls.first_name, sls.family_name, sls.day, sls.month, sls.year);
- return 0;
- }
- \end{lstlisting}
-
- Die Standard-Funktion \lstinline{strcpy()} bewirkt ein Kopieren eines Strings
- von rechts nach links, hier also z.\,B.\ die Zuweisung der String-Konstanten
- \lstinline{"Sabine"} an die String-Variable \lstinline{sls.first_name[]}.
-
- Das Programm wird für einen 32-Bit-Rechner compiliert und ausgeführt.\\
- (Die \lstinline[style=cmd]{gcc}-Option \lstinline[style=cmd]{-m32} sorgt dafür,
- daß \lstinline[style=cmd]{gcc} Code für einen 32-Bit-Prozessor erzeugt.)
-
- \begin{lstlisting}[style=terminal]
- $ ¡gcc -Wall -O -m32 aufgabe-2.c -o aufgabe-2¿
- $ ¡./aufgabe-2¿
- Sabine Leutheusser-Schnarrenberger wurde am 110.98.1701278309 geboren.
- Speicherzugriffsfehler
- \end{lstlisting}
-
- \begin{enumerate}[\quad(a)]
- \item
- Erklären Sie die Ausgabe des Programms einschließlich der Zahlenwerte.
- \points{4}
- \item
- Welche Endianness hat der verwendete Rechner?
- Begründen Sie Ihre Antwort.
- \points{1}
- \item
- Wie sähe die Ausgabe auf einem Rechner mit entgegengesetzter Endianness aus?
- \points{2}
- \item
- Erklären Sie den Speicherzugriffsfehler.
- (Es kann sein, daß sich der Fehler auf Ihrem Rechner nicht bemerkbar macht.
- Er ist aber trotzdem vorhanden.)
- \points{2}
- \end{enumerate}
-
- \exercise{Fakultät}
-
- Die Fakultät $n!$ einer ganzen Zahl $n \ge 0$ ist definiert als:
- \begin{eqnarray*}
- 1 & \mbox{für} & n = 0, \\
- n \cdot (n-1)! & \mbox{für} & n > 0.
- \end{eqnarray*}
-
- Mit anderen Worten: $n! = 1\cdot2\cdot3\cdot\dots\cdot n$.
-
- Die folgende Funktion \lstinline{fak()} berechnet die Fakultät \emph{rekursiv}
- (Datei: \gitfile{hp}{2022ws/20221121}{aufgabe-3.c}):
-
- \begin{lstlisting}
- int fak (int n)
- {
- if (n <= 0)
- return 1;
- else
- return n * fak (n - 1);
- }
- \end{lstlisting}
-
- \begin{enumerate}[\quad(a)]
- \item
- Schreiben Sie eine Funktion, die die Fakultät \emph{iterativ} berechnet,\\
- d.\,h.\ mit Hilfe einer Schleife anstelle von Rekursion.
- \points{3}
- \item
- Wie viele Multiplikationen (Landau-Symbol)
- erfordern beide Versionen der Fakultätsfunktion\\
- in Abhängigkeit von \lstinline$n$?
- Begründen Sie Ihre Antwort.
- \points{2}
- \item
- Wieviel Speicherplatz (Landau-Symbol)
- erfordern beide Versionen der Fakultätsfunktion\\
- in Abhängigkeit von \lstinline$n$?
- Begründen Sie Ihre Antwort.
- \points{3}
- \end{enumerate}
-
- \begin{flushright}
- \textit{Viel Erfolg!}
- \end{flushright}
-
- \makeatletter
- \immediate\write\@mainaux{\string\gdef\string\totalpoints{\arabic{points}}}
- \makeatother
-
-\end{document}
diff --git a/20221121/landau-symbols-2.pdf b/20221121/landau-symbols-2.pdf
deleted file mode 120000
index 6b458b6efd8e274824a6dfcaabc4b9c27d196dc4..0000000000000000000000000000000000000000
--- a/20221121/landau-symbols-2.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/landau-symbols-2.pdf
\ No newline at end of file
diff --git a/20221121/landau-symbols-3.pdf b/20221121/landau-symbols-3.pdf
deleted file mode 120000
index 46efa409b35ff5df763c744a423599cba515d886..0000000000000000000000000000000000000000
--- a/20221121/landau-symbols-3.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/landau-symbols-3.pdf
\ No newline at end of file
diff --git a/20221121/landau-symbols.pdf b/20221121/landau-symbols.pdf
deleted file mode 120000
index ca145425bf07439c680632aa0663f84be601a565..0000000000000000000000000000000000000000
--- a/20221121/landau-symbols.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/landau-symbols.pdf
\ No newline at end of file
diff --git a/20221121/loesung-1a.c b/20221121/loesung-1a.c
deleted file mode 100644
index f355706a6ff6f95bd72897123a985fb2b7ead7c3..0000000000000000000000000000000000000000
--- a/20221121/loesung-1a.c
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <stdio.h>
-#include <math.h>
-
-int main (void)
-{
- double C = 0.0001;
- double U0 = 5.0;
- double U = U0;
- double R = 33000.0;
- double t = 0.0;
- double dt = 0.01;
- double Q = C * U;
- while (U > 0.09)
- {
- printf ("%10.3lf%15.8lf\n", t, U);
- double I = U / R;
- Q -= I * dt;
- U = Q / C;
- t += dt;
- }
- return 0;
-}
diff --git a/20221121/loesung-1b.c b/20221121/loesung-1b.c
deleted file mode 100644
index f5fc22022ef10a1b986bbd11fba8298a7547792d..0000000000000000000000000000000000000000
--- a/20221121/loesung-1b.c
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <stdio.h>
-#include <math.h>
-
-int main (void)
-{
- double C = 0.0001;
- double U0 = 5.0;
- double U = U0;
- double R = 33000.0;
- double t = 0.0;
- double dt = 0.01;
- double Q = C * U;
- while (U >= 0.1)
- {
- double I = U / R;
- Q -= I * dt;
- U = Q / C;
- t += dt;
- }
- printf ("%10.3lf%15.8lf\n", t, U);
- return 0;
-}
diff --git a/20221121/loesung-1c.c b/20221121/loesung-1c.c
deleted file mode 100644
index 71802e036dd56534470028b61f646d297d1d8840..0000000000000000000000000000000000000000
--- a/20221121/loesung-1c.c
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <stdio.h>
-#include <math.h>
-
-int main (void)
-{
- double C = 0.0001;
- double U0 = 5.0;
- double U = U0;
- double R = 33000.0;
- double t = 0.0;
- double dt = 0.01;
- double Q = C * U;
- while (U > 0.09)
- {
- printf ("%10.3lf%15.8lf%15.8lf\n", t, U, U0 * exp (-t / (R * C)));
- double I = U / R;
- Q -= I * dt;
- U = Q / C;
- t += dt;
- }
- return 0;
-}
diff --git a/20221121/loesung-1c.dat b/20221121/loesung-1c.dat
deleted file mode 100644
index 4df706295bde25a74e025c5335f43617d93129a8..0000000000000000000000000000000000000000
--- a/20221121/loesung-1c.dat
+++ /dev/null
@@ -1,1324 +0,0 @@
- 0.000 5.00000000 5.00000000
- 0.010 4.98484848 4.98487142
- 0.020 4.96974288 4.96978861
- 0.030 4.95468306 4.95475144
- 0.040 4.93966887 4.93975977
- 0.050 4.92470017 4.92481346
- 0.060 4.90977684 4.90991237
- 0.070 4.89489873 4.89505637
- 0.080 4.88006570 4.88024532
- 0.090 4.86527762 4.86547908
- 0.100 4.85053436 4.85075752
- 0.110 4.83583577 4.83608050
- 0.120 4.82118172 4.82144789
- 0.130 4.80657208 4.80685956
- 0.140 4.79200671 4.79231537
- 0.150 4.77748548 4.77781518
- 0.160 4.76300825 4.76335887
- 0.170 4.74857489 4.74894630
- 0.180 4.73418527 4.73457733
- 0.190 4.71983925 4.72025184
- 0.200 4.70553671 4.70596970
- 0.210 4.69127751 4.69173077
- 0.220 4.67706151 4.67753493
- 0.230 4.66288860 4.66338203
- 0.240 4.64875864 4.64927196
- 0.250 4.63467149 4.63520458
- 0.260 4.62062703 4.62117977
- 0.270 4.60662513 4.60719739
- 0.280 4.59266566 4.59325732
- 0.290 4.57874849 4.57935942
- 0.300 4.56487349 4.56550358
- 0.310 4.55104054 4.55168966
- 0.320 4.53724951 4.53791754
- 0.330 4.52350027 4.52418709
- 0.340 4.50979269 4.51049818
- 0.350 4.49612666 4.49685070
- 0.360 4.48250203 4.48324450
- 0.370 4.46891869 4.46967948
- 0.380 4.45537651 4.45615549
- 0.390 4.44187537 4.44267243
- 0.400 4.42841514 4.42923016
- 0.410 4.41499570 4.41582857
- 0.420 4.40161693 4.40246753
- 0.430 4.38827870 4.38914691
- 0.440 4.37498088 4.37586660
- 0.450 4.36172336 4.36262646
- 0.460 4.34850602 4.34942639
- 0.470 4.33532873 4.33626626
- 0.480 4.32219137 4.32314595
- 0.490 4.30909382 4.31006534
- 0.500 4.29603596 4.29702430
- 0.510 4.28301767 4.28402273
- 0.520 4.27003883 4.27106049
- 0.530 4.25709932 4.25813747
- 0.540 4.24419901 4.24525356
- 0.550 4.23133781 4.23240862
- 0.560 4.21851557 4.21960256
- 0.570 4.20573219 4.20683524
- 0.580 4.19298755 4.19410655
- 0.590 4.18028152 4.18141637
- 0.600 4.16761400 4.16876459
- 0.610 4.15498487 4.15615109
- 0.620 4.14239401 4.14357576
- 0.630 4.12984130 4.13103847
- 0.640 4.11732663 4.11853912
- 0.650 4.10484988 4.10607759
- 0.660 4.09241094 4.09365377
- 0.670 4.08000970 4.08126753
- 0.680 4.06764603 4.06891877
- 0.690 4.05531983 4.05660738
- 0.700 4.04303098 4.04433324
- 0.710 4.03077937 4.03209623
- 0.720 4.01856489 4.01989625
- 0.730 4.00638742 4.00773319
- 0.740 3.99424685 3.99560692
- 0.750 3.98214307 3.98351735
- 0.760 3.97007597 3.97146436
- 0.770 3.95804544 3.95944783
- 0.780 3.94605136 3.94746767
- 0.790 3.93409363 3.93552375
- 0.800 3.92217214 3.92361597
- 0.810 3.91028677 3.91174422
- 0.820 3.89843741 3.89990839
- 0.830 3.88662397 3.88810838
- 0.840 3.87484632 3.87634406
- 0.850 3.86310436 3.86461535
- 0.860 3.85139798 3.85292212
- 0.870 3.83972708 3.84126427
- 0.880 3.82809154 3.82964169
- 0.890 3.81649127 3.81805428
- 0.900 3.80492614 3.80650193
- 0.910 3.79339606 3.79498454
- 0.920 3.78190092 3.78350199
- 0.930 3.77044062 3.77205419
- 0.940 3.75901504 3.76064102
- 0.950 3.74762408 3.74926239
- 0.960 3.73626765 3.73791819
- 0.970 3.72494562 3.72660831
- 0.980 3.71365791 3.71533265
- 0.990 3.70240440 3.70409110
- 1.000 3.69118499 3.69288357
- 1.010 3.67999958 3.68170996
- 1.020 3.66884807 3.67057015
- 1.030 3.65773035 3.65946404
- 1.040 3.64664632 3.64839154
- 1.050 3.63559587 3.63735255
- 1.060 3.62457892 3.62634695
- 1.070 3.61359534 3.61537465
- 1.080 3.60264506 3.60443555
- 1.090 3.59172795 3.59352955
- 1.100 3.58084393 3.58265655
- 1.110 3.56999288 3.57181645
- 1.120 3.55917472 3.56100915
- 1.130 3.54838934 3.55023454
- 1.140 3.53763665 3.53949254
- 1.150 3.52691654 3.52878304
- 1.160 3.51622891 3.51810594
- 1.170 3.50557367 3.50746115
- 1.180 3.49495072 3.49684857
- 1.190 3.48435996 3.48626810
- 1.200 3.47380130 3.47571964
- 1.210 3.46327463 3.46520310
- 1.220 3.45277985 3.45471838
- 1.230 3.44231689 3.44426538
- 1.240 3.43188562 3.43384401
- 1.250 3.42148597 3.42345417
- 1.260 3.41111783 3.41309577
- 1.270 3.40078111 3.40276871
- 1.280 3.39047571 3.39247290
- 1.290 3.38020154 3.38220824
- 1.300 3.36995851 3.37197464
- 1.310 3.35974651 3.36177200
- 1.320 3.34956546 3.35160023
- 1.330 3.33941526 3.34145924
- 1.340 3.32929582 3.33134893
- 1.350 3.31920705 3.32126921
- 1.360 3.30914885 3.31122000
- 1.370 3.29912112 3.30120118
- 1.380 3.28912378 3.29121269
- 1.390 3.27915674 3.28125441
- 1.400 3.26921990 3.27132626
- 1.410 3.25931318 3.26142816
- 1.420 3.24943647 3.25156000
- 1.430 3.23958969 3.24172171
- 1.440 3.22977276 3.23191317
- 1.450 3.21998557 3.22213432
- 1.460 3.21022803 3.21238506
- 1.470 3.20050007 3.20266529
- 1.480 3.19080158 3.19297494
- 1.490 3.18113249 3.18331390
- 1.500 3.17149269 3.17368209
- 1.510 3.16188211 3.16407943
- 1.520 3.15230065 3.15450583
- 1.530 3.14274822 3.14496119
- 1.540 3.13322474 3.13544543
- 1.550 3.12373012 3.12595846
- 1.560 3.11426427 3.11650019
- 1.570 3.10482711 3.10707055
- 1.580 3.09541854 3.09766944
- 1.590 3.08603849 3.08829677
- 1.600 3.07668685 3.07895246
- 1.610 3.06736356 3.06963642
- 1.620 3.05806852 3.06034857
- 1.630 3.04880164 3.05108882
- 1.640 3.03956285 3.04185710
- 1.650 3.03035206 3.03265330
- 1.660 3.02116917 3.02347735
- 1.670 3.01201411 3.01432917
- 1.680 3.00288680 3.00520866
- 1.690 2.99378714 2.99611575
- 1.700 2.98471506 2.98705036
- 1.710 2.97567047 2.97801239
- 1.720 2.96665328 2.96900177
- 1.730 2.95766343 2.96001841
- 1.740 2.94870081 2.95106223
- 1.750 2.93976535 2.94213316
- 1.760 2.93085697 2.93323110
- 1.770 2.92197559 2.92435597
- 1.780 2.91312112 2.91550770
- 1.790 2.90429348 2.90668620
- 1.800 2.89549259 2.89789139
- 1.810 2.88671837 2.88912320
- 1.820 2.87797074 2.88038153
- 1.830 2.86924961 2.87166631
- 1.840 2.86055492 2.86297746
- 1.850 2.85188657 2.85431491
- 1.860 2.84324449 2.84567856
- 1.870 2.83462859 2.83706834
- 1.880 2.82603881 2.82848418
- 1.890 2.81747506 2.81992599
- 1.900 2.80893725 2.81139369
- 1.910 2.80042532 2.80288721
- 1.920 2.79193919 2.79440647
- 1.930 2.78347876 2.78595139
- 1.940 2.77504398 2.77752189
- 1.950 2.76663476 2.76911790
- 1.960 2.75825101 2.76073933
- 1.970 2.74989268 2.75238612
- 1.980 2.74155967 2.74405818
- 1.990 2.73325191 2.73575544
- 2.000 2.72496933 2.72747782
- 2.010 2.71671185 2.71922525
- 2.020 2.70847939 2.71099764
- 2.030 2.70027187 2.70279493
- 2.040 2.69208923 2.69461704
- 2.050 2.68393139 2.68646389
- 2.060 2.67579826 2.67833542
- 2.070 2.66768978 2.67023153
- 2.080 2.65960587 2.66215217
- 2.090 2.65154646 2.65409725
- 2.100 2.64351147 2.64606671
- 2.110 2.63550083 2.63806046
- 2.120 2.62751447 2.63007844
- 2.130 2.61955230 2.62212057
- 2.140 2.61161426 2.61418677
- 2.150 2.60370028 2.60627699
- 2.160 2.59581028 2.59839113
- 2.170 2.58794419 2.59052914
- 2.180 2.58010193 2.58269093
- 2.190 2.57228344 2.57487644
- 2.200 2.56448864 2.56708560
- 2.210 2.55671747 2.55931832
- 2.220 2.54896984 2.55157455
- 2.230 2.54124569 2.54385421
- 2.240 2.53354494 2.53615723
- 2.250 2.52586753 2.52848354
- 2.260 2.51821339 2.52083306
- 2.270 2.51058244 2.51320574
- 2.280 2.50297461 2.50560149
- 2.290 2.49538984 2.49802025
- 2.300 2.48782805 2.49046195
- 2.310 2.48028918 2.48292652
- 2.320 2.47277315 2.47541389
- 2.330 2.46527990 2.46792399
- 2.340 2.45780936 2.46045675
- 2.350 2.45036145 2.45301211
- 2.360 2.44293611 2.44558999
- 2.370 2.43553328 2.43819033
- 2.380 2.42815287 2.43081305
- 2.390 2.42079483 2.42345810
- 2.400 2.41345909 2.41612541
- 2.410 2.40614558 2.40881490
- 2.420 2.39885423 2.40152651
- 2.430 2.39158497 2.39426017
- 2.440 2.38433775 2.38701582
- 2.450 2.37711248 2.37979338
- 2.460 2.36990911 2.37259280
- 2.470 2.36272757 2.36541401
- 2.480 2.35556778 2.35825694
- 2.490 2.34842970 2.35112152
- 2.500 2.34131325 2.34400770
- 2.510 2.33421836 2.33691539
- 2.520 2.32714497 2.32984455
- 2.530 2.32009302 2.32279510
- 2.540 2.31306243 2.31576698
- 2.550 2.30605315 2.30876013
- 2.560 2.29906511 2.30177448
- 2.570 2.29209825 2.29480996
- 2.580 2.28515249 2.28786652
- 2.590 2.27822779 2.28094408
- 2.600 2.27132407 2.27404259
- 2.610 2.26444127 2.26716198
- 2.620 2.25757933 2.26030219
- 2.630 2.25073818 2.25346316
- 2.640 2.24391776 2.24664482
- 2.650 2.23711801 2.23984711
- 2.660 2.23033886 2.23306997
- 2.670 2.22358026 2.22631333
- 2.680 2.21684214 2.21957714
- 2.690 2.21012443 2.21286133
- 2.700 2.20342709 2.20616584
- 2.710 2.19675003 2.19949061
- 2.720 2.19009322 2.19283557
- 2.730 2.18345657 2.18620067
- 2.740 2.17684003 2.17958585
- 2.750 2.17024355 2.17299104
- 2.760 2.16366705 2.16641619
- 2.770 2.15711049 2.15986123
- 2.780 2.15057379 2.15332610
- 2.790 2.14405690 2.14681075
- 2.800 2.13755976 2.14031511
- 2.810 2.13108230 2.13383912
- 2.820 2.12462448 2.12738273
- 2.830 2.11818622 2.12094587
- 2.840 2.11176748 2.11452849
- 2.850 2.10536818 2.10813053
- 2.860 2.09898828 2.10175192
- 2.870 2.09262771 2.09539262
- 2.880 2.08628641 2.08905255
- 2.890 2.07996433 2.08273167
- 2.900 2.07366141 2.07642992
- 2.910 2.06737759 2.07014723
- 2.920 2.06111280 2.06388355
- 2.930 2.05486701 2.05763883
- 2.940 2.04864014 2.05141299
- 2.950 2.04243214 2.04520600
- 2.960 2.03624295 2.03901779
- 2.970 2.03007252 2.03284830
- 2.980 2.02392078 2.02669748
- 2.990 2.01778769 2.02056526
- 3.000 2.01167318 2.01445161
- 3.010 2.00557720 2.00835645
- 3.020 1.99949969 2.00227973
- 3.030 1.99344060 1.99622140
- 3.040 1.98739988 1.99018140
- 3.050 1.98137745 1.98415968
- 3.060 1.97537328 1.97815617
- 3.070 1.96938730 1.97217083
- 3.080 1.96341946 1.96620360
- 3.090 1.95746970 1.96025443
- 3.100 1.95153798 1.95432326
- 3.110 1.94562422 1.94841003
- 3.120 1.93972839 1.94251469
- 3.130 1.93385043 1.93663719
- 3.140 1.92799028 1.93077748
- 3.150 1.92214788 1.92493549
- 3.160 1.91632319 1.91911119
- 3.170 1.91051615 1.91330450
- 3.180 1.90472671 1.90751538
- 3.190 1.89895481 1.90174378
- 3.200 1.89320040 1.89598965
- 3.210 1.88746343 1.89025292
- 3.220 1.88174384 1.88453355
- 3.230 1.87604159 1.87883149
- 3.240 1.87035661 1.87314668
- 3.250 1.86468887 1.86747906
- 3.260 1.85903829 1.86182860
- 3.270 1.85340484 1.85619524
- 3.280 1.84778847 1.85057892
- 3.290 1.84218911 1.84497959
- 3.300 1.83660672 1.83939721
- 3.310 1.83104124 1.83383171
- 3.320 1.82549263 1.82828306
- 3.330 1.81996084 1.82275119
- 3.340 1.81444580 1.81723606
- 3.350 1.80894748 1.81173762
- 3.360 1.80346582 1.80625582
- 3.370 1.79800078 1.80079060
- 3.380 1.79255229 1.79534192
- 3.390 1.78712031 1.78990972
- 3.400 1.78170480 1.78449397
- 3.410 1.77630569 1.77909459
- 3.420 1.77092295 1.77371156
- 3.430 1.76555651 1.76834481
- 3.440 1.76020634 1.76299430
- 3.450 1.75487238 1.75765998
- 3.460 1.74955459 1.75234180
- 3.470 1.74425291 1.74703971
- 3.480 1.73896729 1.74175366
- 3.490 1.73369769 1.73648361
- 3.500 1.72844406 1.73122950
- 3.510 1.72320636 1.72599129
- 3.520 1.71798452 1.72076893
- 3.530 1.71277850 1.71556238
- 3.540 1.70758827 1.71037157
- 3.550 1.70241376 1.70519647
- 3.560 1.69725493 1.70003703
- 3.570 1.69211173 1.69489320
- 3.580 1.68698412 1.68976494
- 3.590 1.68187205 1.68465219
- 3.600 1.67677546 1.67955491
- 3.610 1.67169433 1.67447305
- 3.620 1.66662859 1.66940657
- 3.630 1.66157820 1.66435542
- 3.640 1.65654311 1.65931955
- 3.650 1.65152328 1.65429892
- 3.660 1.64651867 1.64929348
- 3.670 1.64152922 1.64430319
- 3.680 1.63655489 1.63932799
- 3.690 1.63159563 1.63436785
- 3.700 1.62665140 1.62942272
- 3.710 1.62172215 1.62449255
- 3.720 1.61680784 1.61957729
- 3.730 1.61190842 1.61467691
- 3.740 1.60702385 1.60979136
- 3.750 1.60215408 1.60492059
- 3.760 1.59729907 1.60006455
- 3.770 1.59245877 1.59522321
- 3.780 1.58763314 1.59039652
- 3.790 1.58282213 1.58558443
- 3.800 1.57802570 1.58078690
- 3.810 1.57324380 1.57600389
- 3.820 1.56847640 1.57123535
- 3.830 1.56372344 1.56648123
- 3.840 1.55898488 1.56174151
- 3.850 1.55426069 1.55701612
- 3.860 1.54955081 1.55230503
- 3.870 1.54485520 1.54760820
- 3.880 1.54017382 1.54292557
- 3.890 1.53550662 1.53825712
- 3.900 1.53085357 1.53360279
- 3.910 1.52621462 1.52896254
- 3.920 1.52158973 1.52433633
- 3.930 1.51697885 1.51972412
- 3.940 1.51238195 1.51512587
- 3.950 1.50779897 1.51054153
- 3.960 1.50322988 1.50597106
- 3.970 1.49867464 1.50141442
- 3.980 1.49413320 1.49687156
- 3.990 1.48960553 1.49234246
- 4.000 1.48509157 1.48782705
- 4.010 1.48059129 1.48332531
- 4.020 1.47610465 1.47883719
- 4.030 1.47163161 1.47436264
- 4.040 1.46717212 1.46990164
- 4.050 1.46272614 1.46545414
- 4.060 1.45829364 1.46102009
- 4.070 1.45387457 1.45659946
- 4.080 1.44946889 1.45219220
- 4.090 1.44507656 1.44779828
- 4.100 1.44069754 1.44341765
- 4.110 1.43633179 1.43905028
- 4.120 1.43197927 1.43469612
- 4.130 1.42763994 1.43035514
- 4.140 1.42331375 1.42602729
- 4.150 1.41900068 1.42171253
- 4.160 1.41470068 1.41741084
- 4.170 1.41041371 1.41312215
- 4.180 1.40613973 1.40884645
- 4.190 1.40187870 1.40458368
- 4.200 1.39763058 1.40033380
- 4.210 1.39339534 1.39609679
- 4.220 1.38917293 1.39187260
- 4.230 1.38496331 1.38766119
- 4.240 1.38076645 1.38346252
- 4.250 1.37658231 1.37927655
- 4.260 1.37241085 1.37510325
- 4.270 1.36825203 1.37094258
- 4.280 1.36410581 1.36679450
- 4.290 1.35997216 1.36265897
- 4.300 1.35585103 1.35853595
- 4.310 1.35174239 1.35442540
- 4.320 1.34764620 1.35032729
- 4.330 1.34356242 1.34624159
- 4.340 1.33949102 1.34216824
- 4.350 1.33543196 1.33810722
- 4.360 1.33138520 1.33405849
- 4.370 1.32735070 1.33002201
- 4.380 1.32332842 1.32599774
- 4.390 1.31931833 1.32198564
- 4.400 1.31532040 1.31798569
- 4.410 1.31133458 1.31399784
- 4.420 1.30736084 1.31002206
- 4.430 1.30339914 1.30605830
- 4.440 1.29944945 1.30210654
- 4.450 1.29551172 1.29816673
- 4.460 1.29158593 1.29423885
- 4.470 1.28767203 1.29032285
- 4.480 1.28376999 1.28641870
- 4.490 1.27987978 1.28252636
- 4.500 1.27600136 1.27864580
- 4.510 1.27213469 1.27477698
- 4.520 1.26827973 1.27091987
- 4.530 1.26443646 1.26707442
- 4.540 1.26060484 1.26324062
- 4.550 1.25678482 1.25941841
- 4.560 1.25297638 1.25560777
- 4.570 1.24917948 1.25180865
- 4.580 1.24539409 1.24802103
- 4.590 1.24162017 1.24424488
- 4.600 1.23785769 1.24048015
- 4.610 1.23410660 1.23672680
- 4.620 1.23036688 1.23298482
- 4.630 1.22663850 1.22925416
- 4.640 1.22292141 1.22553478
- 4.650 1.21921559 1.22182666
- 4.660 1.21552100 1.21812976
- 4.670 1.21183760 1.21444405
- 4.680 1.20816537 1.21076948
- 4.690 1.20450426 1.20710604
- 4.700 1.20085425 1.20345368
- 4.710 1.19721529 1.19981237
- 4.720 1.19358737 1.19618208
- 4.730 1.18997044 1.19256277
- 4.740 1.18636447 1.18895441
- 4.750 1.18276942 1.18535697
- 4.760 1.17918527 1.18177042
- 4.770 1.17561198 1.17819472
- 4.780 1.17204952 1.17462984
- 4.790 1.16849786 1.17107574
- 4.800 1.16495696 1.16753240
- 4.810 1.16142678 1.16399977
- 4.820 1.15790731 1.16047784
- 4.830 1.15439850 1.15696656
- 4.840 1.15090032 1.15346591
- 4.850 1.14741274 1.14997585
- 4.860 1.14393574 1.14649635
- 4.870 1.14046926 1.14302738
- 4.880 1.13701330 1.13956890
- 4.890 1.13356780 1.13612089
- 4.900 1.13013275 1.13268331
- 4.910 1.12670810 1.12925613
- 4.920 1.12329384 1.12583932
- 4.930 1.11988992 1.12243285
- 4.940 1.11649631 1.11903669
- 4.950 1.11311299 1.11565080
- 4.960 1.10973992 1.11227516
- 4.970 1.10637707 1.10890973
- 4.980 1.10302441 1.10555448
- 4.990 1.09968191 1.10220939
- 5.000 1.09634954 1.09887442
- 5.010 1.09302727 1.09554953
- 5.020 1.08971507 1.09223471
- 5.030 1.08641290 1.08892992
- 5.040 1.08312074 1.08563513
- 5.050 1.07983856 1.08235030
- 5.060 1.07656632 1.07907542
- 5.070 1.07330400 1.07581044
- 5.080 1.07005156 1.07255534
- 5.090 1.06680898 1.06931010
- 5.100 1.06357623 1.06607467
- 5.110 1.06035327 1.06284903
- 5.120 1.05714008 1.05963315
- 5.130 1.05393662 1.05642700
- 5.140 1.05074287 1.05323055
- 5.150 1.04755880 1.05004377
- 5.160 1.04438438 1.04686664
- 5.170 1.04121958 1.04369912
- 5.180 1.03806437 1.04054118
- 5.190 1.03491872 1.03739280
- 5.200 1.03178261 1.03425394
- 5.210 1.02865599 1.03112458
- 5.220 1.02553885 1.02800469
- 5.230 1.02243116 1.02489424
- 5.240 1.01933288 1.02179320
- 5.250 1.01624399 1.01870155
- 5.260 1.01316447 1.01561924
- 5.270 1.01009427 1.01254627
- 5.280 1.00703338 1.00948259
- 5.290 1.00398176 1.00642818
- 5.300 1.00093939 1.00338302
- 5.310 0.99790625 1.00034706
- 5.320 0.99488229 0.99732030
- 5.330 0.99186749 0.99430269
- 5.340 0.98886183 0.99129421
- 5.350 0.98586528 0.98829484
- 5.360 0.98287781 0.98530454
- 5.370 0.97989939 0.98232328
- 5.380 0.97693000 0.97935105
- 5.390 0.97396961 0.97638781
- 5.400 0.97101818 0.97343354
- 5.410 0.96807571 0.97048821
- 5.420 0.96514214 0.96755179
- 5.430 0.96221747 0.96462425
- 5.440 0.95930166 0.96170557
- 5.450 0.95639468 0.95879572
- 5.460 0.95349652 0.95589468
- 5.470 0.95060714 0.95300241
- 5.480 0.94772651 0.95011890
- 5.490 0.94485461 0.94724411
- 5.500 0.94199141 0.94437801
- 5.510 0.93913689 0.94152059
- 5.520 0.93629102 0.93867182
- 5.530 0.93345378 0.93583167
- 5.540 0.93062513 0.93300010
- 5.550 0.92780505 0.93017711
- 5.560 0.92499352 0.92736266
- 5.570 0.92219051 0.92455672
- 5.580 0.91939600 0.92175928
- 5.590 0.91660995 0.91897029
- 5.600 0.91383234 0.91618975
- 5.610 0.91106315 0.91341762
- 5.620 0.90830236 0.91065388
- 5.630 0.90554992 0.90789850
- 5.640 0.90280583 0.90515145
- 5.650 0.90007006 0.90241272
- 5.660 0.89734257 0.89968228
- 5.670 0.89462335 0.89696009
- 5.680 0.89191237 0.89424615
- 5.690 0.88920961 0.89154041
- 5.700 0.88651503 0.88884286
- 5.710 0.88382863 0.88615348
- 5.720 0.88115036 0.88347223
- 5.730 0.87848020 0.88079909
- 5.740 0.87581814 0.87813404
- 5.750 0.87316415 0.87547706
- 5.760 0.87051820 0.87282811
- 5.770 0.86788026 0.87018718
- 5.780 0.86525032 0.86755424
- 5.790 0.86262835 0.86492927
- 5.800 0.86001433 0.86231224
- 5.810 0.85740822 0.85970313
- 5.820 0.85481002 0.85710191
- 5.830 0.85221968 0.85450856
- 5.840 0.84963720 0.85192306
- 5.850 0.84706254 0.84934539
- 5.860 0.84449568 0.84677551
- 5.870 0.84193661 0.84421341
- 5.880 0.83938528 0.84165906
- 5.890 0.83684169 0.83911243
- 5.900 0.83430581 0.83657352
- 5.910 0.83177761 0.83404228
- 5.920 0.82925707 0.83151871
- 5.930 0.82674417 0.82900277
- 5.940 0.82423888 0.82649444
- 5.950 0.82174119 0.82399370
- 5.960 0.81925107 0.82150053
- 5.970 0.81676849 0.81901490
- 5.980 0.81429343 0.81653680
- 5.990 0.81182588 0.81406619
- 6.000 0.80936580 0.81160306
- 6.010 0.80691317 0.80914738
- 6.020 0.80446798 0.80669912
- 6.030 0.80203020 0.80425828
- 6.040 0.79959981 0.80182482
- 6.050 0.79717678 0.79939873
- 6.060 0.79476109 0.79697998
- 6.070 0.79235272 0.79456854
- 6.080 0.78995165 0.79216440
- 6.090 0.78755786 0.78976754
- 6.100 0.78517132 0.78737793
- 6.110 0.78279201 0.78499554
- 6.120 0.78041992 0.78262037
- 6.130 0.77805501 0.78025238
- 6.140 0.77569727 0.77789156
- 6.150 0.77334667 0.77553788
- 6.160 0.77100319 0.77319132
- 6.170 0.76866682 0.77085187
- 6.180 0.76633753 0.76851949
- 6.190 0.76401529 0.76619416
- 6.200 0.76170009 0.76387588
- 6.210 0.75939191 0.76156461
- 6.220 0.75709072 0.75926033
- 6.230 0.75479651 0.75696302
- 6.240 0.75250925 0.75467267
- 6.250 0.75022892 0.75238924
- 6.260 0.74795550 0.75011272
- 6.270 0.74568896 0.74784310
- 6.280 0.74342930 0.74558034
- 6.290 0.74117648 0.74332442
- 6.300 0.73893049 0.74107533
- 6.310 0.73669131 0.73883305
- 6.320 0.73445891 0.73659755
- 6.330 0.73223328 0.73436881
- 6.340 0.73001439 0.73214682
- 6.350 0.72780223 0.72993155
- 6.360 0.72559677 0.72772299
- 6.370 0.72339799 0.72552110
- 6.380 0.72120587 0.72332588
- 6.390 0.71902040 0.72113730
- 6.400 0.71684155 0.71895535
- 6.410 0.71466930 0.71677999
- 6.420 0.71250364 0.71461122
- 6.430 0.71034454 0.71244901
- 6.440 0.70819198 0.71029334
- 6.450 0.70604594 0.70814419
- 6.460 0.70390641 0.70600155
- 6.470 0.70177336 0.70386539
- 6.480 0.69964677 0.70173569
- 6.490 0.69752663 0.69961244
- 6.500 0.69541291 0.69749561
- 6.510 0.69330560 0.69538519
- 6.520 0.69120468 0.69328115
- 6.530 0.68911012 0.69118348
- 6.540 0.68702190 0.68909215
- 6.550 0.68494002 0.68700715
- 6.560 0.68286444 0.68492847
- 6.570 0.68079516 0.68285607
- 6.580 0.67873214 0.68078994
- 6.590 0.67667538 0.67873006
- 6.600 0.67462485 0.67667642
- 6.610 0.67258053 0.67462899
- 6.620 0.67054241 0.67258775
- 6.630 0.66851046 0.67055269
- 6.640 0.66648467 0.66852379
- 6.650 0.66446502 0.66650102
- 6.660 0.66245149 0.66448438
- 6.670 0.66044406 0.66247384
- 6.680 0.65844271 0.66046938
- 6.690 0.65644743 0.65847099
- 6.700 0.65445820 0.65647864
- 6.710 0.65247499 0.65449232
- 6.720 0.65049780 0.65251202
- 6.730 0.64852659 0.65053770
- 6.740 0.64656136 0.64856936
- 6.750 0.64460208 0.64660697
- 6.760 0.64264874 0.64465052
- 6.770 0.64070132 0.64269999
- 6.780 0.63875980 0.64075536
- 6.790 0.63682417 0.63881662
- 6.800 0.63489440 0.63688374
- 6.810 0.63297047 0.63495671
- 6.820 0.63105238 0.63303551
- 6.830 0.62914010 0.63112013
- 6.840 0.62723362 0.62921054
- 6.850 0.62533291 0.62730673
- 6.860 0.62343796 0.62540867
- 6.870 0.62154875 0.62351636
- 6.880 0.61966527 0.62162978
- 6.890 0.61778750 0.61974890
- 6.900 0.61591542 0.61787372
- 6.910 0.61404901 0.61600421
- 6.920 0.61218825 0.61414036
- 6.930 0.61033313 0.61228214
- 6.940 0.60848364 0.61042955
- 6.950 0.60663975 0.60858256
- 6.960 0.60480145 0.60674116
- 6.970 0.60296872 0.60490534
- 6.980 0.60114154 0.60307507
- 6.990 0.59931990 0.60125033
- 7.000 0.59750378 0.59943112
- 7.010 0.59569316 0.59761741
- 7.020 0.59388803 0.59580919
- 7.030 0.59208837 0.59400644
- 7.040 0.59029416 0.59220915
- 7.050 0.58850539 0.59041729
- 7.060 0.58672204 0.58863085
- 7.070 0.58494410 0.58684982
- 7.080 0.58317154 0.58507418
- 7.090 0.58140435 0.58330391
- 7.100 0.57964252 0.58153900
- 7.110 0.57788603 0.57977943
- 7.120 0.57613486 0.57802518
- 7.130 0.57438899 0.57627624
- 7.140 0.57264842 0.57453259
- 7.150 0.57091312 0.57279422
- 7.160 0.56918308 0.57106111
- 7.170 0.56745829 0.56933324
- 7.180 0.56573872 0.56761060
- 7.190 0.56402436 0.56589317
- 7.200 0.56231519 0.56418094
- 7.210 0.56061121 0.56247389
- 7.220 0.55891238 0.56077200
- 7.230 0.55721871 0.55907526
- 7.240 0.55553017 0.55738366
- 7.250 0.55384674 0.55569717
- 7.260 0.55216842 0.55401579
- 7.270 0.55049518 0.55233950
- 7.280 0.54882702 0.55066827
- 7.290 0.54716390 0.54900211
- 7.300 0.54550583 0.54734098
- 7.310 0.54385278 0.54568489
- 7.320 0.54220474 0.54403380
- 7.330 0.54056170 0.54238771
- 7.340 0.53892363 0.54074659
- 7.350 0.53729053 0.53911045
- 7.360 0.53566238 0.53747925
- 7.370 0.53403916 0.53585299
- 7.380 0.53242086 0.53423165
- 7.390 0.53080746 0.53261522
- 7.400 0.52919895 0.53100368
- 7.410 0.52759532 0.52939701
- 7.420 0.52599655 0.52779521
- 7.430 0.52440262 0.52619825
- 7.440 0.52281352 0.52460612
- 7.450 0.52122924 0.52301881
- 7.460 0.51964975 0.52143631
- 7.470 0.51807506 0.51985859
- 7.480 0.51650513 0.51828564
- 7.490 0.51493997 0.51671746
- 7.500 0.51337954 0.51515402
- 7.510 0.51182385 0.51359531
- 7.520 0.51027287 0.51204131
- 7.530 0.50872658 0.51049202
- 7.540 0.50718499 0.50894742
- 7.550 0.50564806 0.50740749
- 7.560 0.50411580 0.50587222
- 7.570 0.50258817 0.50434159
- 7.580 0.50106518 0.50281560
- 7.590 0.49954680 0.50129422
- 7.600 0.49803302 0.49977744
- 7.610 0.49652383 0.49826526
- 7.620 0.49501921 0.49675765
- 7.630 0.49351915 0.49525460
- 7.640 0.49202364 0.49375610
- 7.650 0.49053266 0.49226214
- 7.660 0.48904620 0.49077269
- 7.670 0.48756424 0.48928775
- 7.680 0.48608677 0.48780731
- 7.690 0.48461378 0.48633134
- 7.700 0.48314526 0.48485984
- 7.710 0.48168118 0.48339279
- 7.720 0.48022154 0.48193018
- 7.730 0.47876632 0.48047200
- 7.740 0.47731552 0.47901823
- 7.750 0.47586911 0.47756885
- 7.760 0.47442708 0.47612386
- 7.770 0.47298942 0.47468325
- 7.780 0.47155612 0.47324699
- 7.790 0.47012716 0.47181508
- 7.800 0.46870253 0.47038750
- 7.810 0.46728222 0.46896424
- 7.820 0.46586622 0.46754529
- 7.830 0.46445450 0.46613063
- 7.840 0.46304706 0.46472025
- 7.850 0.46164389 0.46331414
- 7.860 0.46024497 0.46191228
- 7.870 0.45885029 0.46051467
- 7.880 0.45745983 0.45912128
- 7.890 0.45607359 0.45773211
- 7.900 0.45469155 0.45634714
- 7.910 0.45331369 0.45496637
- 7.920 0.45194002 0.45358977
- 7.930 0.45057050 0.45221733
- 7.940 0.44920514 0.45084905
- 7.950 0.44784391 0.44948491
- 7.960 0.44648681 0.44812490
- 7.970 0.44513382 0.44676900
- 7.980 0.44378493 0.44541720
- 7.990 0.44244012 0.44406949
- 8.000 0.44109939 0.44272587
- 8.010 0.43976273 0.44138630
- 8.020 0.43843012 0.44005079
- 8.030 0.43710154 0.43871933
- 8.040 0.43577699 0.43739188
- 8.050 0.43445645 0.43606846
- 8.060 0.43313992 0.43474904
- 8.070 0.43182737 0.43343361
- 8.080 0.43051881 0.43212217
- 8.090 0.42921420 0.43081469
- 8.100 0.42791355 0.42951117
- 8.110 0.42661685 0.42821159
- 8.120 0.42532407 0.42691594
- 8.130 0.42403521 0.42562421
- 8.140 0.42275025 0.42433639
- 8.150 0.42146919 0.42305247
- 8.160 0.42019201 0.42177244
- 8.170 0.41891870 0.42049627
- 8.180 0.41764925 0.41922397
- 8.190 0.41638365 0.41795552
- 8.200 0.41512188 0.41669090
- 8.210 0.41386393 0.41543011
- 8.220 0.41260980 0.41417314
- 8.230 0.41135947 0.41291997
- 8.240 0.41011292 0.41167059
- 8.250 0.40887016 0.41042499
- 8.260 0.40763116 0.40918316
- 8.270 0.40639591 0.40794509
- 8.280 0.40516441 0.40671077
- 8.290 0.40393664 0.40548017
- 8.300 0.40271259 0.40425331
- 8.310 0.40149225 0.40303015
- 8.320 0.40027560 0.40181070
- 8.330 0.39906265 0.40059493
- 8.340 0.39785337 0.39938284
- 8.350 0.39664775 0.39817442
- 8.360 0.39544579 0.39696966
- 8.370 0.39424747 0.39576854
- 8.380 0.39305278 0.39457106
- 8.390 0.39186171 0.39337720
- 8.400 0.39067425 0.39218695
- 8.410 0.38949039 0.39100031
- 8.420 0.38831011 0.38981725
- 8.430 0.38713342 0.38863777
- 8.440 0.38596028 0.38746187
- 8.450 0.38479071 0.38628952
- 8.460 0.38362467 0.38512071
- 8.470 0.38246218 0.38395545
- 8.480 0.38130320 0.38279371
- 8.490 0.38014774 0.38163548
- 8.500 0.37899577 0.38048076
- 8.510 0.37784730 0.37932953
- 8.520 0.37670231 0.37818179
- 8.530 0.37556079 0.37703752
- 8.540 0.37442272 0.37589671
- 8.550 0.37328811 0.37475936
- 8.560 0.37215693 0.37362544
- 8.570 0.37102918 0.37249496
- 8.580 0.36990485 0.37136789
- 8.590 0.36878393 0.37024424
- 8.600 0.36766640 0.36912398
- 8.610 0.36655226 0.36800712
- 8.620 0.36544150 0.36689363
- 8.630 0.36433410 0.36578352
- 8.640 0.36323006 0.36467676
- 8.650 0.36212936 0.36357335
- 8.660 0.36103200 0.36247328
- 8.670 0.35993796 0.36137654
- 8.680 0.35884724 0.36028312
- 8.690 0.35775982 0.35919300
- 8.700 0.35667570 0.35810619
- 8.710 0.35559487 0.35702266
- 8.720 0.35451731 0.35594241
- 8.730 0.35344301 0.35486543
- 8.740 0.35237197 0.35379171
- 8.750 0.35130418 0.35272123
- 8.760 0.35023962 0.35165400
- 8.770 0.34917829 0.35058999
- 8.780 0.34812017 0.34952921
- 8.790 0.34706526 0.34847163
- 8.800 0.34601355 0.34741726
- 8.810 0.34496503 0.34636607
- 8.820 0.34391968 0.34531806
- 8.830 0.34287750 0.34427323
- 8.840 0.34183847 0.34323156
- 8.850 0.34080260 0.34219304
- 8.860 0.33976986 0.34115766
- 8.870 0.33874026 0.34012541
- 8.880 0.33771377 0.33909629
- 8.890 0.33669040 0.33807028
- 8.900 0.33567012 0.33704737
- 8.910 0.33465294 0.33602756
- 8.920 0.33363884 0.33501084
- 8.930 0.33262781 0.33399719
- 8.940 0.33161985 0.33298661
- 8.950 0.33061494 0.33197909
- 8.960 0.32961308 0.33097461
- 8.970 0.32861425 0.32997318
- 8.980 0.32761845 0.32897477
- 8.990 0.32662567 0.32797939
- 9.000 0.32563589 0.32698702
- 9.010 0.32464912 0.32599765
- 9.020 0.32366533 0.32501127
- 9.030 0.32268453 0.32402788
- 9.040 0.32170670 0.32304746
- 9.050 0.32073183 0.32207001
- 9.060 0.31975991 0.32109552
- 9.070 0.31879094 0.32012398
- 9.080 0.31782491 0.31915537
- 9.090 0.31686181 0.31818970
- 9.100 0.31590162 0.31722695
- 9.110 0.31494434 0.31626711
- 9.120 0.31398996 0.31531017
- 9.130 0.31303848 0.31435613
- 9.140 0.31208988 0.31340498
- 9.150 0.31114415 0.31245671
- 9.160 0.31020129 0.31151130
- 9.170 0.30926129 0.31056876
- 9.180 0.30832413 0.30962906
- 9.190 0.30738981 0.30869221
- 9.200 0.30645833 0.30775820
- 9.210 0.30552967 0.30682701
- 9.220 0.30460382 0.30589864
- 9.230 0.30368078 0.30497308
- 9.240 0.30276053 0.30405031
- 9.250 0.30184308 0.30313034
- 9.260 0.30092840 0.30221316
- 9.270 0.30001650 0.30129875
- 9.280 0.29910736 0.30038710
- 9.290 0.29820097 0.29947821
- 9.300 0.29729733 0.29857208
- 9.310 0.29639643 0.29766868
- 9.320 0.29549826 0.29676802
- 9.330 0.29460281 0.29587009
- 9.340 0.29371007 0.29497487
- 9.350 0.29282004 0.29408236
- 9.360 0.29193271 0.29319255
- 9.370 0.29104807 0.29230543
- 9.380 0.29016610 0.29142100
- 9.390 0.28928681 0.29053924
- 9.400 0.28841018 0.28966015
- 9.410 0.28753621 0.28878372
- 9.420 0.28666489 0.28790994
- 9.430 0.28579621 0.28703881
- 9.440 0.28493016 0.28617031
- 9.450 0.28406674 0.28530444
- 9.460 0.28320593 0.28444119
- 9.470 0.28234773 0.28358055
- 9.480 0.28149213 0.28272252
- 9.490 0.28063912 0.28186708
- 9.500 0.27978870 0.28101423
- 9.510 0.27894086 0.28016396
- 9.520 0.27809558 0.27931627
- 9.530 0.27725287 0.27847113
- 9.540 0.27641271 0.27762856
- 9.550 0.27557509 0.27678853
- 9.560 0.27474002 0.27595105
- 9.570 0.27390747 0.27511610
- 9.580 0.27307745 0.27428368
- 9.590 0.27224994 0.27345377
- 9.600 0.27142494 0.27262638
- 9.610 0.27060244 0.27180149
- 9.620 0.26978243 0.27097909
- 9.630 0.26896491 0.27015919
- 9.640 0.26814987 0.26934176
- 9.650 0.26733729 0.26852681
- 9.660 0.26652718 0.26771433
- 9.670 0.26571952 0.26690430
- 9.680 0.26491431 0.26609672
- 9.690 0.26411154 0.26529159
- 9.700 0.26331120 0.26448889
- 9.710 0.26251329 0.26368862
- 9.720 0.26171779 0.26289078
- 9.730 0.26092471 0.26209534
- 9.740 0.26013403 0.26130232
- 9.750 0.25934574 0.26051169
- 9.760 0.25855985 0.25972346
- 9.770 0.25777633 0.25893761
- 9.780 0.25699519 0.25815413
- 9.790 0.25621642 0.25737303
- 9.800 0.25544001 0.25659430
- 9.810 0.25466594 0.25581791
- 9.820 0.25389423 0.25504388
- 9.830 0.25312485 0.25427219
- 9.840 0.25235781 0.25350284
- 9.850 0.25159309 0.25273581
- 9.860 0.25083068 0.25197110
- 9.870 0.25007059 0.25120871
- 9.880 0.24931280 0.25044862
- 9.890 0.24855731 0.24969084
- 9.900 0.24780410 0.24893534
- 9.910 0.24705318 0.24818213
- 9.920 0.24630454 0.24743121
- 9.930 0.24555816 0.24668255
- 9.940 0.24481404 0.24593616
- 9.950 0.24407218 0.24519202
- 9.960 0.24333257 0.24445014
- 9.970 0.24259520 0.24371051
- 9.980 0.24186006 0.24297311
- 9.990 0.24112715 0.24223794
- 10.000 0.24039646 0.24150500
- 10.010 0.23966799 0.24077427
- 10.020 0.23894172 0.24004576
- 10.030 0.23821766 0.23931945
- 10.040 0.23749579 0.23859533
- 10.050 0.23677610 0.23787341
- 10.060 0.23605860 0.23715367
- 10.070 0.23534327 0.23643611
- 10.080 0.23463011 0.23572073
- 10.090 0.23391911 0.23500750
- 10.100 0.23321026 0.23429644
- 10.110 0.23250356 0.23358752
- 10.120 0.23179901 0.23288075
- 10.130 0.23109659 0.23217612
- 10.140 0.23039629 0.23147362
- 10.150 0.22969812 0.23077325
- 10.160 0.22900207 0.23007499
- 10.170 0.22830812 0.22937885
- 10.180 0.22761628 0.22868482
- 10.190 0.22692653 0.22799288
- 10.200 0.22623888 0.22730304
- 10.210 0.22555331 0.22661528
- 10.220 0.22486981 0.22592961
- 10.230 0.22418839 0.22524601
- 10.240 0.22350903 0.22456448
- 10.250 0.22283173 0.22388501
- 10.260 0.22215648 0.22320760
- 10.270 0.22148328 0.22253224
- 10.280 0.22081212 0.22185892
- 10.290 0.22014299 0.22118764
- 10.300 0.21947589 0.22051839
- 10.310 0.21881081 0.21985116
- 10.320 0.21814775 0.21918595
- 10.330 0.21748669 0.21852276
- 10.340 0.21682764 0.21786157
- 10.350 0.21617059 0.21720238
- 10.360 0.21551553 0.21654519
- 10.370 0.21486245 0.21588998
- 10.380 0.21421135 0.21523676
- 10.390 0.21356223 0.21458552
- 10.400 0.21291507 0.21393624
- 10.410 0.21226987 0.21328893
- 10.420 0.21162663 0.21264358
- 10.430 0.21098534 0.21200018
- 10.440 0.21034599 0.21135873
- 10.450 0.20970858 0.21071922
- 10.460 0.20907309 0.21008164
- 10.470 0.20843954 0.20944599
- 10.480 0.20780790 0.20881227
- 10.490 0.20717818 0.20818046
- 10.500 0.20655037 0.20755057
- 10.510 0.20592446 0.20692258
- 10.520 0.20530045 0.20629649
- 10.530 0.20467833 0.20567229
- 10.540 0.20405809 0.20504999
- 10.550 0.20343973 0.20442957
- 10.560 0.20282325 0.20381102
- 10.570 0.20220863 0.20319435
- 10.580 0.20159588 0.20257954
- 10.590 0.20098498 0.20196659
- 10.600 0.20037593 0.20135550
- 10.610 0.19976873 0.20074625
- 10.620 0.19916337 0.20013885
- 10.630 0.19855985 0.19953329
- 10.640 0.19795815 0.19892956
- 10.650 0.19735828 0.19832765
- 10.660 0.19676022 0.19772757
- 10.670 0.19616398 0.19712930
- 10.680 0.19556954 0.19653284
- 10.690 0.19497691 0.19593819
- 10.700 0.19438607 0.19534534
- 10.710 0.19379702 0.19475428
- 10.720 0.19320976 0.19416501
- 10.730 0.19262427 0.19357752
- 10.740 0.19204056 0.19299181
- 10.750 0.19145862 0.19240787
- 10.760 0.19087845 0.19182570
- 10.770 0.19030003 0.19124529
- 10.780 0.18972336 0.19066663
- 10.790 0.18914844 0.19008973
- 10.800 0.18857526 0.18951457
- 10.810 0.18800382 0.18894115
- 10.820 0.18743411 0.18836947
- 10.830 0.18686613 0.18779952
- 10.840 0.18629987 0.18723129
- 10.850 0.18573533 0.18666478
- 10.860 0.18517249 0.18609999
- 10.870 0.18461136 0.18553690
- 10.880 0.18405193 0.18497552
- 10.890 0.18349420 0.18441584
- 10.900 0.18293816 0.18385785
- 10.910 0.18238380 0.18330155
- 10.920 0.18183112 0.18274693
- 10.930 0.18128012 0.18219399
- 10.940 0.18073079 0.18164272
- 10.950 0.18018312 0.18109312
- 10.960 0.17963711 0.18054518
- 10.970 0.17909275 0.17999890
- 10.980 0.17855005 0.17945428
- 10.990 0.17800899 0.17891130
- 11.000 0.17746956 0.17836997
- 11.010 0.17693178 0.17783027
- 11.020 0.17639562 0.17729221
- 11.030 0.17586109 0.17675577
- 11.040 0.17532818 0.17622096
- 11.050 0.17479688 0.17568776
- 11.060 0.17426719 0.17515618
- 11.070 0.17373911 0.17462621
- 11.080 0.17321263 0.17409784
- 11.090 0.17268774 0.17357107
- 11.100 0.17216444 0.17304589
- 11.110 0.17164273 0.17252230
- 11.120 0.17112260 0.17200030
- 11.130 0.17060405 0.17147988
- 11.140 0.17008707 0.17096103
- 11.150 0.16957165 0.17044375
- 11.160 0.16905780 0.16992803
- 11.170 0.16854550 0.16941388
- 11.180 0.16803476 0.16890128
- 11.190 0.16752556 0.16839023
- 11.200 0.16701791 0.16788073
- 11.210 0.16651180 0.16737277
- 11.220 0.16600721 0.16686635
- 11.230 0.16550416 0.16636146
- 11.240 0.16500263 0.16585810
- 11.250 0.16450263 0.16535626
- 11.260 0.16400413 0.16485594
- 11.270 0.16350715 0.16435713
- 11.280 0.16301167 0.16385983
- 11.290 0.16251770 0.16336404
- 11.300 0.16202522 0.16286974
- 11.310 0.16153424 0.16237695
- 11.320 0.16104474 0.16188564
- 11.330 0.16055672 0.16139582
- 11.340 0.16007019 0.16090748
- 11.350 0.15958513 0.16042062
- 11.360 0.15910154 0.15993523
- 11.370 0.15861941 0.15945132
- 11.380 0.15813875 0.15896886
- 11.390 0.15765954 0.15848787
- 11.400 0.15718178 0.15800833
- 11.410 0.15670547 0.15753024
- 11.420 0.15623061 0.15705360
- 11.430 0.15575718 0.15657840
- 11.440 0.15528519 0.15610464
- 11.450 0.15481463 0.15563231
- 11.460 0.15434549 0.15516141
- 11.470 0.15387778 0.15469193
- 11.480 0.15341148 0.15422388
- 11.490 0.15294660 0.15375724
- 11.500 0.15248313 0.15329202
- 11.510 0.15202106 0.15282820
- 11.520 0.15156039 0.15236578
- 11.530 0.15110111 0.15190477
- 11.540 0.15064323 0.15144515
- 11.550 0.15018674 0.15098692
- 11.560 0.14973162 0.15053007
- 11.570 0.14927789 0.15007461
- 11.580 0.14882553 0.14962053
- 11.590 0.14837455 0.14916782
- 11.600 0.14792493 0.14871648
- 11.610 0.14747667 0.14826651
- 11.620 0.14702977 0.14781789
- 11.630 0.14658423 0.14737064
- 11.640 0.14614003 0.14692474
- 11.650 0.14569718 0.14648018
- 11.660 0.14525568 0.14603698
- 11.670 0.14481551 0.14559511
- 11.680 0.14437667 0.14515458
- 11.690 0.14393917 0.14471538
- 11.700 0.14350299 0.14427752
- 11.710 0.14306813 0.14384097
- 11.720 0.14263459 0.14340575
- 11.730 0.14220237 0.14297185
- 11.740 0.14177145 0.14253925
- 11.750 0.14134184 0.14210797
- 11.760 0.14091353 0.14167799
- 11.770 0.14048652 0.14124932
- 11.780 0.14006080 0.14082194
- 11.790 0.13963638 0.14039585
- 11.800 0.13921324 0.13997105
- 11.810 0.13879138 0.13954754
- 11.820 0.13837080 0.13912531
- 11.830 0.13795149 0.13870435
- 11.840 0.13753346 0.13828467
- 11.850 0.13711669 0.13786626
- 11.860 0.13670118 0.13744912
- 11.870 0.13628694 0.13703324
- 11.880 0.13587395 0.13661861
- 11.890 0.13546221 0.13620524
- 11.900 0.13505172 0.13579312
- 11.910 0.13464247 0.13538225
- 11.920 0.13423446 0.13497262
- 11.930 0.13382769 0.13456424
- 11.940 0.13342215 0.13415708
- 11.950 0.13301784 0.13375116
- 11.960 0.13261476 0.13334647
- 11.970 0.13221290 0.13294300
- 11.980 0.13181225 0.13254075
- 11.990 0.13141282 0.13213972
- 12.000 0.13101460 0.13173990
- 12.010 0.13061758 0.13134130
- 12.020 0.13022177 0.13094389
- 12.030 0.12982716 0.13054770
- 12.040 0.12943375 0.13015270
- 12.050 0.12904152 0.12975889
- 12.060 0.12865049 0.12936628
- 12.070 0.12826064 0.12897485
- 12.080 0.12787197 0.12858461
- 12.090 0.12748448 0.12819555
- 12.100 0.12709816 0.12780767
- 12.110 0.12671302 0.12742096
- 12.120 0.12632904 0.12703542
- 12.130 0.12594622 0.12665104
- 12.140 0.12556457 0.12626783
- 12.150 0.12518407 0.12588578
- 12.160 0.12480472 0.12550489
- 12.170 0.12442653 0.12512515
- 12.180 0.12404948 0.12474655
- 12.190 0.12367357 0.12436911
- 12.200 0.12329880 0.12399280
- 12.210 0.12292517 0.12361763
- 12.220 0.12255267 0.12324360
- 12.230 0.12218130 0.12287070
- 12.240 0.12181105 0.12249893
- 12.250 0.12144192 0.12212828
- 12.260 0.12107392 0.12175876
- 12.270 0.12070703 0.12139035
- 12.280 0.12034125 0.12102306
- 12.290 0.11997658 0.12065687
- 12.300 0.11961301 0.12029180
- 12.310 0.11925055 0.11992783
- 12.320 0.11888918 0.11956496
- 12.330 0.11852891 0.11920319
- 12.340 0.11816974 0.11884252
- 12.350 0.11781165 0.11848294
- 12.360 0.11745464 0.11812444
- 12.370 0.11709872 0.11776703
- 12.380 0.11674387 0.11741070
- 12.390 0.11639010 0.11705545
- 12.400 0.11603741 0.11670127
- 12.410 0.11568578 0.11634817
- 12.420 0.11533522 0.11599613
- 12.430 0.11498571 0.11564516
- 12.440 0.11463727 0.11529525
- 12.450 0.11428989 0.11494640
- 12.460 0.11394355 0.11459860
- 12.470 0.11359827 0.11425186
- 12.480 0.11325403 0.11390617
- 12.490 0.11291084 0.11356152
- 12.500 0.11256869 0.11321791
- 12.510 0.11222757 0.11287535
- 12.520 0.11188748 0.11253382
- 12.530 0.11154843 0.11219332
- 12.540 0.11121041 0.11185386
- 12.550 0.11087340 0.11151542
- 12.560 0.11053742 0.11117801
- 12.570 0.11020246 0.11084161
- 12.580 0.10986852 0.11050624
- 12.590 0.10953558 0.11017188
- 12.600 0.10920366 0.10983853
- 12.610 0.10887274 0.10950619
- 12.620 0.10854282 0.10917485
- 12.630 0.10821390 0.10884452
- 12.640 0.10788598 0.10851519
- 12.650 0.10755905 0.10818685
- 12.660 0.10723312 0.10785951
- 12.670 0.10690817 0.10753316
- 12.680 0.10658420 0.10720779
- 12.690 0.10626122 0.10688341
- 12.700 0.10593922 0.10656001
- 12.710 0.10561819 0.10623759
- 12.720 0.10529813 0.10591615
- 12.730 0.10497905 0.10559568
- 12.740 0.10466093 0.10527617
- 12.750 0.10434378 0.10495764
- 12.760 0.10402758 0.10464007
- 12.770 0.10371235 0.10432346
- 12.780 0.10339807 0.10400780
- 12.790 0.10308474 0.10369310
- 12.800 0.10277236 0.10337936
- 12.810 0.10246093 0.10306656
- 12.820 0.10215044 0.10275471
- 12.830 0.10184090 0.10244380
- 12.840 0.10153229 0.10213384
- 12.850 0.10122461 0.10182481
- 12.860 0.10091787 0.10151672
- 12.870 0.10061206 0.10120956
- 12.880 0.10030718 0.10090333
- 12.890 0.10000321 0.10059802
- 12.900 0.09970017 0.10029364
- 12.910 0.09939805 0.09999018
- 12.920 0.09909685 0.09968764
- 12.930 0.09879655 0.09938601
- 12.940 0.09849717 0.09908530
- 12.950 0.09819869 0.09878549
- 12.960 0.09790112 0.09848660
- 12.970 0.09760445 0.09818860
- 12.980 0.09730868 0.09789151
- 12.990 0.09701381 0.09759532
- 13.000 0.09671982 0.09730003
- 13.010 0.09642673 0.09700562
- 13.020 0.09613453 0.09671211
- 13.030 0.09584321 0.09641949
- 13.040 0.09555278 0.09612775
- 13.050 0.09526323 0.09583690
- 13.060 0.09497455 0.09554692
- 13.070 0.09468675 0.09525782
- 13.080 0.09439982 0.09496960
- 13.090 0.09411376 0.09468225
- 13.100 0.09382857 0.09439577
- 13.110 0.09354424 0.09411015
- 13.120 0.09326077 0.09382540
- 13.130 0.09297816 0.09354151
- 13.140 0.09269641 0.09325848
- 13.150 0.09241551 0.09297631
- 13.160 0.09213546 0.09269499
- 13.170 0.09185627 0.09241452
- 13.180 0.09157791 0.09213490
- 13.190 0.09130040 0.09185613
- 13.200 0.09102374 0.09157819
- 13.210 0.09074791 0.09130110
- 13.220 0.09047291 0.09102485
- 13.230 0.09019875 0.09074944
diff --git a/20221121/loesung-1c.tikz b/20221121/loesung-1c.tikz
deleted file mode 100644
index e97073c442cd1f84adf842357e3cb254fb05e54c..0000000000000000000000000000000000000000
--- a/20221121/loesung-1c.tikz
+++ /dev/null
@@ -1,521 +0,0 @@
-\begin{tikzpicture}[gnuplot]
-%% generated with GNUPLOT 5.0p5 (Lua 5.1; terminal rev. 99, script rev. 100)
-%% Mi 14 Nov 2018 19:24:42 CET
-\path (0.000,0.000) rectangle (12.500,8.750);
-\gpcolor{color=gp lt color border}
-\gpsetlinetype{gp lt border}
-\gpsetdashtype{gp dt solid}
-\gpsetlinewidth{1.00}
-\draw[gp path] (1.012,0.616)--(1.192,0.616);
-\draw[gp path] (11.947,0.616)--(11.767,0.616);
-\node[gp node right] at (0.828,0.616) {$0$};
-\draw[gp path] (1.012,1.393)--(1.192,1.393);
-\draw[gp path] (11.947,1.393)--(11.767,1.393);
-\node[gp node right] at (0.828,1.393) {$0.5$};
-\draw[gp path] (1.012,2.169)--(1.192,2.169);
-\draw[gp path] (11.947,2.169)--(11.767,2.169);
-\node[gp node right] at (0.828,2.169) {$1$};
-\draw[gp path] (1.012,2.946)--(1.192,2.946);
-\draw[gp path] (11.947,2.946)--(11.767,2.946);
-\node[gp node right] at (0.828,2.946) {$1.5$};
-\draw[gp path] (1.012,3.722)--(1.192,3.722);
-\draw[gp path] (11.947,3.722)--(11.767,3.722);
-\node[gp node right] at (0.828,3.722) {$2$};
-\draw[gp path] (1.012,4.499)--(1.192,4.499);
-\draw[gp path] (11.947,4.499)--(11.767,4.499);
-\node[gp node right] at (0.828,4.499) {$2.5$};
-\draw[gp path] (1.012,5.275)--(1.192,5.275);
-\draw[gp path] (11.947,5.275)--(11.767,5.275);
-\node[gp node right] at (0.828,5.275) {$3$};
-\draw[gp path] (1.012,6.052)--(1.192,6.052);
-\draw[gp path] (11.947,6.052)--(11.767,6.052);
-\node[gp node right] at (0.828,6.052) {$3.5$};
-\draw[gp path] (1.012,6.828)--(1.192,6.828);
-\draw[gp path] (11.947,6.828)--(11.767,6.828);
-\node[gp node right] at (0.828,6.828) {$4$};
-\draw[gp path] (1.012,7.605)--(1.192,7.605);
-\draw[gp path] (11.947,7.605)--(11.767,7.605);
-\node[gp node right] at (0.828,7.605) {$4.5$};
-\draw[gp path] (1.012,8.381)--(1.192,8.381);
-\draw[gp path] (11.947,8.381)--(11.767,8.381);
-\node[gp node right] at (0.828,8.381) {$5$};
-\draw[gp path] (1.012,0.616)--(1.012,0.796);
-\draw[gp path] (1.012,8.381)--(1.012,8.201);
-\node[gp node center] at (1.012,0.308) {$0$};
-\draw[gp path] (2.574,0.616)--(2.574,0.796);
-\draw[gp path] (2.574,8.381)--(2.574,8.201);
-\node[gp node center] at (2.574,0.308) {$2$};
-\draw[gp path] (4.136,0.616)--(4.136,0.796);
-\draw[gp path] (4.136,8.381)--(4.136,8.201);
-\node[gp node center] at (4.136,0.308) {$4$};
-\draw[gp path] (5.698,0.616)--(5.698,0.796);
-\draw[gp path] (5.698,8.381)--(5.698,8.201);
-\node[gp node center] at (5.698,0.308) {$6$};
-\draw[gp path] (7.261,0.616)--(7.261,0.796);
-\draw[gp path] (7.261,8.381)--(7.261,8.201);
-\node[gp node center] at (7.261,0.308) {$8$};
-\draw[gp path] (8.823,0.616)--(8.823,0.796);
-\draw[gp path] (8.823,8.381)--(8.823,8.201);
-\node[gp node center] at (8.823,0.308) {$10$};
-\draw[gp path] (10.385,0.616)--(10.385,0.796);
-\draw[gp path] (10.385,8.381)--(10.385,8.201);
-\node[gp node center] at (10.385,0.308) {$12$};
-\draw[gp path] (11.947,0.616)--(11.947,0.796);
-\draw[gp path] (11.947,8.381)--(11.947,8.201);
-\node[gp node center] at (11.947,0.308) {$14$};
-\draw[gp path] (1.012,8.381)--(1.012,0.616)--(11.947,0.616)--(11.947,8.381)--cycle;
-\node[gp node right] at (10.479,7.8) {Simulation};
-\gpcolor{rgb color={0.580,0.000,0.827}}
-\draw[gp path] (10.663,7.8)--(11.579,7.8);
-\draw[gp path] (1.012,8.381)--(1.020,8.358)--(1.028,8.334)--(1.035,8.311)--(1.043,8.288)%
- --(1.051,8.265)--(1.059,8.241)--(1.067,8.218)--(1.074,8.195)--(1.082,8.171)--(1.090,8.150)%
- --(1.098,8.126)--(1.106,8.103)--(1.114,8.081)--(1.121,8.058)--(1.129,8.035)--(1.137,8.013)%
- --(1.145,7.991)--(1.153,7.968)--(1.160,7.946)--(1.168,7.924)--(1.176,7.901)--(1.184,7.879)%
- --(1.192,7.858)--(1.199,7.836)--(1.207,7.814)--(1.215,7.792)--(1.223,7.771)--(1.231,7.749)%
- --(1.239,7.727)--(1.246,7.705)--(1.254,7.684)--(1.262,7.662)--(1.270,7.642)--(1.278,7.620)%
- --(1.285,7.598)--(1.293,7.578)--(1.301,7.556)--(1.309,7.535)--(1.317,7.514)--(1.324,7.493)%
- --(1.332,7.472)--(1.340,7.452)--(1.348,7.431)--(1.356,7.410)--(1.363,7.390)--(1.371,7.370)%
- --(1.379,7.348)--(1.387,7.328)--(1.395,7.308)--(1.403,7.288)--(1.410,7.267)--(1.418,7.247)%
- --(1.426,7.227)--(1.434,7.207)--(1.442,7.187)--(1.449,7.168)--(1.457,7.148)--(1.465,7.128)%
- --(1.473,7.108)--(1.481,7.089)--(1.488,7.069)--(1.496,7.049)--(1.504,7.030)--(1.512,7.010)%
- --(1.520,6.991)--(1.528,6.971)--(1.535,6.952)--(1.543,6.934)--(1.551,6.913)--(1.559,6.895)%
- --(1.567,6.876)--(1.574,6.858)--(1.582,6.837)--(1.590,6.819)--(1.598,6.800)--(1.606,6.781)%
- --(1.613,6.763)--(1.621,6.744)--(1.629,6.726)--(1.637,6.707)--(1.645,6.688)--(1.652,6.670)%
- --(1.660,6.653)--(1.668,6.634)--(1.676,6.615)--(1.684,6.597)--(1.692,6.580)--(1.699,6.561)%
- --(1.707,6.542)--(1.715,6.525)--(1.723,6.507)--(1.731,6.489)--(1.738,6.471)--(1.746,6.454)%
- --(1.754,6.437)--(1.762,6.418)--(1.770,6.401)--(1.777,6.384)--(1.785,6.365)--(1.793,6.348)%
- --(1.801,6.331)--(1.809,6.314)--(1.817,6.297)--(1.824,6.280)--(1.832,6.263)--(1.840,6.246)%
- --(1.848,6.229)--(1.856,6.211)--(1.863,6.194)--(1.871,6.177)--(1.879,6.160)--(1.887,6.143)%
- --(1.895,6.126)--(1.902,6.111)--(1.910,6.093)--(1.918,6.076)--(1.926,6.061)--(1.934,6.044)%
- --(1.941,6.027)--(1.949,6.011)--(1.957,5.994)--(1.965,5.979)--(1.973,5.961)--(1.981,5.946)%
- --(1.988,5.929)--(1.996,5.913)--(2.004,5.898)--(2.012,5.881)--(2.020,5.865)--(2.027,5.850)%
- --(2.035,5.834)--(2.043,5.819)--(2.051,5.801)--(2.059,5.786)--(2.066,5.770)--(2.074,5.755)%
- --(2.082,5.739)--(2.090,5.724)--(2.098,5.708)--(2.106,5.693)--(2.113,5.677)--(2.121,5.662)%
- --(2.129,5.648)--(2.137,5.632)--(2.145,5.617)--(2.152,5.601)--(2.160,5.587)--(2.168,5.572)%
- --(2.176,5.556)--(2.184,5.541)--(2.191,5.527)--(2.199,5.511)--(2.207,5.497)--(2.215,5.482)%
- --(2.223,5.468)--(2.230,5.452)--(2.238,5.438)--(2.246,5.423)--(2.254,5.409)--(2.262,5.395)%
- --(2.270,5.379)--(2.277,5.365)--(2.285,5.351)--(2.293,5.337)--(2.301,5.322)--(2.309,5.308)%
- --(2.316,5.294)--(2.324,5.280)--(2.332,5.266)--(2.340,5.252)--(2.348,5.238)--(2.355,5.224)%
- --(2.363,5.210)--(2.371,5.196)--(2.379,5.182)--(2.387,5.168)--(2.394,5.154)--(2.402,5.140)%
- --(2.410,5.126)--(2.418,5.112)--(2.426,5.100)--(2.434,5.086)--(2.441,5.072)--(2.449,5.059)%
- --(2.457,5.045)--(2.465,5.031)--(2.473,5.019)--(2.480,5.005)--(2.488,4.991)--(2.496,4.978)%
- --(2.504,4.964)--(2.512,4.952)--(2.519,4.938)--(2.527,4.926)--(2.535,4.913)--(2.543,4.899)%
- --(2.551,4.887)--(2.559,4.874)--(2.566,4.860)--(2.574,4.848)--(2.582,4.836)--(2.590,4.822)%
- --(2.598,4.809)--(2.605,4.797)--(2.613,4.784)--(2.621,4.772)--(2.629,4.759)--(2.637,4.747)%
- --(2.644,4.735)--(2.652,4.722)--(2.660,4.710)--(2.668,4.697)--(2.676,4.685)--(2.683,4.672)%
- --(2.691,4.660)--(2.699,4.648)--(2.707,4.635)--(2.715,4.623)--(2.723,4.610)--(2.730,4.598)%
- --(2.738,4.587)--(2.746,4.575)--(2.754,4.562)--(2.762,4.551)--(2.769,4.539)--(2.777,4.526)%
- --(2.785,4.516)--(2.793,4.503)--(2.801,4.491)--(2.808,4.480)--(2.816,4.467)--(2.824,4.457)%
- --(2.832,4.444)--(2.840,4.433)--(2.848,4.421)--(2.855,4.410)--(2.863,4.399)--(2.871,4.387)%
- --(2.879,4.376)--(2.887,4.363)--(2.894,4.353)--(2.902,4.342)--(2.910,4.331)--(2.918,4.318)%
- --(2.926,4.307)--(2.933,4.297)--(2.941,4.286)--(2.949,4.275)--(2.957,4.262)--(2.965,4.252)%
- --(2.972,4.241)--(2.980,4.230)--(2.988,4.219)--(2.996,4.208)--(3.004,4.197)--(3.012,4.186)%
- --(3.019,4.175)--(3.027,4.165)--(3.035,4.154)--(3.043,4.143)--(3.051,4.132)--(3.058,4.123)%
- --(3.066,4.112)--(3.074,4.101)--(3.082,4.090)--(3.090,4.079)--(3.097,4.070)--(3.105,4.059)%
- --(3.113,4.048)--(3.121,4.037)--(3.129,4.028)--(3.137,4.017)--(3.144,4.006)--(3.152,3.997)%
- --(3.160,3.986)--(3.168,3.977)--(3.176,3.966)--(3.183,3.957)--(3.191,3.946)--(3.199,3.936)%
- --(3.207,3.925)--(3.215,3.916)--(3.222,3.905)--(3.230,3.896)--(3.238,3.885)--(3.246,3.876)%
- --(3.254,3.866)--(3.261,3.856)--(3.269,3.846)--(3.277,3.837)--(3.285,3.826)--(3.293,3.817)%
- --(3.301,3.807)--(3.308,3.798)--(3.316,3.787)--(3.324,3.778)--(3.332,3.769)--(3.340,3.759)%
- --(3.347,3.750)--(3.355,3.741)--(3.363,3.731)--(3.371,3.720)--(3.379,3.711)--(3.386,3.702)%
- --(3.394,3.692)--(3.402,3.683)--(3.410,3.674)--(3.418,3.665)--(3.426,3.655)--(3.433,3.647)%
- --(3.441,3.638)--(3.449,3.629)--(3.457,3.620)--(3.465,3.610)--(3.472,3.601)--(3.480,3.592)%
- --(3.488,3.584)--(3.496,3.574)--(3.504,3.565)--(3.511,3.556)--(3.519,3.547)--(3.527,3.539)%
- --(3.535,3.529)--(3.543,3.520)--(3.550,3.512)--(3.558,3.503)--(3.566,3.494)--(3.574,3.486)%
- --(3.582,3.477)--(3.590,3.469)--(3.597,3.460)--(3.605,3.450)--(3.613,3.442)--(3.621,3.433)%
- --(3.629,3.425)--(3.636,3.416)--(3.644,3.408)--(3.652,3.401)--(3.660,3.391)--(3.668,3.383)%
- --(3.675,3.374)--(3.683,3.366)--(3.691,3.359)--(3.699,3.349)--(3.707,3.342)--(3.715,3.334)%
- --(3.722,3.324)--(3.730,3.317)--(3.738,3.309)--(3.746,3.300)--(3.754,3.292)--(3.761,3.284)%
- --(3.769,3.276)--(3.777,3.269)--(3.785,3.259)--(3.793,3.251)--(3.800,3.244)--(3.808,3.236)%
- --(3.816,3.228)--(3.824,3.220)--(3.832,3.213)--(3.839,3.205)--(3.847,3.197)--(3.855,3.189)%
- --(3.863,3.182)--(3.871,3.174)--(3.879,3.166)--(3.886,3.158)--(3.894,3.150)--(3.902,3.143)%
- --(3.910,3.135)--(3.918,3.127)--(3.925,3.119)--(3.933,3.112)--(3.941,3.104)--(3.949,3.096)%
- --(3.957,3.088)--(3.964,3.082)--(3.972,3.074)--(3.980,3.067)--(3.988,3.059)--(3.996,3.051)%
- --(4.004,3.045)--(4.011,3.037)--(4.019,3.029)--(4.027,3.023)--(4.035,3.015)--(4.043,3.008)%
- --(4.050,3.001)--(4.058,2.994)--(4.066,2.986)--(4.074,2.980)--(4.082,2.972)--(4.089,2.964)%
- --(4.097,2.958)--(4.105,2.950)--(4.113,2.944)--(4.121,2.936)--(4.128,2.930)--(4.136,2.922)%
- --(4.144,2.916)--(4.152,2.908)--(4.160,2.902)--(4.168,2.894)--(4.175,2.888)--(4.183,2.880)%
- --(4.191,2.874)--(4.199,2.866)--(4.207,2.860)--(4.214,2.854)--(4.222,2.846)--(4.230,2.840)%
- --(4.238,2.834)--(4.246,2.826)--(4.253,2.820)--(4.261,2.813)--(4.269,2.806)--(4.277,2.800)%
- --(4.285,2.793)--(4.293,2.787)--(4.300,2.779)--(4.308,2.773)--(4.316,2.767)--(4.324,2.761)%
- --(4.332,2.754)--(4.339,2.747)--(4.347,2.741)--(4.355,2.734)--(4.363,2.728)--(4.371,2.722)%
- --(4.378,2.716)--(4.386,2.709)--(4.394,2.703)--(4.402,2.695)--(4.410,2.689)--(4.417,2.683)%
- --(4.425,2.677)--(4.433,2.671)--(4.441,2.664)--(4.449,2.658)--(4.457,2.652)--(4.464,2.646)%
- --(4.472,2.640)--(4.480,2.633)--(4.488,2.629)--(4.496,2.622)--(4.503,2.616)--(4.511,2.610)%
- --(4.519,2.604)--(4.527,2.598)--(4.535,2.591)--(4.542,2.585)--(4.550,2.579)--(4.558,2.574)%
- --(4.566,2.568)--(4.574,2.562)--(4.581,2.556)--(4.589,2.549)--(4.597,2.545)--(4.605,2.539)%
- --(4.613,2.532)--(4.621,2.526)--(4.628,2.522)--(4.636,2.515)--(4.644,2.509)--(4.652,2.504)%
- --(4.660,2.498)--(4.667,2.492)--(4.675,2.487)--(4.683,2.481)--(4.691,2.475)--(4.699,2.470)%
- --(4.706,2.464)--(4.714,2.458)--(4.722,2.453)--(4.730,2.447)--(4.738,2.442)--(4.746,2.436)%
- --(4.753,2.430)--(4.761,2.425)--(4.769,2.419)--(4.777,2.414)--(4.785,2.408)--(4.792,2.404)%
- --(4.800,2.397)--(4.808,2.393)--(4.816,2.386)--(4.824,2.382)--(4.831,2.377)--(4.839,2.371)%
- --(4.847,2.366)--(4.855,2.360)--(4.863,2.355)--(4.870,2.349)--(4.878,2.344)--(4.886,2.340)%
- --(4.894,2.334)--(4.902,2.329)--(4.910,2.324)--(4.917,2.318)--(4.925,2.313)--(4.933,2.309)%
- --(4.941,2.303)--(4.949,2.298)--(4.956,2.293)--(4.964,2.289)--(4.972,2.282)--(4.980,2.278)%
- --(4.988,2.273)--(4.995,2.268)--(5.003,2.262)--(5.011,2.258)--(5.019,2.253)--(5.027,2.248)%
- --(5.035,2.244)--(5.042,2.237)--(5.050,2.233)--(5.058,2.228)--(5.066,2.223)--(5.074,2.219)%
- --(5.081,2.214)--(5.089,2.209)--(5.097,2.203)--(5.105,2.199)--(5.113,2.194)--(5.120,2.189)%
- --(5.128,2.185)--(5.136,2.180)--(5.144,2.175)--(5.152,2.171)--(5.159,2.166)--(5.167,2.161)%
- --(5.175,2.157)--(5.183,2.152)--(5.191,2.147)--(5.199,2.143)--(5.206,2.138)--(5.214,2.133)%
- --(5.222,2.129)--(5.230,2.124)--(5.238,2.119)--(5.245,2.115)--(5.253,2.110)--(5.261,2.105)%
- --(5.269,2.101)--(5.277,2.096)--(5.284,2.093)--(5.292,2.088)--(5.300,2.084)--(5.308,2.079)%
- --(5.316,2.074)--(5.324,2.070)--(5.331,2.065)--(5.339,2.062)--(5.347,2.057)--(5.355,2.053)%
- --(5.363,2.048)--(5.370,2.043)--(5.378,2.040)--(5.386,2.035)--(5.394,2.031)--(5.402,2.026)%
- --(5.409,2.023)--(5.417,2.018)--(5.425,2.014)--(5.433,2.009)--(5.441,2.006)--(5.448,2.001)%
- --(5.456,1.997)--(5.464,1.994)--(5.472,1.989)--(5.480,1.984)--(5.488,1.980)--(5.495,1.976)%
- --(5.503,1.972)--(5.511,1.969)--(5.519,1.964)--(5.527,1.959)--(5.534,1.956)--(5.542,1.952)%
- --(5.550,1.947)--(5.558,1.944)--(5.566,1.939)--(5.573,1.936)--(5.581,1.931)--(5.589,1.927)%
- --(5.597,1.924)--(5.605,1.919)--(5.613,1.916)--(5.620,1.911)--(5.628,1.908)--(5.636,1.903)%
- --(5.644,1.900)--(5.652,1.896)--(5.659,1.893)--(5.667,1.888)--(5.675,1.885)--(5.683,1.880)%
- --(5.691,1.877)--(5.698,1.872)--(5.706,1.869)--(5.714,1.865)--(5.722,1.862)--(5.730,1.858)%
- --(5.737,1.854)--(5.745,1.851)--(5.753,1.846)--(5.761,1.843)--(5.769,1.840)--(5.777,1.835)%
- --(5.784,1.832)--(5.792,1.827)--(5.800,1.824)--(5.808,1.821)--(5.816,1.816)--(5.823,1.813)%
- --(5.831,1.810)--(5.839,1.806)--(5.847,1.802)--(5.855,1.799)--(5.862,1.795)--(5.870,1.792)%
- --(5.878,1.789)--(5.886,1.785)--(5.894,1.781)--(5.902,1.778)--(5.909,1.775)--(5.917,1.770)%
- --(5.925,1.767)--(5.933,1.764)--(5.941,1.761)--(5.948,1.756)--(5.956,1.753)--(5.964,1.750)%
- --(5.972,1.747)--(5.980,1.743)--(5.987,1.739)--(5.995,1.736)--(6.003,1.733)--(6.011,1.730)%
- --(6.019,1.726)--(6.026,1.723)--(6.034,1.719)--(6.042,1.716)--(6.050,1.712)--(6.058,1.709)%
- --(6.066,1.706)--(6.073,1.703)--(6.081,1.700)--(6.089,1.695)--(6.097,1.692)--(6.105,1.689)%
- --(6.112,1.686)--(6.120,1.683)--(6.128,1.680)--(6.136,1.677)--(6.144,1.674)--(6.151,1.670)%
- --(6.159,1.667)--(6.167,1.664)--(6.175,1.661)--(6.183,1.658)--(6.191,1.655)--(6.198,1.650)%
- --(6.206,1.647)--(6.214,1.644)--(6.222,1.641)--(6.230,1.638)--(6.237,1.635)--(6.245,1.632)%
- --(6.253,1.629)--(6.261,1.625)--(6.269,1.624)--(6.276,1.621)--(6.284,1.618)--(6.292,1.615)%
- --(6.300,1.611)--(6.308,1.608)--(6.315,1.605)--(6.323,1.602)--(6.331,1.599)--(6.339,1.596)%
- --(6.347,1.593)--(6.355,1.590)--(6.362,1.587)--(6.370,1.584)--(6.378,1.582)--(6.386,1.579)%
- --(6.394,1.576)--(6.401,1.573)--(6.409,1.570)--(6.417,1.566)--(6.425,1.563)--(6.433,1.560)%
- --(6.440,1.559)--(6.448,1.556)--(6.456,1.552)--(6.464,1.549)--(6.472,1.546)--(6.480,1.545)%
- --(6.487,1.542)--(6.495,1.538)--(6.503,1.535)--(6.511,1.532)--(6.519,1.531)--(6.526,1.528)%
- --(6.534,1.525)--(6.542,1.521)--(6.550,1.518)--(6.558,1.517)--(6.565,1.514)--(6.573,1.511)%
- --(6.581,1.507)--(6.589,1.506)--(6.597,1.503)--(6.604,1.500)--(6.612,1.497)--(6.620,1.495)%
- --(6.628,1.492)--(6.636,1.489)--(6.644,1.487)--(6.651,1.484)--(6.659,1.481)--(6.667,1.479)%
- --(6.675,1.476)--(6.683,1.473)--(6.690,1.470)--(6.698,1.469)--(6.706,1.465)--(6.714,1.464)%
- --(6.722,1.461)--(6.729,1.458)--(6.737,1.456)--(6.745,1.453)--(6.753,1.450)--(6.761,1.448)%
- --(6.768,1.445)--(6.776,1.442)--(6.784,1.441)--(6.792,1.438)--(6.800,1.436)--(6.808,1.433)%
- --(6.815,1.430)--(6.823,1.428)--(6.831,1.425)--(6.839,1.424)--(6.847,1.420)--(6.854,1.419)%
- --(6.862,1.416)--(6.870,1.413)--(6.878,1.411)--(6.886,1.408)--(6.893,1.406)--(6.901,1.403)%
- --(6.909,1.402)--(6.917,1.399)--(6.925,1.397)--(6.933,1.394)--(6.940,1.393)--(6.948,1.389)%
- --(6.956,1.388)--(6.964,1.385)--(6.972,1.383)--(6.979,1.380)--(6.987,1.379)--(6.995,1.375)%
- --(7.003,1.374)--(7.011,1.371)--(7.018,1.369)--(7.026,1.366)--(7.034,1.365)--(7.042,1.361)%
- --(7.050,1.360)--(7.057,1.357)--(7.065,1.355)--(7.073,1.352)--(7.081,1.351)--(7.089,1.349)%
- --(7.097,1.346)--(7.104,1.344)--(7.112,1.341)--(7.120,1.340)--(7.128,1.337)--(7.136,1.335)%
- --(7.143,1.333)--(7.151,1.330)--(7.159,1.329)--(7.167,1.326)--(7.175,1.324)--(7.182,1.323)%
- --(7.190,1.320)--(7.198,1.318)--(7.206,1.316)--(7.214,1.313)--(7.222,1.312)--(7.229,1.309)%
- --(7.237,1.307)--(7.245,1.306)--(7.253,1.302)--(7.261,1.301)--(7.268,1.299)--(7.276,1.296)%
- --(7.284,1.295)--(7.292,1.293)--(7.300,1.290)--(7.307,1.288)--(7.315,1.287)--(7.323,1.285)%
- --(7.331,1.282)--(7.339,1.281)--(7.346,1.279)--(7.354,1.276)--(7.362,1.274)--(7.370,1.273)%
- --(7.378,1.270)--(7.386,1.268)--(7.393,1.267)--(7.401,1.265)--(7.409,1.262)--(7.417,1.260)%
- --(7.425,1.259)--(7.432,1.257)--(7.440,1.254)--(7.448,1.253)--(7.456,1.251)--(7.464,1.250)%
- --(7.471,1.247)--(7.479,1.245)--(7.487,1.243)--(7.495,1.242)--(7.503,1.239)--(7.511,1.237)%
- --(7.518,1.236)--(7.526,1.234)--(7.534,1.233)--(7.542,1.229)--(7.550,1.228)--(7.557,1.226)%
- --(7.565,1.225)--(7.573,1.223)--(7.581,1.220)--(7.589,1.219)--(7.596,1.217)--(7.604,1.215)%
- --(7.612,1.214)--(7.620,1.212)--(7.628,1.209)--(7.635,1.208)--(7.643,1.206)--(7.651,1.205)%
- --(7.659,1.203)--(7.667,1.201)--(7.675,1.200)--(7.682,1.197)--(7.690,1.195)--(7.698,1.194)%
- --(7.706,1.192)--(7.714,1.191)--(7.721,1.189)--(7.729,1.188)--(7.737,1.186)--(7.745,1.183)%
- --(7.753,1.181)--(7.760,1.180)--(7.768,1.178)--(7.776,1.177)--(7.784,1.175)--(7.792,1.174)%
- --(7.800,1.172)--(7.807,1.170)--(7.815,1.169)--(7.823,1.167)--(7.831,1.164)--(7.839,1.163)%
- --(7.846,1.161)--(7.854,1.160)--(7.862,1.158)--(7.870,1.156)--(7.878,1.155)--(7.885,1.153)%
- --(7.893,1.152)--(7.901,1.150)--(7.909,1.149)--(7.917,1.147)--(7.924,1.146)--(7.932,1.144)%
- --(7.940,1.142)--(7.948,1.141)--(7.956,1.139)--(7.964,1.138)--(7.971,1.136)--(7.979,1.135)%
- --(7.987,1.133)--(7.995,1.132)--(8.003,1.130)--(8.010,1.128)--(8.018,1.127)--(8.026,1.125)%
- --(8.034,1.124)--(8.042,1.122)--(8.049,1.121)--(8.057,1.119)--(8.065,1.118)--(8.073,1.116)%
- --(8.081,1.115)--(8.089,1.113)--(8.096,1.111)--(8.104,1.110)--(8.112,1.108)--(8.120,1.107)%
- --(8.128,1.105)--(8.135,1.104)--(8.143,1.102)--(8.151,1.101)--(8.159,1.099)--(8.167,1.097)%
- --(8.174,1.096)--(8.182,1.094)--(8.190,1.093)--(8.198,1.091)--(8.206,1.091)--(8.213,1.090)%
- --(8.221,1.088)--(8.229,1.087)--(8.237,1.085)--(8.245,1.083)--(8.253,1.082)--(8.260,1.080)%
- --(8.268,1.079)--(8.276,1.077)--(8.284,1.076)--(8.292,1.074)--(8.299,1.074)--(8.307,1.073)%
- --(8.315,1.071)--(8.323,1.069)--(8.331,1.068)--(8.338,1.066)--(8.346,1.065)--(8.354,1.063)%
- --(8.362,1.063)--(8.370,1.062)--(8.378,1.060)--(8.385,1.059)--(8.393,1.057)--(8.401,1.055)%
- --(8.409,1.054)--(8.417,1.052)--(8.424,1.052)--(8.432,1.051)--(8.440,1.049)--(8.448,1.048)%
- --(8.456,1.046)--(8.463,1.045)--(8.471,1.045)--(8.479,1.043)--(8.487,1.042)--(8.495,1.040)%
- --(8.502,1.038)--(8.510,1.037)--(8.518,1.037)--(8.526,1.035)--(8.534,1.034)--(8.542,1.032)%
- --(8.549,1.031)--(8.557,1.031)--(8.565,1.029)--(8.573,1.028)--(8.581,1.026)--(8.588,1.024)%
- --(8.596,1.024)--(8.604,1.023)--(8.612,1.021)--(8.620,1.020)--(8.627,1.018)--(8.635,1.018)%
- --(8.643,1.017)--(8.651,1.015)--(8.659,1.014)--(8.667,1.012)--(8.674,1.012)--(8.682,1.010)%
- --(8.690,1.009)--(8.698,1.007)--(8.706,1.007)--(8.713,1.006)--(8.721,1.004)--(8.729,1.003)%
- --(8.737,1.003)--(8.745,1.001)--(8.752,1.000)--(8.760,0.998)--(8.768,0.998)--(8.776,0.996)%
- --(8.784,0.995)--(8.791,0.993)--(8.799,0.993)--(8.807,0.992)--(8.815,0.990)--(8.823,0.989)%
- --(8.831,0.989)--(8.838,0.987)--(8.846,0.986)--(8.854,0.984)--(8.862,0.984)--(8.870,0.983)%
- --(8.877,0.981)--(8.885,0.981)--(8.893,0.979)--(8.901,0.978)--(8.909,0.978)--(8.916,0.976)%
- --(8.924,0.975)--(8.932,0.973)--(8.940,0.973)--(8.948,0.972)--(8.955,0.970)--(8.963,0.970)%
- --(8.971,0.969)--(8.979,0.967)--(8.987,0.967)--(8.995,0.965)--(9.002,0.964)--(9.010,0.964)%
- --(9.018,0.962)--(9.026,0.961)--(9.034,0.959)--(9.041,0.959)--(9.049,0.958)--(9.057,0.956)%
- --(9.065,0.956)--(9.073,0.955)--(9.080,0.953)--(9.088,0.953)--(9.096,0.951)--(9.104,0.951)%
- --(9.112,0.950)--(9.120,0.948)--(9.127,0.948)--(9.135,0.947)--(9.143,0.945)--(9.151,0.945)%
- --(9.159,0.944)--(9.166,0.942)--(9.174,0.942)--(9.182,0.941)--(9.190,0.939)--(9.198,0.939)%
- --(9.205,0.937)--(9.213,0.937)--(9.221,0.936)--(9.229,0.934)--(9.237,0.934)--(9.244,0.933)%
- --(9.252,0.931)--(9.260,0.931)--(9.268,0.930)--(9.276,0.930)--(9.284,0.928)--(9.291,0.927)%
- --(9.299,0.927)--(9.307,0.925)--(9.315,0.925)--(9.323,0.923)--(9.330,0.922)--(9.338,0.922)%
- --(9.346,0.920)--(9.354,0.920)--(9.362,0.919)--(9.369,0.917)--(9.377,0.917)--(9.385,0.916)%
- --(9.393,0.916)--(9.401,0.914)--(9.409,0.913)--(9.416,0.913)--(9.424,0.911)--(9.432,0.911)%
- --(9.440,0.910)--(9.448,0.910)--(9.455,0.908)--(9.463,0.906)--(9.471,0.906)--(9.479,0.905)%
- --(9.487,0.905)--(9.494,0.903)--(9.502,0.903)--(9.510,0.902)--(9.518,0.900)--(9.526,0.900)%
- --(9.533,0.899)--(9.541,0.899)--(9.549,0.897)--(9.557,0.897)--(9.565,0.896)--(9.573,0.896)%
- --(9.580,0.894)--(9.588,0.894)--(9.596,0.892)--(9.604,0.891)--(9.612,0.891)--(9.619,0.889)%
- --(9.627,0.889)--(9.635,0.888)--(9.643,0.888)--(9.651,0.886)--(9.658,0.886)--(9.666,0.885)%
- --(9.674,0.885)--(9.682,0.883)--(9.690,0.883)--(9.698,0.882)--(9.705,0.882)--(9.713,0.880)%
- --(9.721,0.880)--(9.729,0.878)--(9.737,0.878)--(9.744,0.877)--(9.752,0.877)--(9.760,0.875)%
- --(9.768,0.875)--(9.776,0.874)--(9.783,0.874)--(9.791,0.872)--(9.799,0.872)--(9.807,0.871)%
- --(9.815,0.871)--(9.822,0.869)--(9.830,0.869)--(9.838,0.868)--(9.846,0.868)--(9.854,0.866)%
- --(9.862,0.866)--(9.869,0.864)--(9.877,0.864)--(9.885,0.863)--(9.893,0.863)--(9.901,0.861)%
- --(9.908,0.861)--(9.916,0.860)--(9.924,0.860)--(9.932,0.858)--(9.940,0.858)--(9.947,0.857)%
- --(9.955,0.857)--(9.963,0.855)--(9.971,0.855)--(9.979,0.854)--(9.987,0.854)--(9.994,0.852)%
- --(10.002,0.852)--(10.010,0.852)--(10.018,0.851)--(10.026,0.851)--(10.033,0.849)--(10.041,0.849)%
- --(10.049,0.847)--(10.057,0.847)--(10.065,0.846)--(10.072,0.846)--(10.080,0.844)--(10.088,0.844)%
- --(10.096,0.844)--(10.104,0.843)--(10.111,0.843)--(10.119,0.841)--(10.127,0.841)--(10.135,0.840)%
- --(10.143,0.840)--(10.151,0.840)--(10.158,0.838)--(10.166,0.838)--(10.174,0.837)--(10.182,0.837)%
- --(10.190,0.835)--(10.197,0.835)--(10.205,0.833)--(10.213,0.833)--(10.221,0.833)--(10.229,0.832)%
- --(10.236,0.832)--(10.244,0.830)--(10.252,0.830)--(10.260,0.830)--(10.268,0.829)--(10.276,0.829)%
- --(10.283,0.827)--(10.291,0.827)--(10.299,0.826)--(10.307,0.826)--(10.315,0.826)--(10.322,0.824)%
- --(10.330,0.824)--(10.338,0.823)--(10.346,0.823)--(10.354,0.823)--(10.361,0.821)--(10.369,0.821)%
- --(10.377,0.819)--(10.385,0.819)--(10.393,0.819)--(10.400,0.818)--(10.408,0.818)--(10.416,0.816)%
- --(10.424,0.816)--(10.432,0.816)--(10.440,0.815)--(10.447,0.815)--(10.455,0.813)--(10.463,0.813)%
- --(10.471,0.813)--(10.479,0.812)--(10.486,0.812)--(10.494,0.812)--(10.502,0.810)--(10.510,0.810)%
- --(10.518,0.809)--(10.525,0.809)--(10.533,0.809)--(10.541,0.807)--(10.549,0.807)--(10.557,0.807)%
- --(10.565,0.805)--(10.572,0.805)--(10.580,0.804)--(10.588,0.804)--(10.596,0.804)--(10.604,0.802)%
- --(10.611,0.802)--(10.619,0.802)--(10.627,0.801)--(10.635,0.801)--(10.643,0.801)--(10.650,0.799)%
- --(10.658,0.799)--(10.666,0.798)--(10.674,0.798)--(10.682,0.798)--(10.689,0.796)--(10.697,0.796)%
- --(10.705,0.796)--(10.713,0.795)--(10.721,0.795)--(10.729,0.795)--(10.736,0.793)--(10.744,0.793)%
- --(10.752,0.793)--(10.760,0.791)--(10.768,0.791)--(10.775,0.791)--(10.783,0.790)--(10.791,0.790)%
- --(10.799,0.790)--(10.807,0.788)--(10.814,0.788)--(10.822,0.788)--(10.830,0.787)--(10.838,0.787)%
- --(10.846,0.787)--(10.854,0.785)--(10.861,0.785)--(10.869,0.785)--(10.877,0.784)--(10.885,0.784)%
- --(10.893,0.784)--(10.900,0.782)--(10.908,0.782)--(10.916,0.782)--(10.924,0.781)--(10.932,0.781)%
- --(10.939,0.781)--(10.947,0.779)--(10.955,0.779)--(10.963,0.779)--(10.971,0.778)--(10.978,0.778)%
- --(10.986,0.778)--(10.994,0.776)--(11.002,0.776)--(11.010,0.776)--(11.018,0.774)--(11.025,0.774)%
- --(11.033,0.774)--(11.041,0.774)--(11.049,0.773)--(11.057,0.773)--(11.064,0.773)--(11.072,0.771)%
- --(11.080,0.771)--(11.088,0.771)--(11.096,0.770)--(11.103,0.770)--(11.111,0.770)--(11.119,0.768)%
- --(11.127,0.768)--(11.135,0.768)--(11.142,0.768)--(11.150,0.767)--(11.158,0.767)--(11.166,0.767)%
- --(11.174,0.765)--(11.182,0.765)--(11.189,0.765)--(11.197,0.765)--(11.205,0.764)--(11.213,0.764)%
- --(11.221,0.764)--(11.228,0.762)--(11.236,0.762)--(11.244,0.762)--(11.252,0.762)--(11.260,0.760)%
- --(11.267,0.760)--(11.275,0.760)--(11.283,0.759)--(11.291,0.759)--(11.299,0.759)--(11.307,0.759)%
- --(11.314,0.757)--(11.322,0.757)--(11.330,0.757)--(11.338,0.756)--(11.346,0.756);
-\gpcolor{color=gp lt color border}
-\node[gp node right] at (10.479,7.35) {Theorie};
-\gpcolor{rgb color={0.000,0.620,0.451}}
-\draw[gp path] (10.663,7.35)--(11.579,7.35);
-\draw[gp path] (1.012,8.381)--(1.020,8.358)--(1.028,8.334)--(1.035,8.311)--(1.043,8.288)%
- --(1.051,8.265)--(1.059,8.241)--(1.067,8.218)--(1.074,8.195)--(1.082,8.171)--(1.090,8.150)%
- --(1.098,8.126)--(1.106,8.103)--(1.114,8.081)--(1.121,8.058)--(1.129,8.036)--(1.137,8.013)%
- --(1.145,7.991)--(1.153,7.969)--(1.160,7.946)--(1.168,7.924)--(1.176,7.903)--(1.184,7.881)%
- --(1.192,7.858)--(1.199,7.836)--(1.207,7.814)--(1.215,7.792)--(1.223,7.771)--(1.231,7.749)%
- --(1.239,7.727)--(1.246,7.707)--(1.254,7.685)--(1.262,7.664)--(1.270,7.642)--(1.278,7.620)%
- --(1.285,7.600)--(1.293,7.578)--(1.301,7.558)--(1.309,7.536)--(1.317,7.516)--(1.324,7.494)%
- --(1.332,7.474)--(1.340,7.452)--(1.348,7.432)--(1.356,7.412)--(1.363,7.392)--(1.371,7.370)%
- --(1.379,7.350)--(1.387,7.330)--(1.395,7.309)--(1.403,7.289)--(1.410,7.269)--(1.418,7.249)%
- --(1.426,7.229)--(1.434,7.208)--(1.442,7.188)--(1.449,7.170)--(1.457,7.149)--(1.465,7.129)%
- --(1.473,7.109)--(1.481,7.090)--(1.488,7.070)--(1.496,7.052)--(1.504,7.031)--(1.512,7.013)%
- --(1.520,6.993)--(1.528,6.974)--(1.535,6.954)--(1.543,6.935)--(1.551,6.917)--(1.559,6.896)%
- --(1.567,6.878)--(1.574,6.859)--(1.582,6.840)--(1.590,6.822)--(1.598,6.803)--(1.606,6.783)%
- --(1.613,6.764)--(1.621,6.746)--(1.629,6.729)--(1.637,6.710)--(1.645,6.691)--(1.652,6.673)%
- --(1.660,6.654)--(1.668,6.635)--(1.676,6.618)--(1.684,6.600)--(1.692,6.581)--(1.699,6.564)%
- --(1.707,6.545)--(1.715,6.528)--(1.723,6.510)--(1.731,6.493)--(1.738,6.474)--(1.746,6.457)%
- --(1.754,6.438)--(1.762,6.421)--(1.770,6.404)--(1.777,6.385)--(1.785,6.368)--(1.793,6.351)%
- --(1.801,6.334)--(1.809,6.317)--(1.817,6.298)--(1.824,6.281)--(1.832,6.264)--(1.840,6.247)%
- --(1.848,6.230)--(1.856,6.213)--(1.863,6.197)--(1.871,6.180)--(1.879,6.163)--(1.887,6.146)%
- --(1.895,6.129)--(1.902,6.112)--(1.910,6.097)--(1.918,6.079)--(1.926,6.062)--(1.934,6.047)%
- --(1.941,6.030)--(1.949,6.014)--(1.957,5.997)--(1.965,5.982)--(1.973,5.965)--(1.981,5.949)%
- --(1.988,5.932)--(1.996,5.916)--(2.004,5.901)--(2.012,5.884)--(2.020,5.868)--(2.027,5.853)%
- --(2.035,5.837)--(2.043,5.822)--(2.051,5.805)--(2.059,5.789)--(2.066,5.774)--(2.074,5.758)%
- --(2.082,5.742)--(2.090,5.727)--(2.098,5.711)--(2.106,5.696)--(2.113,5.680)--(2.121,5.666)%
- --(2.129,5.651)--(2.137,5.635)--(2.145,5.620)--(2.152,5.604)--(2.160,5.590)--(2.168,5.575)%
- --(2.176,5.559)--(2.184,5.545)--(2.191,5.530)--(2.199,5.516)--(2.207,5.500)--(2.215,5.485)%
- --(2.223,5.471)--(2.230,5.457)--(2.238,5.441)--(2.246,5.427)--(2.254,5.412)--(2.262,5.398)%
- --(2.270,5.384)--(2.277,5.368)--(2.285,5.354)--(2.293,5.340)--(2.301,5.326)--(2.309,5.311)%
- --(2.316,5.297)--(2.324,5.283)--(2.332,5.269)--(2.340,5.255)--(2.348,5.241)--(2.355,5.227)%
- --(2.363,5.213)--(2.371,5.199)--(2.379,5.185)--(2.387,5.171)--(2.394,5.157)--(2.402,5.145)%
- --(2.410,5.131)--(2.418,5.117)--(2.426,5.103)--(2.434,5.089)--(2.441,5.076)--(2.449,5.062)%
- --(2.457,5.048)--(2.465,5.036)--(2.473,5.022)--(2.480,5.008)--(2.488,4.995)--(2.496,4.981)%
- --(2.504,4.969)--(2.512,4.955)--(2.519,4.943)--(2.527,4.930)--(2.535,4.916)--(2.543,4.904)%
- --(2.551,4.890)--(2.559,4.877)--(2.566,4.865)--(2.574,4.851)--(2.582,4.839)--(2.590,4.826)%
- --(2.598,4.814)--(2.605,4.801)--(2.613,4.787)--(2.621,4.775)--(2.629,4.763)--(2.637,4.750)%
- --(2.644,4.738)--(2.652,4.725)--(2.660,4.713)--(2.668,4.700)--(2.676,4.688)--(2.683,4.676)%
- --(2.691,4.663)--(2.699,4.651)--(2.707,4.640)--(2.715,4.627)--(2.723,4.615)--(2.730,4.603)%
- --(2.738,4.590)--(2.746,4.579)--(2.754,4.567)--(2.762,4.554)--(2.769,4.542)--(2.777,4.531)%
- --(2.785,4.519)--(2.793,4.508)--(2.801,4.495)--(2.808,4.483)--(2.816,4.472)--(2.824,4.460)%
- --(2.832,4.449)--(2.840,4.436)--(2.848,4.426)--(2.855,4.415)--(2.863,4.402)--(2.871,4.391)%
- --(2.879,4.379)--(2.887,4.368)--(2.894,4.357)--(2.902,4.346)--(2.910,4.334)--(2.918,4.323)%
- --(2.926,4.312)--(2.933,4.301)--(2.941,4.289)--(2.949,4.278)--(2.957,4.267)--(2.965,4.256)%
- --(2.972,4.245)--(2.980,4.234)--(2.988,4.224)--(2.996,4.213)--(3.004,4.202)--(3.012,4.191)%
- --(3.019,4.180)--(3.027,4.169)--(3.035,4.158)--(3.043,4.148)--(3.051,4.137)--(3.058,4.126)%
- --(3.066,4.115)--(3.074,4.106)--(3.082,4.095)--(3.090,4.084)--(3.097,4.073)--(3.105,4.064)%
- --(3.113,4.053)--(3.121,4.042)--(3.129,4.031)--(3.137,4.022)--(3.144,4.011)--(3.152,4.002)%
- --(3.160,3.991)--(3.168,3.980)--(3.176,3.970)--(3.183,3.960)--(3.191,3.950)--(3.199,3.939)%
- --(3.207,3.930)--(3.215,3.919)--(3.222,3.910)--(3.230,3.901)--(3.238,3.890)--(3.246,3.880)%
- --(3.254,3.870)--(3.261,3.860)--(3.269,3.851)--(3.277,3.840)--(3.285,3.831)--(3.293,3.821)%
- --(3.301,3.812)--(3.308,3.801)--(3.316,3.792)--(3.324,3.783)--(3.332,3.773)--(3.340,3.764)%
- --(3.347,3.755)--(3.355,3.744)--(3.363,3.734)--(3.371,3.725)--(3.379,3.716)--(3.386,3.706)%
- --(3.394,3.697)--(3.402,3.688)--(3.410,3.679)--(3.418,3.669)--(3.426,3.660)--(3.433,3.651)%
- --(3.441,3.641)--(3.449,3.633)--(3.457,3.624)--(3.465,3.615)--(3.472,3.606)--(3.480,3.596)%
- --(3.488,3.587)--(3.496,3.579)--(3.504,3.570)--(3.511,3.560)--(3.519,3.551)--(3.527,3.543)%
- --(3.535,3.534)--(3.543,3.525)--(3.550,3.515)--(3.558,3.508)--(3.566,3.498)--(3.574,3.491)%
- --(3.582,3.481)--(3.590,3.472)--(3.597,3.464)--(3.605,3.455)--(3.613,3.447)--(3.621,3.438)%
- --(3.629,3.430)--(3.636,3.421)--(3.644,3.413)--(3.652,3.404)--(3.660,3.396)--(3.668,3.387)%
- --(3.675,3.379)--(3.683,3.371)--(3.691,3.362)--(3.699,3.354)--(3.707,3.346)--(3.715,3.337)%
- --(3.722,3.329)--(3.730,3.321)--(3.738,3.312)--(3.746,3.304)--(3.754,3.296)--(3.761,3.289)%
- --(3.769,3.281)--(3.777,3.272)--(3.785,3.264)--(3.793,3.256)--(3.800,3.248)--(3.808,3.241)%
- --(3.816,3.233)--(3.824,3.225)--(3.832,3.216)--(3.839,3.208)--(3.847,3.200)--(3.855,3.192)%
- --(3.863,3.185)--(3.871,3.177)--(3.879,3.169)--(3.886,3.161)--(3.894,3.154)--(3.902,3.146)%
- --(3.910,3.138)--(3.918,3.132)--(3.925,3.124)--(3.933,3.116)--(3.941,3.109)--(3.949,3.101)%
- --(3.957,3.093)--(3.964,3.085)--(3.972,3.079)--(3.980,3.071)--(3.988,3.064)--(3.996,3.056)%
- --(4.004,3.048)--(4.011,3.042)--(4.019,3.034)--(4.027,3.026)--(4.035,3.020)--(4.043,3.012)%
- --(4.050,3.005)--(4.058,2.998)--(4.066,2.991)--(4.074,2.983)--(4.082,2.977)--(4.089,2.969)%
- --(4.097,2.963)--(4.105,2.955)--(4.113,2.947)--(4.121,2.941)--(4.128,2.933)--(4.136,2.927)%
- --(4.144,2.919)--(4.152,2.913)--(4.160,2.905)--(4.168,2.899)--(4.175,2.891)--(4.183,2.885)%
- --(4.191,2.879)--(4.199,2.871)--(4.207,2.865)--(4.214,2.857)--(4.222,2.851)--(4.230,2.845)%
- --(4.238,2.837)--(4.246,2.831)--(4.253,2.824)--(4.261,2.817)--(4.269,2.810)--(4.277,2.804)%
- --(4.285,2.798)--(4.293,2.790)--(4.300,2.784)--(4.308,2.778)--(4.316,2.772)--(4.324,2.764)%
- --(4.332,2.758)--(4.339,2.751)--(4.347,2.745)--(4.355,2.739)--(4.363,2.733)--(4.371,2.727)%
- --(4.378,2.719)--(4.386,2.713)--(4.394,2.706)--(4.402,2.700)--(4.410,2.694)--(4.417,2.688)%
- --(4.425,2.681)--(4.433,2.675)--(4.441,2.669)--(4.449,2.663)--(4.457,2.657)--(4.464,2.650)%
- --(4.472,2.644)--(4.480,2.638)--(4.488,2.632)--(4.496,2.626)--(4.503,2.619)--(4.511,2.613)%
- --(4.519,2.608)--(4.527,2.602)--(4.535,2.596)--(4.542,2.590)--(4.550,2.584)--(4.558,2.577)%
- --(4.566,2.571)--(4.574,2.567)--(4.581,2.560)--(4.589,2.554)--(4.597,2.548)--(4.605,2.542)%
- --(4.613,2.537)--(4.621,2.531)--(4.628,2.525)--(4.636,2.520)--(4.644,2.514)--(4.652,2.508)%
- --(4.660,2.501)--(4.667,2.497)--(4.675,2.490)--(4.683,2.484)--(4.691,2.480)--(4.699,2.473)%
- --(4.706,2.469)--(4.714,2.463)--(4.722,2.456)--(4.730,2.452)--(4.738,2.445)--(4.746,2.441)%
- --(4.753,2.435)--(4.761,2.430)--(4.769,2.424)--(4.777,2.417)--(4.785,2.413)--(4.792,2.407)%
- --(4.800,2.402)--(4.808,2.396)--(4.816,2.391)--(4.824,2.386)--(4.831,2.380)--(4.839,2.376)%
- --(4.847,2.369)--(4.855,2.365)--(4.863,2.358)--(4.870,2.354)--(4.878,2.349)--(4.886,2.343)%
- --(4.894,2.338)--(4.902,2.334)--(4.910,2.327)--(4.917,2.323)--(4.925,2.318)--(4.933,2.312)%
- --(4.941,2.307)--(4.949,2.303)--(4.956,2.296)--(4.964,2.292)--(4.972,2.287)--(4.980,2.282)%
- --(4.988,2.276)--(4.995,2.271)--(5.003,2.267)--(5.011,2.262)--(5.019,2.256)--(5.027,2.251)%
- --(5.035,2.247)--(5.042,2.242)--(5.050,2.237)--(5.058,2.233)--(5.066,2.226)--(5.074,2.222)%
- --(5.081,2.217)--(5.089,2.212)--(5.097,2.208)--(5.105,2.203)--(5.113,2.199)--(5.120,2.194)%
- --(5.128,2.189)--(5.136,2.183)--(5.144,2.178)--(5.152,2.174)--(5.159,2.169)--(5.167,2.164)%
- --(5.175,2.160)--(5.183,2.155)--(5.191,2.150)--(5.199,2.146)--(5.206,2.141)--(5.214,2.136)%
- --(5.222,2.132)--(5.230,2.127)--(5.238,2.122)--(5.245,2.119)--(5.253,2.115)--(5.261,2.110)%
- --(5.269,2.105)--(5.277,2.101)--(5.284,2.096)--(5.292,2.091)--(5.300,2.087)--(5.308,2.082)%
- --(5.316,2.079)--(5.324,2.074)--(5.331,2.070)--(5.339,2.065)--(5.347,2.060)--(5.355,2.056)%
- --(5.363,2.053)--(5.370,2.048)--(5.378,2.043)--(5.386,2.039)--(5.394,2.034)--(5.402,2.031)%
- --(5.409,2.026)--(5.417,2.021)--(5.425,2.017)--(5.433,2.014)--(5.441,2.009)--(5.448,2.004)%
- --(5.456,2.001)--(5.464,1.997)--(5.472,1.992)--(5.480,1.987)--(5.488,1.984)--(5.495,1.980)%
- --(5.503,1.975)--(5.511,1.972)--(5.519,1.967)--(5.527,1.964)--(5.534,1.959)--(5.542,1.955)%
- --(5.550,1.952)--(5.558,1.947)--(5.566,1.944)--(5.573,1.939)--(5.581,1.934)--(5.589,1.931)%
- --(5.597,1.927)--(5.605,1.924)--(5.613,1.919)--(5.620,1.916)--(5.628,1.911)--(5.636,1.908)%
- --(5.644,1.903)--(5.652,1.899)--(5.659,1.896)--(5.667,1.893)--(5.675,1.888)--(5.683,1.885)%
- --(5.691,1.880)--(5.698,1.877)--(5.706,1.872)--(5.714,1.869)--(5.722,1.865)--(5.730,1.862)%
- --(5.737,1.857)--(5.745,1.854)--(5.753,1.851)--(5.761,1.846)--(5.769,1.843)--(5.777,1.838)%
- --(5.784,1.835)--(5.792,1.832)--(5.800,1.827)--(5.808,1.824)--(5.816,1.821)--(5.823,1.816)%
- --(5.831,1.813)--(5.839,1.810)--(5.847,1.806)--(5.855,1.802)--(5.862,1.799)--(5.870,1.795)%
- --(5.878,1.792)--(5.886,1.789)--(5.894,1.784)--(5.902,1.781)--(5.909,1.778)--(5.917,1.775)%
- --(5.925,1.770)--(5.933,1.767)--(5.941,1.764)--(5.948,1.761)--(5.956,1.756)--(5.964,1.753)%
- --(5.972,1.750)--(5.980,1.747)--(5.987,1.743)--(5.995,1.739)--(6.003,1.736)--(6.011,1.733)%
- --(6.019,1.730)--(6.026,1.726)--(6.034,1.722)--(6.042,1.719)--(6.050,1.716)--(6.058,1.712)%
- --(6.066,1.709)--(6.073,1.706)--(6.081,1.703)--(6.089,1.698)--(6.097,1.695)--(6.105,1.692)%
- --(6.112,1.689)--(6.120,1.686)--(6.128,1.683)--(6.136,1.680)--(6.144,1.677)--(6.151,1.674)%
- --(6.159,1.670)--(6.167,1.667)--(6.175,1.664)--(6.183,1.661)--(6.191,1.658)--(6.198,1.655)%
- --(6.206,1.652)--(6.214,1.647)--(6.222,1.644)--(6.230,1.641)--(6.237,1.638)--(6.245,1.635)%
- --(6.253,1.632)--(6.261,1.630)--(6.269,1.627)--(6.276,1.624)--(6.284,1.621)--(6.292,1.618)%
- --(6.300,1.615)--(6.308,1.611)--(6.315,1.608)--(6.323,1.605)--(6.331,1.602)--(6.339,1.599)%
- --(6.347,1.596)--(6.355,1.593)--(6.362,1.590)--(6.370,1.587)--(6.378,1.585)--(6.386,1.582)%
- --(6.394,1.579)--(6.401,1.576)--(6.409,1.573)--(6.417,1.570)--(6.425,1.566)--(6.433,1.563)%
- --(6.440,1.562)--(6.448,1.559)--(6.456,1.556)--(6.464,1.552)--(6.472,1.549)--(6.480,1.546)%
- --(6.487,1.545)--(6.495,1.542)--(6.503,1.538)--(6.511,1.535)--(6.519,1.532)--(6.526,1.531)%
- --(6.534,1.528)--(6.542,1.525)--(6.550,1.521)--(6.558,1.520)--(6.565,1.517)--(6.573,1.514)%
- --(6.581,1.511)--(6.589,1.509)--(6.597,1.506)--(6.604,1.503)--(6.612,1.500)--(6.620,1.498)%
- --(6.628,1.495)--(6.636,1.492)--(6.644,1.489)--(6.651,1.487)--(6.659,1.484)--(6.667,1.481)%
- --(6.675,1.479)--(6.683,1.476)--(6.690,1.473)--(6.698,1.472)--(6.706,1.469)--(6.714,1.465)%
- --(6.722,1.464)--(6.729,1.461)--(6.737,1.458)--(6.745,1.456)--(6.753,1.453)--(6.761,1.450)%
- --(6.768,1.448)--(6.776,1.445)--(6.784,1.444)--(6.792,1.441)--(6.800,1.438)--(6.808,1.436)%
- --(6.815,1.433)--(6.823,1.431)--(6.831,1.428)--(6.839,1.425)--(6.847,1.424)--(6.854,1.420)%
- --(6.862,1.419)--(6.870,1.416)--(6.878,1.414)--(6.886,1.411)--(6.893,1.408)--(6.901,1.406)%
- --(6.909,1.403)--(6.917,1.402)--(6.925,1.399)--(6.933,1.397)--(6.940,1.394)--(6.948,1.393)%
- --(6.956,1.389)--(6.964,1.388)--(6.972,1.385)--(6.979,1.383)--(6.987,1.380)--(6.995,1.379)%
- --(7.003,1.375)--(7.011,1.374)--(7.018,1.371)--(7.026,1.369)--(7.034,1.366)--(7.042,1.365)%
- --(7.050,1.361)--(7.057,1.360)--(7.065,1.358)--(7.073,1.355)--(7.081,1.354)--(7.089,1.351)%
- --(7.097,1.349)--(7.104,1.346)--(7.112,1.344)--(7.120,1.343)--(7.128,1.340)--(7.136,1.338)%
- --(7.143,1.335)--(7.151,1.333)--(7.159,1.332)--(7.167,1.329)--(7.175,1.327)--(7.182,1.324)%
- --(7.190,1.323)--(7.198,1.321)--(7.206,1.318)--(7.214,1.316)--(7.222,1.313)--(7.229,1.312)%
- --(7.237,1.310)--(7.245,1.307)--(7.253,1.306)--(7.261,1.304)--(7.268,1.301)--(7.276,1.299)%
- --(7.284,1.298)--(7.292,1.295)--(7.300,1.293)--(7.307,1.292)--(7.315,1.288)--(7.323,1.287)%
- --(7.331,1.285)--(7.339,1.284)--(7.346,1.281)--(7.354,1.279)--(7.362,1.278)--(7.370,1.274)%
- --(7.378,1.273)--(7.386,1.271)--(7.393,1.268)--(7.401,1.267)--(7.409,1.265)--(7.417,1.264)%
- --(7.425,1.260)--(7.432,1.259)--(7.440,1.257)--(7.448,1.256)--(7.456,1.253)--(7.464,1.251)%
- --(7.471,1.250)--(7.479,1.248)--(7.487,1.245)--(7.495,1.243)--(7.503,1.242)--(7.511,1.240)%
- --(7.518,1.239)--(7.526,1.236)--(7.534,1.234)--(7.542,1.233)--(7.550,1.231)--(7.557,1.229)%
- --(7.565,1.226)--(7.573,1.225)--(7.581,1.223)--(7.589,1.222)--(7.596,1.220)--(7.604,1.217)%
- --(7.612,1.215)--(7.620,1.214)--(7.628,1.212)--(7.635,1.211)--(7.643,1.209)--(7.651,1.206)%
- --(7.659,1.205)--(7.667,1.203)--(7.675,1.201)--(7.682,1.200)--(7.690,1.198)--(7.698,1.197)%
- --(7.706,1.194)--(7.714,1.192)--(7.721,1.191)--(7.729,1.189)--(7.737,1.188)--(7.745,1.186)%
- --(7.753,1.184)--(7.760,1.183)--(7.768,1.181)--(7.776,1.178)--(7.784,1.177)--(7.792,1.175)%
- --(7.800,1.174)--(7.807,1.172)--(7.815,1.170)--(7.823,1.169)--(7.831,1.167)--(7.839,1.166)%
- --(7.846,1.164)--(7.854,1.163)--(7.862,1.161)--(7.870,1.160)--(7.878,1.156)--(7.885,1.155)%
- --(7.893,1.153)--(7.901,1.152)--(7.909,1.150)--(7.917,1.149)--(7.924,1.147)--(7.932,1.146)%
- --(7.940,1.144)--(7.948,1.142)--(7.956,1.141)--(7.964,1.139)--(7.971,1.138)--(7.979,1.136)%
- --(7.987,1.135)--(7.995,1.133)--(8.003,1.132)--(8.010,1.130)--(8.018,1.128)--(8.026,1.127)%
- --(8.034,1.125)--(8.042,1.124)--(8.049,1.122)--(8.057,1.121)--(8.065,1.119)--(8.073,1.118)%
- --(8.081,1.116)--(8.089,1.115)--(8.096,1.113)--(8.104,1.111)--(8.112,1.110)--(8.120,1.108)%
- --(8.128,1.107)--(8.135,1.105)--(8.143,1.104)--(8.151,1.102)--(8.159,1.101)--(8.167,1.101)%
- --(8.174,1.099)--(8.182,1.097)--(8.190,1.096)--(8.198,1.094)--(8.206,1.093)--(8.213,1.091)%
- --(8.221,1.090)--(8.229,1.088)--(8.237,1.087)--(8.245,1.085)--(8.253,1.083)--(8.260,1.082)%
- --(8.268,1.080)--(8.276,1.080)--(8.284,1.079)--(8.292,1.077)--(8.299,1.076)--(8.307,1.074)%
- --(8.315,1.073)--(8.323,1.071)--(8.331,1.069)--(8.338,1.068)--(8.346,1.068)--(8.354,1.066)%
- --(8.362,1.065)--(8.370,1.063)--(8.378,1.062)--(8.385,1.060)--(8.393,1.059)--(8.401,1.057)%
- --(8.409,1.057)--(8.417,1.055)--(8.424,1.054)--(8.432,1.052)--(8.440,1.051)--(8.448,1.049)%
- --(8.456,1.048)--(8.463,1.048)--(8.471,1.046)--(8.479,1.045)--(8.487,1.043)--(8.495,1.042)%
- --(8.502,1.040)--(8.510,1.040)--(8.518,1.038)--(8.526,1.037)--(8.534,1.035)--(8.542,1.034)%
- --(8.549,1.034)--(8.557,1.032)--(8.565,1.031)--(8.573,1.029)--(8.581,1.028)--(8.588,1.026)%
- --(8.596,1.026)--(8.604,1.024)--(8.612,1.023)--(8.620,1.021)--(8.627,1.021)--(8.635,1.020)%
- --(8.643,1.018)--(8.651,1.017)--(8.659,1.015)--(8.667,1.015)--(8.674,1.014)--(8.682,1.012)%
- --(8.690,1.010)--(8.698,1.010)--(8.706,1.009)--(8.713,1.007)--(8.721,1.006)--(8.729,1.004)%
- --(8.737,1.004)--(8.745,1.003)--(8.752,1.001)--(8.760,1.000)--(8.768,1.000)--(8.776,0.998)%
- --(8.784,0.996)--(8.791,0.995)--(8.799,0.995)--(8.807,0.993)--(8.815,0.992)--(8.823,0.992)%
- --(8.831,0.990)--(8.838,0.989)--(8.846,0.987)--(8.854,0.987)--(8.862,0.986)--(8.870,0.984)%
- --(8.877,0.983)--(8.885,0.983)--(8.893,0.981)--(8.901,0.979)--(8.909,0.979)--(8.916,0.978)%
- --(8.924,0.976)--(8.932,0.975)--(8.940,0.975)--(8.948,0.973)--(8.955,0.972)--(8.963,0.972)%
- --(8.971,0.970)--(8.979,0.969)--(8.987,0.969)--(8.995,0.967)--(9.002,0.965)--(9.010,0.965)%
- --(9.018,0.964)--(9.026,0.962)--(9.034,0.962)--(9.041,0.961)--(9.049,0.959)--(9.057,0.959)%
- --(9.065,0.958)--(9.073,0.956)--(9.080,0.956)--(9.088,0.955)--(9.096,0.953)--(9.104,0.953)%
- --(9.112,0.951)--(9.120,0.950)--(9.127,0.950)--(9.135,0.948)--(9.143,0.947)--(9.151,0.947)%
- --(9.159,0.945)--(9.166,0.944)--(9.174,0.944)--(9.182,0.942)--(9.190,0.941)--(9.198,0.941)%
- --(9.205,0.939)--(9.213,0.939)--(9.221,0.937)--(9.229,0.936)--(9.237,0.936)--(9.244,0.934)%
- --(9.252,0.933)--(9.260,0.933)--(9.268,0.931)--(9.276,0.931)--(9.284,0.930)--(9.291,0.928)%
- --(9.299,0.928)--(9.307,0.927)--(9.315,0.927)--(9.323,0.925)--(9.330,0.923)--(9.338,0.923)%
- --(9.346,0.922)--(9.354,0.922)--(9.362,0.920)--(9.369,0.919)--(9.377,0.919)--(9.385,0.917)%
- --(9.393,0.917)--(9.401,0.916)--(9.409,0.914)--(9.416,0.914)--(9.424,0.913)--(9.432,0.913)%
- --(9.440,0.911)--(9.448,0.911)--(9.455,0.910)--(9.463,0.908)--(9.471,0.908)--(9.479,0.906)%
- --(9.487,0.906)--(9.494,0.905)--(9.502,0.905)--(9.510,0.903)--(9.518,0.902)--(9.526,0.902)%
- --(9.533,0.900)--(9.541,0.900)--(9.549,0.899)--(9.557,0.899)--(9.565,0.897)--(9.573,0.897)%
- --(9.580,0.896)--(9.588,0.894)--(9.596,0.894)--(9.604,0.892)--(9.612,0.892)--(9.619,0.891)%
- --(9.627,0.891)--(9.635,0.889)--(9.643,0.889)--(9.651,0.888)--(9.658,0.888)--(9.666,0.886)%
- --(9.674,0.886)--(9.682,0.885)--(9.690,0.885)--(9.698,0.883)--(9.705,0.882)--(9.713,0.882)%
- --(9.721,0.880)--(9.729,0.880)--(9.737,0.878)--(9.744,0.878)--(9.752,0.877)--(9.760,0.877)%
- --(9.768,0.875)--(9.776,0.875)--(9.783,0.874)--(9.791,0.874)--(9.799,0.872)--(9.807,0.872)%
- --(9.815,0.871)--(9.822,0.871)--(9.830,0.869)--(9.838,0.869)--(9.846,0.868)--(9.854,0.868)%
- --(9.862,0.866)--(9.869,0.866)--(9.877,0.864)--(9.885,0.864)--(9.893,0.863)--(9.901,0.863)%
- --(9.908,0.861)--(9.916,0.861)--(9.924,0.861)--(9.932,0.860)--(9.940,0.860)--(9.947,0.858)%
- --(9.955,0.858)--(9.963,0.857)--(9.971,0.857)--(9.979,0.855)--(9.987,0.855)--(9.994,0.854)%
- --(10.002,0.854)--(10.010,0.852)--(10.018,0.852)--(10.026,0.851)--(10.033,0.851)--(10.041,0.851)%
- --(10.049,0.849)--(10.057,0.849)--(10.065,0.847)--(10.072,0.847)--(10.080,0.846)--(10.088,0.846)%
- --(10.096,0.844)--(10.104,0.844)--(10.111,0.843)--(10.119,0.843)--(10.127,0.843)--(10.135,0.841)%
- --(10.143,0.841)--(10.151,0.840)--(10.158,0.840)--(10.166,0.838)--(10.174,0.838)--(10.182,0.838)%
- --(10.190,0.837)--(10.197,0.837)--(10.205,0.835)--(10.213,0.835)--(10.221,0.833)--(10.229,0.833)%
- --(10.236,0.833)--(10.244,0.832)--(10.252,0.832)--(10.260,0.830)--(10.268,0.830)--(10.276,0.829)%
- --(10.283,0.829)--(10.291,0.829)--(10.299,0.827)--(10.307,0.827)--(10.315,0.826)--(10.322,0.826)%
- --(10.330,0.826)--(10.338,0.824)--(10.346,0.824)--(10.354,0.823)--(10.361,0.823)--(10.369,0.823)%
- --(10.377,0.821)--(10.385,0.821)--(10.393,0.819)--(10.400,0.819)--(10.408,0.819)--(10.416,0.818)%
- --(10.424,0.818)--(10.432,0.816)--(10.440,0.816)--(10.447,0.816)--(10.455,0.815)--(10.463,0.815)%
- --(10.471,0.813)--(10.479,0.813)--(10.486,0.813)--(10.494,0.812)--(10.502,0.812)--(10.510,0.812)%
- --(10.518,0.810)--(10.525,0.810)--(10.533,0.809)--(10.541,0.809)--(10.549,0.809)--(10.557,0.807)%
- --(10.565,0.807)--(10.572,0.805)--(10.580,0.805)--(10.588,0.805)--(10.596,0.804)--(10.604,0.804)%
- --(10.611,0.804)--(10.619,0.802)--(10.627,0.802)--(10.635,0.802)--(10.643,0.801)--(10.650,0.801)%
- --(10.658,0.799)--(10.666,0.799)--(10.674,0.799)--(10.682,0.798)--(10.689,0.798)--(10.697,0.798)%
- --(10.705,0.796)--(10.713,0.796)--(10.721,0.796)--(10.729,0.795)--(10.736,0.795)--(10.744,0.795)%
- --(10.752,0.793)--(10.760,0.793)--(10.768,0.793)--(10.775,0.791)--(10.783,0.791)--(10.791,0.791)%
- --(10.799,0.790)--(10.807,0.790)--(10.814,0.790)--(10.822,0.788)--(10.830,0.788)--(10.838,0.788)%
- --(10.846,0.787)--(10.854,0.787)--(10.861,0.787)--(10.869,0.785)--(10.877,0.785)--(10.885,0.785)%
- --(10.893,0.784)--(10.900,0.784)--(10.908,0.784)--(10.916,0.782)--(10.924,0.782)--(10.932,0.782)%
- --(10.939,0.781)--(10.947,0.781)--(10.955,0.781)--(10.963,0.779)--(10.971,0.779)--(10.978,0.779)%
- --(10.986,0.778)--(10.994,0.778)--(11.002,0.778)--(11.010,0.776)--(11.018,0.776)--(11.025,0.776)%
- --(11.033,0.774)--(11.041,0.774)--(11.049,0.774)--(11.057,0.774)--(11.064,0.773)--(11.072,0.773)%
- --(11.080,0.773)--(11.088,0.771)--(11.096,0.771)--(11.103,0.771)--(11.111,0.770)--(11.119,0.770)%
- --(11.127,0.770)--(11.135,0.768)--(11.142,0.768)--(11.150,0.768)--(11.158,0.768)--(11.166,0.767)%
- --(11.174,0.767)--(11.182,0.767)--(11.189,0.765)--(11.197,0.765)--(11.205,0.765)--(11.213,0.765)%
- --(11.221,0.764)--(11.228,0.764)--(11.236,0.764)--(11.244,0.762)--(11.252,0.762)--(11.260,0.762)%
- --(11.267,0.762)--(11.275,0.760)--(11.283,0.760)--(11.291,0.760)--(11.299,0.759)--(11.307,0.759)%
- --(11.314,0.759)--(11.322,0.759)--(11.330,0.757)--(11.338,0.757)--(11.346,0.757);
-\gpcolor{color=gp lt color border}
-\draw[gp path] (1.012,8.381)--(1.012,0.616)--(11.947,0.616)--(11.947,8.381)--cycle;
-%% coordinates of the plot area
-\gpdefrectangularnode{gp plot 1}{\pgfpoint{1.012cm}{0.616cm}}{\pgfpoint{11.947cm}{8.381cm}}
-\end{tikzpicture}
-%% gnuplot variables
diff --git a/20221121/logo-hochschule-bochum-cvh-text-v2.pdf b/20221121/logo-hochschule-bochum-cvh-text-v2.pdf
deleted file mode 120000
index 4aa99b8f81061aca6dcaf43eed2d9efef40555f8..0000000000000000000000000000000000000000
--- a/20221121/logo-hochschule-bochum-cvh-text-v2.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
diff --git a/20221121/logo-hochschule-bochum.pdf b/20221121/logo-hochschule-bochum.pdf
deleted file mode 120000
index b6b9491e370e499c9276918182cdb82cb311bcd1..0000000000000000000000000000000000000000
--- a/20221121/logo-hochschule-bochum.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20221121/names.h b/20221121/names.h
deleted file mode 100644
index a265ff4141a2cc578d3f6f402822a2dbbd5cea90..0000000000000000000000000000000000000000
--- a/20221121/names.h
+++ /dev/null
@@ -1,50 +0,0 @@
-"Michael", "Laura",
-"Elias", "Julia",
-"Luca", "Anna",
-"Liam", "Emma",
-"Alexander", "Lena",
-"Noah", "Vanessa",
-"Jonas", "Lea",
-"Marcel", "Mila",
-"Daniel", "Lisa",
-"David", "Lina",
-"Milan", "Sarah",
-"Julian", "Alina",
-"Linus", "Emilia",
-"Thomas", "Nina",
-"Samuel", "Elena",
-"Levin", "Lara",
-"Levi", "Melanie",
-"Jan", "Hannah",
-"Lukas", "Sandra",
-"Tim", "Leonie",
-"Patrick", "Sophie",
-"Marvin", "Mia",
-"Andreas", "Amelie",
-"Leon", "Selina",
-"Tobias", "Luisa",
-"Simon", "Maria",
-"Valentin", "Jana",
-"Robin", "Johanna",
-"Paul", "Marie",
-"Markus", "Milena",
-"Benjamin", "Melina",
-"Stefan", "Michelle",
-"Felix", "Emily",
-"Florian", "Renesmee",
-"Fabian", "Aylin",
-"Emil", "Jessica",
-"Aaron", "Franziska",
-"Manuel", "Jasmin",
-"Christian", "Fiona",
-"Dominik", "Sina",
-"Joshua", "Jennifer",
-"Moritz", "Claudia",
-"Sebastian", "Nicole",
-"Peter", "Annika",
-"Philipp", "Sophia",
-"Max", "Katharina",
-"Johannes", "Isabella",
-"Finn", "Nele",
-"Adrian", "Elisabeth",
-"Martin", "Pia",
diff --git a/20221121/pendulum.pdf b/20221121/pendulum.pdf
deleted file mode 120000
index 7d1d87305cdb8840a248ff2207538d758464f452..0000000000000000000000000000000000000000
--- a/20221121/pendulum.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/pendulum.pdf
\ No newline at end of file
diff --git a/20221121/pgscript.sty b/20221121/pgscript.sty
deleted file mode 120000
index 95c888478c99ea7fda0fd11ccf669ae91be7178b..0000000000000000000000000000000000000000
--- a/20221121/pgscript.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgscript.sty
\ No newline at end of file
diff --git a/20221121/pgslides.sty b/20221121/pgslides.sty
deleted file mode 120000
index 5be1416f4216f076aa268901f52a15d775e43f64..0000000000000000000000000000000000000000
--- a/20221121/pgslides.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgslides.sty
\ No newline at end of file
diff --git a/20221121/qsort-1.c b/20221121/qsort-1.c
deleted file mode 100644
index c5431b853862e62812016f4fd3a031eeb0b5c9df..0000000000000000000000000000000000000000
--- a/20221121/qsort-1.c
+++ /dev/null
@@ -1,70 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, char *pivot, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (name[i] == pivot)
- printf (" <==");
- else if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, char *pivot, int left, int right)
-{
- int result = strcmp (name[left], pivot);
- comparisons++;
- display (name, pivot, left, right);
- usleep (200000);
- return result;
-}
-
-void quicksort (char **name, int left, int right)
-{
- int p = (left + right) / 2;
- char *pivot = name[p];
- int l = left;
- int r = right;
- while (l < r)
- {
- while (l < r && compare (name, pivot, l, r - 1) < 0)
- l++;
- while (l < r && compare (name, pivot, r - 1, l) > 0)
- r--;
- if (l < r)
- {
- char *temp = name[r - 1];
- name[r - 1] = name[l];
- name[l] = temp;
- l++;
- r--;
- }
- }
-}
-
-void sort (char **name)
-{
- int r = 0;
- while (name[r])
- r++;
- quicksort (name, 0, r);
-}
-
-int main (void)
-{
- char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
- "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
- "Thomas", "Ulrich", "Zacharias", NULL };
- sort (name);
- display (name, NULL, -1, -1);
- return 0;
-}
diff --git a/20221121/qsort-1a.c b/20221121/qsort-1a.c
deleted file mode 100644
index a3d4d0011834aa3d85907c2a0d0e90e3bf80799e..0000000000000000000000000000000000000000
--- a/20221121/qsort-1a.c
+++ /dev/null
@@ -1,70 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, char *pivot, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (name[i] == pivot)
- printf (" <==");
- else if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, char *pivot, int left, int right)
-{
- int result = strcmp (name[left], pivot);
- comparisons++;
- display (name, pivot, left, right);
- usleep (200000);
- return result;
-}
-
-void quicksort (char **name, int left, int right)
-{
- int p = (left + right) / 2 - 1;
- char *pivot = name[p];
- int l = left;
- int r = right;
- while (l < r)
- {
- while (l < r && compare (name, pivot, l, r - 1) < 0)
- l++;
- while (l < r && compare (name, pivot, r - 1, l) > 0)
- r--;
- if (l < r)
- {
- char *temp = name[r - 1];
- name[r - 1] = name[l];
- name[l] = temp;
- l++;
- r--;
- }
- }
-}
-
-void sort (char **name)
-{
- int r = 0;
- while (name[r])
- r++;
- quicksort (name, 0, r);
-}
-
-int main (void)
-{
- char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
- "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
- "Thomas", "Ulrich", "Zacharias", NULL };
- sort (name);
- display (name, NULL, -1, -1);
- return 0;
-}
diff --git a/20221121/qsort-2.c b/20221121/qsort-2.c
deleted file mode 100644
index cfdc2ec11a92a4292c9443e01453cce818e9e73a..0000000000000000000000000000000000000000
--- a/20221121/qsort-2.c
+++ /dev/null
@@ -1,72 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, char *pivot, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (name[i] == pivot)
- printf (" <==");
- else if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, char *pivot, int left, int right)
-{
- int result = strcmp (name[left], pivot);
- comparisons++;
- display (name, pivot, left, right);
- usleep (200000);
- return result;
-}
-
-void quicksort (char **name, int left, int right)
-{
- int p = (left + right) / 2;
- char *pivot = name[p];
- int l = left;
- int r = right;
- while (l < r)
- {
- while (l < r && compare (name, pivot, l, r - 1) < 0)
- l++;
- while (l < r && compare (name, pivot, r - 1, l) > 0)
- r--;
- if (l < r)
- {
- char *temp = name[r - 1];
- name[r - 1] = name[l];
- name[l] = temp;
- l++;
- r--;
- }
- }
- if (l < right)
- quicksort (name, l, right);
-}
-
-void sort (char **name)
-{
- int r = 0;
- while (name[r])
- r++;
- quicksort (name, 0, r);
-}
-
-int main (void)
-{
- char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
- "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
- "Thomas", "Ulrich", "Zacharias", NULL };
- sort (name);
- display (name, NULL, -1, -1);
- return 0;
-}
diff --git a/20221121/qsort-3.c b/20221121/qsort-3.c
deleted file mode 100644
index e6b7d9909473af6d8c13d3745dc6b07e8ea75699..0000000000000000000000000000000000000000
--- a/20221121/qsort-3.c
+++ /dev/null
@@ -1,74 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, char *pivot, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (name[i] == pivot)
- printf (" <==");
- else if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, char *pivot, int left, int right)
-{
- int result = strcmp (name[left], pivot);
- comparisons++;
- display (name, pivot, left, right);
- usleep (200000);
- return result;
-}
-
-void quicksort (char **name, int left, int right)
-{
- int p = (left + right) / 2;
- char *pivot = name[p];
- int l = left;
- int r = right;
- while (l < r)
- {
- while (l < r && compare (name, pivot, l, r - 1) < 0)
- l++;
- while (l < r && compare (name, pivot, r - 1, l) > 0)
- r--;
- if (l < r)
- {
- char *temp = name[r - 1];
- name[r - 1] = name[l];
- name[l] = temp;
- l++;
- r--;
- }
- }
- if (r > left)
- quicksort (name, left, r);
- if (l < right)
- quicksort (name, l, right);
-}
-
-void sort (char **name)
-{
- int r = 0;
- while (name[r])
- r++;
- quicksort (name, 0, r);
-}
-
-int main (void)
-{
- char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
- "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
- "Thomas", "Ulrich", "Zacharias", NULL };
- sort (name);
- display (name, NULL, -1, -1);
- return 0;
-}
diff --git a/20221121/qsort-3.txt b/20221121/qsort-3.txt
deleted file mode 100644
index e6db54a62799d42b0328a7ba75d80615aec5164b..0000000000000000000000000000000000000000
--- a/20221121/qsort-3.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-cassini/home/peter/bo/2022ws/hp/20221121> bc
-bc 1.07.1
-Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006, 2008, 2012-2017 Free Software Foundation, Inc.
-This is free software with ABSOLUTELY NO WARRANTY.
-For details type `warranty'.
-
-16 / 2
-8
-8 / 2
-4
-4 / 2
-2
-2 / 2
-1
-
-cassini/home/peter/bo/2022ws/hp/20221121>
diff --git a/20221121/qsort-3a.c b/20221121/qsort-3a.c
deleted file mode 100644
index ef4d709f21246b7d8e604dc56047483216f837b8..0000000000000000000000000000000000000000
--- a/20221121/qsort-3a.c
+++ /dev/null
@@ -1,74 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, char *pivot, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (name[i] == pivot)
- printf (" <==");
- else if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, char *pivot, int left, int right)
-{
- int result = strcmp (name[left], pivot);
- comparisons++;
- display (name, pivot, left, right);
- usleep (200000);
- return result;
-}
-
-void quicksort (char **name, int left, int right)
-{
- int p = (left + right) / 2;
- char *pivot = name[p];
- int l = left;
- int r = right;
- while (l < r)
- {
- while (l < r && compare (name, pivot, l, r - 1) < 0)
- l++;
- while (l < r && compare (name, pivot, r - 1, l) > 0)
- r--;
- if (l < r)
- {
- char *temp = name[r - 1];
- name[r - 1] = name[l];
- name[l] = temp;
- l++;
- r--;
- }
- }
- if (r > left)
- quicksort (name, left, r);
- if (l < right)
- quicksort (name, l, right);
-}
-
-void sort (char **name)
-{
- int r = 0;
- while (name[r])
- r++;
- quicksort (name, 0, r);
-}
-
-int main (void)
-{
- char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
- "Dieter", "Berta", "Hugo", "Maria", "Fritz", "Box", "Hans",
- "Thomas", "Ulrich", "Zacharias", NULL };
- sort (name);
- display (name, NULL, -1, -1);
- return 0;
-}
diff --git a/20221121/qsort-3b.c b/20221121/qsort-3b.c
deleted file mode 100644
index 333d7f000b82d8f7708272103ca58442c2165bc3..0000000000000000000000000000000000000000
--- a/20221121/qsort-3b.c
+++ /dev/null
@@ -1,75 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, char *pivot, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (name[i] == pivot)
- printf (" <==");
- else if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, char *pivot, int left, int right)
-{
- int result = strcmp (name[left], pivot);
- comparisons++;
-// display (name, pivot, left, right);
-// usleep (200000);
- return result;
-}
-
-void quicksort (char **name, int left, int right)
-{
- int p = (left + right) / 2;
- char *pivot = name[p];
- int l = left;
- int r = right;
- while (l < r)
- {
- while (l < r && compare (name, pivot, l, r - 1) < 0)
- l++;
- while (l < r && compare (name, pivot, r - 1, l) > 0)
- r--;
- if (l < r)
- {
- char *temp = name[r - 1];
- name[r - 1] = name[l];
- name[l] = temp;
- l++;
- r--;
- }
- }
- if (r > left)
- quicksort (name, left, r);
- if (l < right)
- quicksort (name, l, right);
-}
-
-void sort (char **name)
-{
- int r = 0;
- while (name[r])
- r++;
- quicksort (name, 0, r);
-}
-
-int main (void)
-{
- char *name[] = {
- #include "names.h"
- NULL
- };
- sort (name);
- display (name, NULL, -1, -1);
- return 0;
-}
diff --git a/20221121/qsort-3b.txt b/20221121/qsort-3b.txt
deleted file mode 100644
index 9b48b9628ed885419183ba3b4d786e8754b7fc9e..0000000000000000000000000000000000000000
--- a/20221121/qsort-3b.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-cassini/home/peter/bo/2022ws/hp/20221121> ./sort-6 | tail -1
-4950
-cassini/home/peter/bo/2022ws/hp/20221121> ./bsort-4c | tail -1
-4792
-cassini/home/peter/bo/2022ws/hp/20221121> ./qsort-3b | tail -1
-1130
diff --git a/20221121/sort-0.c b/20221121/sort-0.c
deleted file mode 100644
index 70e0e717cbfd42a27bf90f419c216fa18b0783c7..0000000000000000000000000000000000000000
--- a/20221121/sort-0.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <stdio.h>
-
-int find_first (char **name)
-{
- return 2;
-}
-
-int main (void)
-{
- char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
- "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
- "Thomas", "Ulrich", "Zacharias", NULL };
- int first = find_first (name);
- printf ("%s\n", name[first]);
- return 0;
-}
diff --git a/20221121/sort-1.c b/20221121/sort-1.c
deleted file mode 100644
index 3f009d45657f84e462db48a67fa22821819216ad..0000000000000000000000000000000000000000
--- a/20221121/sort-1.c
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-int find_first (char **name)
-{
- int first = 0;
- for (int i = 1; name[i]; i++)
- if (strcmp (name[i], name[first]) < 0)
- first = i;
- return first;
-}
-
-int main (void)
-{
- char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
- "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
- "Thomas", "Ulrich", "Zacharias", NULL };
- int first = find_first (name);
- printf ("%s\n", name[first]);
- return 0;
-}
diff --git a/20221121/sort-2.c b/20221121/sort-2.c
deleted file mode 100644
index 638e6e2caa670ceace0a854d0827292dfcb59ca5..0000000000000000000000000000000000000000
--- a/20221121/sort-2.c
+++ /dev/null
@@ -1,46 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, int left, int right)
-{
- int result = strcmp (name[left], name[right]);
- comparisons++;
- display (name, left, right);
- usleep (200000);
- return result;
-}
-
-int find_first (char **name)
-{
- int first = 0;
- for (int i = 1; name[i]; i++)
- if (compare (name, i, first) < 0)
- first = i;
- return first;
-}
-
-int main (void)
-{
- char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
- "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
- "Thomas", "Ulrich", "Zacharias", NULL };
- int first = find_first (name);
- display (name, first, -1);
- return 0;
-}
diff --git a/20221121/sort-3.c b/20221121/sort-3.c
deleted file mode 100644
index 430a6fc0e95fcb9bc225e3572566c8d187016130..0000000000000000000000000000000000000000
--- a/20221121/sort-3.c
+++ /dev/null
@@ -1,46 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, int left, int right)
-{
- int result = strcmp (name[left], name[right]);
- comparisons++;
- display (name, left, right);
- usleep (200000);
- return result;
-}
-
-int find_first (char **name, int i0)
-{
- int first = i0;
- for (int i = i0 + 1; name[i]; i++)
- if (compare (name, i, first) < 0)
- first = i;
- return first;
-}
-
-int main (void)
-{
- char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
- "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
- "Thomas", "Ulrich", "Zacharias", NULL };
- int first = find_first (name, 0);
- display (name, first, -1);
- return 0;
-}
diff --git a/20221121/sort-4.c b/20221121/sort-4.c
deleted file mode 100644
index 19d4f416a2d30c5181ad289fe1d0dcba91ee81cf..0000000000000000000000000000000000000000
--- a/20221121/sort-4.c
+++ /dev/null
@@ -1,59 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, int left, int right)
-{
- int result = strcmp (name[left], name[right]);
- comparisons++;
- display (name, left, right);
- usleep (200000);
- return result;
-}
-
-int find_first (char **name, int i0)
-{
- int first = i0;
- for (int i = i0 + 1; name[i]; i++)
- if (compare (name, i, first) < 0)
- first = i;
- return first;
-}
-
-void sort (char **name)
-{
- int sorted = 0;
- while (name[sorted])
- {
- int first = find_first (name, sorted);
- char *temp = name[sorted];
- name[sorted] = name[first];
- name[first] = temp;
- sorted++;
- }
-}
-
-int main (void)
-{
- char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
- "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
- "Thomas", "Ulrich", "Zacharias", NULL };
- sort (name);
- display (name, -1, -1);
- return 0;
-}
diff --git a/20221121/sort-5.c b/20221121/sort-5.c
deleted file mode 100644
index f0742bc8665d0b13edf4ad4ad3fe4790c1e6b929..0000000000000000000000000000000000000000
--- a/20221121/sort-5.c
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, int left, int right)
-{
- int result = strcmp (name[left], name[right]);
- comparisons++;
- display (name, left, right);
- usleep (200);
- return result;
-}
-
-int find_first (char **name, int i0)
-{
- int first = i0;
- for (int i = i0 + 1; name[i]; i++)
- if (compare (name, i, first) < 0)
- first = i;
- return first;
-}
-
-void sort (char **name)
-{
- int sorted = 0;
- while (name[sorted])
- {
- int first = find_first (name, sorted);
- char *temp = name[sorted];
- name[sorted] = name[first];
- name[first] = temp;
- sorted++;
- }
-}
-
-int main (void)
-{
- char *name[] = {
- #include "names.h"
- NULL
- };
- sort (name);
- display (name, -1, -1);
- return 0;
-}
diff --git a/20221121/sort-6.c b/20221121/sort-6.c
deleted file mode 100644
index 94a1a16abfacda7bb728f8d3317cd00b4cf8ccde..0000000000000000000000000000000000000000
--- a/20221121/sort-6.c
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, int left, int right)
-{
- int result = strcmp (name[left], name[right]);
- comparisons++;
-// display (name, left, right);
-// usleep (200);
- return result;
-}
-
-int find_first (char **name, int i0)
-{
- int first = i0;
- for (int i = i0 + 1; name[i]; i++)
- if (compare (name, i, first) < 0)
- first = i;
- return first;
-}
-
-void sort (char **name)
-{
- int sorted = 0;
- while (name[sorted])
- {
- int first = find_first (name, sorted);
- char *temp = name[sorted];
- name[sorted] = name[first];
- name[first] = temp;
- sorted++;
- }
-}
-
-int main (void)
-{
- char *name[] = {
- #include "names.h"
- NULL
- };
- sort (name);
- display (name, -1, -1);
- return 0;
-}
diff --git a/20221121/sort-7.c b/20221121/sort-7.c
deleted file mode 100644
index 46132dd247a061dda0e5ebade9c5b818a1a74fcb..0000000000000000000000000000000000000000
--- a/20221121/sort-7.c
+++ /dev/null
@@ -1,53 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int comparisons = 0;
-
-void display (char **name, int left, int right)
-{
- printf ("\e[H\e[J");
- for (int i = 0; name[i]; i++)
- {
- printf ("%s", name[i]);
- if (i == left || i == right)
- printf (" <--");
- printf ("\n");
- }
- printf ("%d\n", comparisons);
-}
-
-int compare (char **name, int left, int right)
-{
- int result = strcmp (name[left], name[right]);
- comparisons++;
- display (name, left, right);
- usleep (200000);
- return result;
-}
-
-void sort (char **name)
-{
- int sorted = 0;
- while (name[sorted])
- {
- int first = sorted;
- for (int i = sorted + 1; name[i]; i++)
- if (compare (name, i, first) < 0)
- first = i;
- char *temp = name[sorted];
- name[sorted] = name[first];
- name[first] = temp;
- sorted++;
- }
-}
-
-int main (void)
-{
- char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter",
- "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans",
- "Thomas", "Ulrich", "Zacharias", NULL };
- sort (name);
- display (name, -1, -1);
- return 0;
-}
diff --git a/20221128/Tower_of_Hanoi.jpeg b/20221128/Tower_of_Hanoi.jpeg
deleted file mode 120000
index a1a794afda08596ffa2f46f278db53455de25b6c..0000000000000000000000000000000000000000
--- a/20221128/Tower_of_Hanoi.jpeg
+++ /dev/null
@@ -1 +0,0 @@
-../common/Tower_of_Hanoi.jpeg
\ No newline at end of file
diff --git a/20221128/aufgabe-1.c b/20221128/aufgabe-1.c
deleted file mode 100644
index 15c90561b94d5a0c1a136f0e6479d3633dc242b1..0000000000000000000000000000000000000000
--- a/20221128/aufgabe-1.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-void insert_into_string (char src, char *target, int pos)
-{
- int len = strlen (target);
- for (int i = pos; i < len; i++)
- target[i + 1] = target[i];
- target[pos] = src;
-}
-
-int main (void)
-{
- char test[100] = "Hochshule Bochum";
- insert_into_string ('c', test, 5);
- printf ("%s\n", test);
- return 0;
-}
diff --git a/20221128/aufgabe-3a.c b/20221128/aufgabe-3a.c
deleted file mode 100644
index 61b6e79400afbb8ac0609eb1b72c04b83a0fce41..0000000000000000000000000000000000000000
--- a/20221128/aufgabe-3a.c
+++ /dev/null
@@ -1,50 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- a[0]->type = WITH_WINGS;
- a[0]->name = "duck";
- a[0]->wings = 2;
-
- animal cow;
- a[1] = &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- a[1]->legs = 4;
-
- for (int i = 0; i < 2; i++)
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name,
- ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name,
- ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
-
- return 0;
-}
diff --git a/20221128/aufgabe-3b.c b/20221128/aufgabe-3b.c
deleted file mode 100644
index 2cf3b56f4540f399d3761b0de929d80a1f1de611..0000000000000000000000000000000000000000
--- a/20221128/aufgabe-3b.c
+++ /dev/null
@@ -1,50 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- a[0]->type = WITH_WINGS;
- a[0]->name = "duck";
- ((with_wings *) a[0])->wings = 2;
-
- animal cow;
- a[1] = &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- ((with_legs *) a[1])->legs = 4;
-
- for (int i = 0; i < 2; i++)
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name,
- ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name,
- ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
-
- return 0;
-}
diff --git a/20221128/dynmem-01.c b/20221128/dynmem-01.c
deleted file mode 100644
index 0ffe355084006090fc13a895516ab80938df25be..0000000000000000000000000000000000000000
--- a/20221128/dynmem-01.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-
-char *name[] = { "Anna", "Berthold", "Caesar" };
-
-int main (void)
-{
- name[3] = "Dieter";
- for (int i = 0; i < 4; i++)
- printf ("%s\n", name[i]);
- return 0;
-}
diff --git a/20221128/dynmem-02.c b/20221128/dynmem-02.c
deleted file mode 100644
index d8f71409680d6ecfd8ae175cc44aa2ab3d28fc15..0000000000000000000000000000000000000000
--- a/20221128/dynmem-02.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-int main (void)
-{
- char **name = malloc (3 * sizeof (char *)); /* Speicherplatz für 3 Zeiger anfordern */
- name[0] = "Anna";
- name[1] = "Berthold";
- name[2] = "Caesar";
- name[3] = "Dieter"; /* immer noch unzulässig */
- for (int i = 0; i < 4; i++)
- printf ("%s\n", name[i]);
- free (name);
- return 0;
-}
diff --git a/20221128/dynmem-03.c b/20221128/dynmem-03.c
deleted file mode 100644
index d4edee601a4fb7f5e796964e287f7856e78bad7a..0000000000000000000000000000000000000000
--- a/20221128/dynmem-03.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-int main (void)
-{
- char **name = malloc (3 * sizeof (char *)); /* Speicherplatz für 3 Zeiger anfordern */
- name[0] = "Anna";
- name[1] = "Berthold";
- name[2] = "Caesar";
-// name[3] = "Dieter"; /* immer noch unzulässig */
- for (int i = 0; i < 4; i++)
- printf ("%s\n", name[i]);
- free (name);
- return 0;
-}
diff --git a/20221128/dynmem-04.c b/20221128/dynmem-04.c
deleted file mode 100644
index 5b154ef182bed0c1c32c7d454a34a22a94fcb44c..0000000000000000000000000000000000000000
--- a/20221128/dynmem-04.c
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-int main (void)
-{
- char **name = malloc (3 * sizeof (char *)); /* Speicherplatz für 3 Zeiger anfordern */
- name[0] = "Anna";
- name[1] = "Berthold";
- name[2] = "Caesar";
-
- char **new_name = malloc (4 * sizeof (char *)); /* Speicherplatz für 4 Zeiger anfordern */
- for (int i = 0; i < 3; i++)
- new_name[i] = name[i];
- new_name[3] = "Dieter";
-
- free (name); /* altes Array */
- name = new_name; /* alter Zeiger zeigt auf neues Array */
-
- for (int i = 0; i < 4; i++)
- printf ("%s\n", name[i]);
- free (name);
- return 0;
-}
diff --git a/20221128/dynmem-05.c b/20221128/dynmem-05.c
deleted file mode 100644
index fc53998df034d3b3c06a87a9372be2daf9c71aae..0000000000000000000000000000000000000000
--- a/20221128/dynmem-05.c
+++ /dev/null
@@ -1,24 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-int main (void)
-{
- char **name = malloc (3 * sizeof (char *)); /* Speicherplatz für 3 Zeiger anfordern */
- name[0] = "Anna";
- name[1] = "Berthold";
- name[2] = "Caesar";
-
- char **new_name = malloc (4 * sizeof (char *)); /* Speicherplatz für 4 Zeiger anfordern */
- for (int i = 0; i < 3; i++)
- new_name[i] = name[i];
- new_name[3] = "Dieter";
-
- free (name); /* altes Array */
- name = new_name; /* alter Zeiger zeigt auf neues Array */
-
- for (int i = 0; i < 4; i++)
- printf ("%s\n", name[i]);
- free (name);
- free (new_name); /* zeigt auf denselben Speicherplatz wie name --> Fehler */
- return 0;
-}
diff --git a/20221128/dynmem-06.c b/20221128/dynmem-06.c
deleted file mode 100644
index 226f12f62f02dafed072eefe32503188168bb668..0000000000000000000000000000000000000000
--- a/20221128/dynmem-06.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-int main (void)
-{
- char **name = malloc (3 * sizeof (char *)); /* Speicherplatz für 3 Zeiger anfordern */
- name[0] = "Anna";
- name[1] = "Berthold";
- name[2] = "Caesar";
-
- name = realloc (name, 4 * sizeof (char *)); /* Speicherplatz für 4 Zeiger anfordern */
- name[3] = "Dieter";
-
- for (int i = 0; i < 4; i++)
- printf ("%s\n", name[i]);
- free (name);
- return 0;
-}
diff --git a/20221128/hp-20221128.pdf b/20221128/hp-20221128.pdf
deleted file mode 100644
index 8c19cf5a2cea843243b7344dc1e90292e199391c..0000000000000000000000000000000000000000
Binary files a/20221128/hp-20221128.pdf and /dev/null differ
diff --git a/20221128/hp-20221128.tex b/20221128/hp-20221128.tex
deleted file mode 100644
index dcbe6a043b09312d2d53acfd65826631a7ff6270..0000000000000000000000000000000000000000
--- a/20221128/hp-20221128.tex
+++ /dev/null
@@ -1,986 +0,0 @@
-% hp-20221128.pdf - Lecture Slides on Low-Level Programming
-% Copyright (C) 2012, 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Objektorientierte Programmierung
-
-\documentclass[10pt,t]{beamer}
-
-\usepackage{pgslides}
-\usepackage{pdftricks}
-\usepackage{tikz}
-\usepackage{rotating}
-
-\begin{psinputs}
- \usepackage[utf8]{inputenc}
- \usepackage[german]{babel}
- \usepackage[T1]{fontenc}
- \usepackage{helvet}
- \renewcommand*\familydefault{\sfdefault}
- \usepackage{pstricks,pst-grad}
-\end{psinputs}
-
-\newcommand{\redurl}[1]{\href{#1}{\color{red}\nolinkurl{#1}}}
-
-\title{Hardwarenahe Programmierung}
-\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
-\date{28.\ November 2022}
-
-\begin{document}
-
-\maketitleframe
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \item[\textbf{5}] \textbf{Algorithmen}
- \begin{itemize}
- \item[5.1] Differentialgleichungen
- \item[5.2] Rekursion
- \color{medgreen}
- \item[5.3] Aufwandsabschätzungen
- \end{itemize}
- \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
- \begin{itemize}
- \color{red}
- \item[6.0] Dynamische Speicherverwaltung
- \color{orange}
- \item[6.1] Konzepte und Ziele
- \color{red}
- \item[6.2] Beispiel: Zahlen und Buchstaben
- \item[6.3] Unions
- \item[6.4] Virtuelle Methoden
- \color{black}
- \item[6.5] Beispiel: Graphische Benutzeroberfläche (GUI)
- \item[6.6] Ausblick: C++
- \end{itemize}
- \item[\textbf{7}] \textbf{Datenstrukturen}
- \end{itemize}
- \vspace*{-1cm}
-
-\end{frame}
-
-\setcounter{section}{4}
-\section{Algorithmen}
-\setcounter{subsection}{1}
-\subsection{Rekursion}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Vollständige Induktion:
- \vspace*{-0.725cm}
- \begin{displaymath}
- \hspace*{4cm}
- \left.
- \begin{array}{r}
- \mbox{Aussage gilt für $n = 1$}\\[2pt]
- \mbox{Schluß von $n - 1$ auf $n$}
- \end{array}
- \right\}
- \mbox{Aussage gilt für alle $n\in\mathbb{N}$}
- \end{displaymath}
- \vspace*{-0.5cm}
-
-% \pause
-
- Türme von Hanoi
-
- \begin{onlyenv}<1>
- \begin{center}
- \includegraphics[width=12.2cm]{Tower_of_Hanoi.jpeg}
- \end{center}
- \end{onlyenv}
-
- \begin{onlyenv}<2->
- \begin{itemize}
- \item
- 64 Scheiben, 3 Plätze,
- \only<2>{\hfill\makebox(0,0)[rt]{\includegraphics[width=6cm]{Tower_of_Hanoi.jpeg}}}\\
- immer 1 Scheibe verschieben
- \item
- Ziel: Turm verschieben
- \item
- Es dürfen nur kleinere Scheiben\\
- auf größeren liegen.
- \bigskip
-% \pause
- \pause
- \item
- $n = 1$ Scheibe: fertig
- \item
- Wenn $n - 1$ Scheiben verschiebbar:\\
- schiebe $n - 1$ Scheiben auf Hilfsplatz,\\
- verschiebe die darunterliegende,\\
- hole $n - 1$ Scheiben von Hilfsplatz
- \end{itemize}
- \begin{onlyenv}<3>
- \vspace{-4.3cm}
- \begin{lstlisting}[gobble=8,xleftmargin=6.4cm]
- void move (int from, int to, int disks)
- {
- if (disks == 1)
- move_one_disk (from, to);
- else
- {
- int help = 0 + 1 + 2 - from - to;
- move (from, help, disks - 1);
- move (from, to, 1);
- move (help, to, disks - 1);
- }
- }
- \end{lstlisting}
- \end{onlyenv}
- \begin{onlyenv}<4->
- \vspace{-5.0cm}
- \hspace*{7.4cm}\begin{minipage}[t]{5cm}
- 32 Scheiben:
- \begin{lstlisting}[gobble=10,style=terminal]
- $ ¡time ./hanoi-9b¿
- ...
- real 0m30,672s
- user 0m30,662s
- sys 0m0,008s
- \end{lstlisting}
-% \pause[7]
- \begin{itemize}
- \arrowitem
- etwas über 1 Minute\\
- für 64 Scheiben
- \end{itemize}
-% \pause
- \vspace*{-0.5cm}
- \begin{picture}(0,0)
- \color{red}
- \put(0,0){\makebox(0,0)[bl]{\tikz[line width=1pt]{\draw(0,0)--(4,0.8);}}}
- \put(0,0.8){\makebox(0,0)[tl]{\tikz[line width=1pt]{\draw(0,0)--(4,-0.8);}}}
- \end{picture}
-
- Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit!
- % 30.672 * 2^32 / 3600 / 24 / 365.25 = 4174.43775518138261464750
- \begin{itemize}
- \arrowitem
- $\frac{30,672\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4174$
- Jahre\\[\smallskipamount]
- für 64 Scheiben
- \end{itemize}
- \end{minipage}
- \end{onlyenv}
- \end{onlyenv}
-
-\end{frame}
-
-\subsection{Aufwandsabschätzungen \protect\color{gray}-- Komplexitätsanalyse}
-
-\begin{frame}[fragile]
-
-% \newcommand{\w}{\hspace*{0.75pt}}
-
- \showsubsection
-
- \begin{picture}(0,0)
- \put(7.6,-0.5){%
- \begin{minipage}[t]{5.3cm}
-% \vspace*{-1.0cm}\includegraphics{landau-symbols.pdf}
- \vspace*{-1.0cm}\alt<5->{\includegraphics{landau-symbols-3.pdf}}%
- {\alt<4->{\includegraphics{landau-symbols-2.pdf}}%
- {\includegraphics{landau-symbols.pdf}}}
- \small
- \begin{description}\itemsep0pt\leftskip-0.5cm
- \item[$n$:] Eingabedaten
- \item[$g(n)$:] Rechenzeit
- \end{description}
- \end{minipage}}
- \end{picture}
-
- \vspace*{-\bigskipamount}
-
- Wann ist ein Programm "`schnell"'?
-
- \medskip
-
- \begin{onlyenv}<1>
- Türme von Hanoi: $\mathcal{O}(2^n)$
- \par\medskip
- Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit!
- \begin{itemize}
- \arrowitem
- $\frac{30,672\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4174$
- Jahre\\[\smallskipamount]
- für 64 Scheiben
- \end{itemize}
-
- \bigskip
- \end{onlyenv}
-
- \begin{onlyenv}<1->
- Faustregel:\\Schachtelung der Schleifen zählen\\
- $k$ Schleifen ineinander \textarrow\ $\mathcal{O}(n^k)$
-
- \bigskip
- \end{onlyenv}
-
- \begin{onlyenv}<2>
- \textbf{Beispiel: Sortieralgorithmen}
-
- \smallskip
-
- Anzahl der Vergleiche bei $n$ Strings
- \begin{itemize}
- \item
- Maximum suchen mit Schummeln: $\mathcal{O}(1)$
-% \pause
- \item
- Maximum suchen: $\mathcal{O}(n)$
-% \pause
- \item
- Selection-Sort: $\mathcal{O}(n^2)$
-% \pause
- \item
- Bubble-Sort: $\mathcal{O}(n)$ bis $\mathcal{O}(n^2)$
-% \pause
- \item
- Quicksort: $\mathcal{O}(n\log n)$ bis $\mathcal{O}(n^2)$
- \end{itemize}
-
- \end{onlyenv}
-
- \begin{onlyenv}<3>
- \textbf{Wie schnell ist RSA-Verschlüsselung?}
-
- \smallskip
-
- \begin{math}
- c = m^e\,\%\,N
- \end{math}
- \quad
- ("`$\%$"' = "`modulo"')
-
- \medskip
-
- \begin{lstlisting}[gobble=6,xleftmargin=2em]
- int c = 1;
- for (int i = 0; i < e; i++)
- c = (c * m) % N;
- \end{lstlisting}
-
- \smallskip
-
- \begin{itemize}
- \item
- $\mathcal{O}(e)$ Iterationen
-% \item
-% wenn $n$ die Anzahl der Binärziffern (Bits) von $e$ ist:
-% $\mathcal{O}(2^n)$ Iterationen
- \item
- mit Trick:
- $\mathcal{O}(\log e)$ Iterationen ($\log e$ = Anzahl der Ziffern von $e$)
- \end{itemize}
-
- \smallskip
-
- Jede Iteration enthält eine Multiplikation und eine Division.\\
- Aufwand dafür: $\mathcal{O}(\log e)$\\
- \textarrow\ Gesamtaufwand: $\mathcal{O}\bigl((\log e)^2\bigr)$
-
- \end{onlyenv}
-
- \begin{onlyenv}<4->
-
- \textbf{Wie schnell ist RSA?}\\
-
- \smallskip
-
- ($n$ = typische beteiligte Zahl, z.\,B. $e,p,q$)
-
- \begin{itemize}
- \item
- Ver- und Entschlüsselung (Exponentiation):\\
- \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\!\left((\log n)^2\right)$\hss}
- \only<5->{{\color{magenta}$\mathcal{O}(n^2)$}}
- \item
- Schlüsselerzeugung (Berechnung von $d$):\\
- \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\!\left((\log n)^2\right)$\hss}
- \only<5->{{\color{magenta}$\mathcal{O}(n^2)$}}
- \item
- Verschlüsselung brechen (Primfaktorzerlegung):\\
- \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\bigl(2^{\sqrt{\log n\,\cdot\,\log\log n}}\bigr)$\hss}
- \only<5->{{\color{magenta}$\mathcal{O}\bigl(2^{\sqrt{n\log n}}\bigr)$}}
- \end{itemize}
-
- \vspace{0cm plus 1filll}
-
- \textbf{Die Sicherheit von RSA beruht darauf,
- daß das Brechen der Verschlüsselung aufwendiger ist als
- \boldmath$\mathcal{O}\bigl((\log n)^k\bigr)$ (für beliebiges $k$).}
-
- \vspace*{0.65cm}
-
- \end{onlyenv}
-
-\end{frame}
-
-\section{Objektorientierte Programmierung}
-
-\addtocounter{subsection}{-1}
-\subsection{Dynamische Speicherverwaltung}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \begin{itemize}
- \item
- Array: feste Anzahl von Elementen desselben Typs (z.\,B.\ 3 ganze Zahlen)
- \item
- Dynamisches Array: variable Anzahl von Elementen desselben Typs
- \end{itemize}
-
- \bigskip
-
- \begin{lstlisting}
- char *name[] = { "Anna", "Berthold", "Caesar" };
-
- ...
-
- name[3] = "Dieter";
- \end{lstlisting}
-
- \begin{picture}(0,0)
- \color{red}
- \put(0,0){\line(3,1){3.5}}
- \put(0,1){\line(3,-1){3.5}}
- \end{picture}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \bigskip
-
- \begin{lstlisting}
- #include <stdlib.h>
-
- ...
-
- char **name = malloc (3 * sizeof (char *));
- /* Speicherplatz für 3 Zeiger anfordern */
-
- ...
-
- free (name);
- /* Speicherplatz freigeben */
-
- \end{lstlisting}
-
-\end{frame}
-
-\subsection{Konzepte und Ziele}
-
-\begin{frame}
-
- \showsection
- \showsubsection
-
- \begin{itemize}
- \item
-% Array: feste Anzahl von Elementen desselben Typs (z.\,B.\ 3 ganze Zahlen)
- Array: Elemente desselben Typs (z.\,B.\ 3 ganze Zahlen)
-% \item
-% Dynamisches Array: variable Anzahl von Elementen desselben Typs
- \item
- Problem: Elemente unterschiedlichen Typs
- \item
- Lösung: den Typ des Elements zusätzlich speichern \textarrow\ \newterm{Objekt}
- \item
- Problem: Die Elemente sind unterschiedlich groß (Speicherplatz).
- \item
- Lösung: Im Array nicht die Objekte selbst speichern, sondern Zeiger darauf.
- \end{itemize}
- \begin{itemize}
- \item
- Funktionen, die mit dem Objekt arbeiten: \newterm{Methoden}
- \begin{onlyenv}<1>
- \item
- Was die Funktion bewirkt,\\
- hängt vom Typ des Objekts ab
- \item
- Realisierung über endlose \lstinline{if}-Ketten
- \end{onlyenv}
- \begin{onlyenv}<2>
- \item
- Was die Funktion bewirkt
- \begin{picture}(0,0)
- \color{red}
- \put(-4.00,-0.05){\tikz{\draw[thick](0,0.25)--(3.75,-0.05);%
- \draw[thick](-0.1,-0.05)--(3.75,0.3);}}
- \end{picture}%
- Welche Funktion aufgerufen wird,\\
- hängt vom Typ des Objekts ab: \newterm{virtuelle Methode}
- \item
- Realisierung über endlose \lstinline{if}-Ketten%
- \begin{picture}(0,0)
- \color{red}
- \put(-2.75,-0.05){\tikz{\draw[thick](0,0.25)--(2.5,-0.05);%
- \draw[thick](-0.1,-0.05)--(2.5,0.3);}}
- \put(1.5,-1.1){\begin{rotate}{7}\large\bf\textarrow\
- kommt gleich
-% nächste Woche
- \end{rotate}}
- \end{picture}
- Zeiger, die im Objekt gespeichert sind\\
- (Genaugenommen: Tabelle von Zeigern)
- \end{onlyenv}
- \end{itemize}
-
-\end{frame}
-
-\begin{frame}
-
- \showsection
- \showsubsection
-
- \begin{itemize}
- \item
- Problem: Elemente unterschiedlichen Typs
- \item
- Lösung: den Typ des Elements zusätzlich speichern \textarrow\ \newterm{Objekt}
- \item
- \newterm{Methoden\/} und \newterm{virtuelle Methoden}
- \end{itemize}
-
- \begin{itemize}
- \item
- Zeiger auf verschiedene Strukturen\\
- mit einem gemeinsamen Anteil von Datenfeldern\\
- \textarrow\ "`verwandte"' \newterm{Objekte}, \newterm{Klassenhierarchie} von Objekten
- \item
- Struktur, die \emph{nur\/} den gemeinsamen Anteil enthält\\
- \textarrow\ "`Vorfahr"', \newterm{Basisklasse}, \newterm{Vererbung}
- \item
-% Explizite Typumwandlung eines Zeigers auf die Basisklasse\\
-% in einen Zeiger auf die \newterm{abgeleitete Klasse}\\
-% \textarrow\ Man kann ein Array unterschiedlicher Objekte\\
-% \strut\phantom{\textarrow} in einer Schleife abarbeiten.\\
- Zeiger auf die Basisklasse dürfen auf Objekte\\
- der \newterm{abgeleiteten Klasse} zeigen\\
- \textarrow\ \newterm{Polymorphie}
- \end{itemize}
-
-\end{frame}
-
-\subsection{Beispiel: Zahlen und Buchstaben}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \begin{center}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- } t_base;¿
- \end{lstlisting}
- \end{minipage}\\[0.5cm]
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- int content;
- } t_integer;¿
- \end{lstlisting}
- \end{minipage}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- char *content;
- } t_string;¿
- \end{lstlisting}
- \end{minipage}
- \end{center}
-
-\end{frame}
-
-\begin{frame}[fragile]
- \begin{center}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- } t_base;¿
- \end{lstlisting}
- \end{minipage}\\[0.5cm]
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- int content;
- } t_integer;¿
- \end{lstlisting}
- \end{minipage}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- char *content;
- } t_string;¿
- \end{lstlisting}
- \end{minipage}\\[0.7cm]
- \begin{onlyenv}<1>
- \begin{minipage}{8cm}
- \begin{lstlisting}[gobble=10]
- ¡t_integer i = { 1, 42 };
- t_string s = { 2, "Hello, world!" };
-
- t_base *object[] = { (t_base *) &i, (t_base *) &s };¿
- \end{lstlisting}
- \end{minipage}%
- \begin{picture}(0,0)
- \color{red}
- \put(-5.4,-0.8){\mbox{$\underbrace{\rule{1.45cm}{0pt}}_{\shortstack{\strut explizite\\Typumwandlung}}$}}
- \end{picture}
- \end{onlyenv}
-% \begin{onlyenv}<2>
-% \begin{minipage}{5cm}
-% \begin{lstlisting}[gobble=10]
-% ¡typedef union
-% {
-% t_base base;
-% t_integer integer;
-% t_string string;
-% } t_object;¿
-% \end{lstlisting}
-% \end{minipage}
-% \end{onlyenv}
- \end{center}
-
-\end{frame}
-
-\subsection{Unions}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Variable teilen sich denselben Speicherplatz.
-
- \medskip
-
- \begin{minipage}[t]{3.7cm}
- \begin{lstlisting}[gobble=6]
- ¡typedef union
- {
- int8_t i;
- uint8_t u;
- } num8_t;¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{4.5cm}
- \begin{lstlisting}[gobble=6]
- ¡int main (void)
- {
- num8_t test;
- test.i = -1;
- printf ("%d\n", test.u);
- return 0;
- }¿
- \end{lstlisting}
- \end{minipage}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Variable teilen sich denselben Speicherplatz.
-
- \medskip
-
- \begin{minipage}[t]{3.7cm}
- \begin{lstlisting}[gobble=6]
- ¡typedef union
- {
- char s[8];
- uint64_t x;
- } num_char_t;¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{4.5cm}
- \begin{lstlisting}[gobble=6]
- ¡int main (void)
- {
- num_char_t test = { "Hello!" };
- printf ("%lx\n", test.x);
- return 0;
- }¿
- \end{lstlisting}
- \end{minipage}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Variable teilen sich denselben Speicherplatz.
-
- \medskip
-
- \begin{minipage}[t]{3.7cm}
- \begin{lstlisting}[gobble=6]
- ¡typedef union
- {
- t_base base;
- t_integer integer;
- t_string string;
- } t_object;¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{3.0cm}
- \begin{lstlisting}[gobble=6]
-
- ¡typedef struct
- {
- int type;
- } t_base;¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{3.0cm}
- \begin{lstlisting}[gobble=6]
-
- ¡typedef struct
- {
- int type;
- int content;
- } t_integer;¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{3.0cm}
- \begin{lstlisting}[gobble=6]
-
- ¡typedef struct
- {
- int type;
- char *content;
- } t_string;¿
- \end{lstlisting}
- \end{minipage}
-
- \bigskip
-
- \begin{center}
- \begin{minipage}{8.5cm}
- \begin{lstlisting}[gobble=8]
- ¡if (this->base.type == T_INTEGER)
- printf ("Integer: %d\n", this->integer.content);
- else if (this->base.type == T_STRING)
- printf ("String: \"%s\"\n", this->string.content);¿
- \end{lstlisting}
- \end{minipage}
- \end{center}
-
-\end{frame}
-
-\subsection{Virtuelle Methoden}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{lstlisting}
- void print_object (t_object *this)
- {
- if (this->base.type == T_INTEGER)
- printf ("Integer: %d\n", this->integer.content);
- else if (this->base.type == T_STRING)
- printf ("String: \"%s\"\n", this->string.content);
- }
- \end{lstlisting}
-
- \begin{picture}(0,0)
- \color{red}
- \put(9,1.7){\shortstack[l]{if-Kette:\\\strut wird unübersichtlich}}
- \put(1,-2){\mbox{\textarrow}}
- \put(0,-3){\mbox{Zeiger auf Funktionen}}
- \end{picture}
-
- \begin{lstlisting}[xleftmargin=4cm]
- void print_integer (t_object *this)
- {
- printf ("Integer: %d\n", this->integer.content);
- }
-
- void print_string (t_object *this)
- {
- printf ("String: \"%s\"\n", this->string.content);
- }
- \end{lstlisting}
-
-\end{frame}
-
-\begin{frame}[fragile]
- \showsubsection
-
- Zeiger auf Funktionen
-
- \medskip
-
- \begin{lstlisting}
- void (* print) (t_object *this);
- \end{lstlisting}
- \begin{picture}(0,1.2)(0,-0.9)
- \color{red}
- \put(0.95,0.3){\mbox{$\underbrace{\rule{1cm}{0pt}}$}}
- \put(0.2,-0.7){\shortstack{das, worauf print zeigt,\\ist eine Funktion}}
- \end{picture}
-
- \begin{itemize}
- \item
- Objekt enthält Zeiger auf Funktion
- \begin{onlyenv}<1>
- \medskip
- \begin{lstlisting}[gobble=10]
- typedef struct
- {
- void (* print) (union t_object *this);
- int content;
- } t_integer;
- \end{lstlisting}
- \vspace*{-2cm}
- \end{onlyenv}
- \begin{onlyenv}<2->
- \vspace*{-3.5cm} % Why doesn't a picture environment work here??? :-(
- \begin{lstlisting}[gobble=10,xleftmargin=5.5cm]
- typedef struct
- {
- void (* print) (union t_object *this);
- int content;
- } t_integer;
- \end{lstlisting}
- \vspace*{0.85cm}
- \bigskip
- \smallskip
- \end{onlyenv}
- \pause
- \item
- Konstruktor initialisiert diesen Zeiger
- \begin{onlyenv}<2>
- \medskip
- \begin{lstlisting}[gobble=10]
- t_object *new_integer (int i)
- {
- t_object *p = malloc (sizeof (t_integer));
- p->integer.print = print_integer;
- p->integer.content = i;
- return p;
- }
- \end{lstlisting}
- \vspace*{-2cm}
- \end{onlyenv}
- \pause
- \item
- Aufruf: "`automatisch"' die richtige Funktion
- \begin{onlyenv}<3>
- \medskip
- \begin{lstlisting}[gobble=10]
- for (int i = 0; object[i]; i++)
- object[i]->base.print (object[i]);
- \end{lstlisting}
- \end{onlyenv}
- \pause
- \medskip
- \item
- in größeren Projekten:\\
- Objekt enthält Zeiger auf Tabelle von Funktionen
- \end{itemize}
-\end{frame}
-
-\iffalse
-
-\subsection{Beispiel: Graphische Benutzeroberfläche (GUI)}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \scriptsize
- \begin{lstlisting}
- #include <gtk/gtk.h>
-
- int main (int argc, char **argv)
- {
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
- gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
- GtkWidget *label = gtk_label_new ("Hello, world!");
- gtk_container_add (GTK_CONTAINER (vbox), label);
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
- gtk_widget_show (button);
- gtk_widget_show (label);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
- }
- \end{lstlisting}
-
- \vspace*{-6cm}\strut\hfill
- \includegraphics[scale=0.85]{hello-gtk.png}\\[2cm]
- \begin{flushright}
- \normalsize\bf Praktikumsversuch:\\
- Objektorientiertes Zeichenprogramm
- \end{flushright}
-
-\end{frame}
-
-\subsection{Ausblick: C++}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{center}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- void (* print) (union t_object *this);
- } t_base;¿
- \end{lstlisting}
- \end{minipage}\\[0.5cm]
- \begin{minipage}{5.5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- void (* print) (...);
- int content;
- } t_integer;¿
- \end{lstlisting}
- \end{minipage}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- void (* print) (union t_object *this);
- char *content;
- } t_string;¿
- \end{lstlisting}
- \end{minipage}
- \end{center}
-
-\end{frame}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{center}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡struct TBase
- {
- virtual void print (void);
- };¿
- \end{lstlisting}
- \end{minipage}\\[0.5cm]
- \begin{minipage}{5.5cm}
- \begin{lstlisting}[gobble=8]
- ¡struct TInteger: public TBase
- {
- virtual void print (void);
- int content;
- };¿
- \end{lstlisting}
- \end{minipage}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡struct TString: public TBase
- {
- virtual void print (void);
- char *content;
- };¿
- \end{lstlisting}
- \end{minipage}
- \end{center}
-
-\end{frame}
-
-\fi
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \item[\textbf{5}] \textbf{Algorithmen}
- \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
- \begin{itemize}
- \color{medgreen}
- \item[6.0] Dynamische Speicherverwaltung
- \item[6.1] Konzepte und Ziele
- \item[6.2] Beispiel: Zahlen und Buchstaben
- \item[6.3] Unions
- \item[6.4] Virtuelle Methoden
- \color{red}
- \item[6.5] Beispiel: Graphische Benutzeroberfläche (GUI)
- \item[6.6] Ausblick: C++
- \end{itemize}
- \item[\textbf{7}] \textbf{Datenstrukturen}
- \vspace*{-1cm}
- \end{itemize}
-
-\end{frame}
-
-\end{document}
diff --git a/20221128/hp-musterloesung-20221128.pdf b/20221128/hp-musterloesung-20221128.pdf
deleted file mode 100644
index a113dc6303fd8897fb08f0f87b2a8d81c31d8e99..0000000000000000000000000000000000000000
Binary files a/20221128/hp-musterloesung-20221128.pdf and /dev/null differ
diff --git a/20221128/hp-musterloesung-20221128.tex b/20221128/hp-musterloesung-20221128.tex
deleted file mode 100644
index 4b0817bf918ab8b9c398c3cb1c75e3b4f0098aca..0000000000000000000000000000000000000000
--- a/20221128/hp-musterloesung-20221128.tex
+++ /dev/null
@@ -1,707 +0,0 @@
-% hp-musterloesung-20221128.pdf - Solutions to the Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Einfügen in Strings (Ergänzung), dynamisches Bit-Array, objektorientierte Tier-Datenbank
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\begin{document}
-
- \section*{Hardwarenahe Programmierung\\
- Musterlösung zu den Übungsaufgaben -- 28.\ November 2022}
-
- \exercise{Einfügen in Strings (Ergänzung)}
-
- Diese Aufgabe ist eine Ergänzung von Aufgabe 3 der Übung vom 31.\ Oktober
- 2022 um die Teilaufgaben (e), (f) und (g). Für den "`Klausur-Modus"' können
- Sie die Teilaufgaben (a) bis (d) als "`bereits gelöst"' voraussetzen.
-
- Wir betrachten das folgende Programm (\gitfile{hp}{2022ws/20221128}{aufgabe-1.c}):
-% \begin{lstlisting}[style=numbered]
- \begin{lstlisting}
- #include <stdio.h>
- #include <string.h>
-
- void insert_into_string (char src, char *target, int pos)
- {
- int len = strlen (target);
- for (int i = pos; i < len; i++)
- target[i+1] = target[i];
- target[pos] = src;
- }
-
- int main (void)
- {
- char test[100] = "Hochshule Bochum";
- insert_into_string ('c', test, 5);
- printf ("%s\n", test);
- return 0;
- }
- \end{lstlisting}
- Die Ausgabe des Programms lautet:
- \lstinline[style=terminal]{Hochschhhhhhhhhhh}
-
- \begin{enumerate}[\quad(a)]
- \item
- Erklären Sie, wie die Ausgabe zustandekommt.
-% \points{3}
-% \workspace{12}
- \item
- Schreiben Sie die Funktion \lstinline|insert_into_string()| so um,
- daß sie den Buchstaben \lstinline{src} an der Stelle \lstinline{pos}
- in den String \lstinline{target} einfügt.\par
- Die Ausgabe des Programms müßte dann
- \lstinline[style=terminal]{Hochschule Bochum} lauten.
-% \points{2}
-% \workspace{13}
- \item
- Was kann passieren, wenn Sie die Zeile
- \lstinline{char test[100] = "Hochshule Bochum";}\\
- durch
- \lstinline{char test[] = "Hochshule Bochum";} ersetzen?
- Begründen Sie Ihre Antwort.
-% \points{2}
-% \workspace{10}
- \item
- Was kann passieren, wenn Sie die Zeile
- \lstinline{char test[100] = "Hochshule Bochum";}\\
- durch
- \lstinline{char *test = "Hochshule Bochum";} ersetzen?
- Begründen Sie Ihre Antwort.
-% \points{2}
-% \workspace{10}
- \item
- Schreiben Sie eine Funktion
- \lstinline{void insert_into_string_sorted (char src, char *target)},
- die voraussetzt, daß der String \lstinline{target} alphabetisch sortiert ist
- und den Buchstaben \lstinline{src} an der alphabetisch richtigen Stelle
- einfügt. Diese Funktion darf die bereits vorhandene Funktion
- \lstinline|insert_into_string()| aufrufen.\\
- \points{4}\par
- Zum Testen eignen sich die folgenden Zeilen im Hauptprogramm:
- \begin{lstlisting}[gobble=8]
- char test[100] = "";
- insert_into_string_sorted ('c', test);
- insert_into_string_sorted ('a', test);
- insert_into_string_sorted ('d', test);
- insert_into_string_sorted ('b', test);
- \end{lstlisting}
- Danach sollte \lstinline{test[]} die Zeichenfolge \lstinline{"abcd"} enthalten.
-% \workspace{14}
- \goodbreak
- \item
- Wie schnell (Landau-Symbol in Abhängigkeit von der Länge $n$ des Strings)
- arbeitet Ihre Funktion
- \lstinline{void insert_into_string_sorted (char src, char *target)}?
- Begründen Sie Ihre Antwort.
- \points{1}
-% \workspace{10}
- \item
- Beschreiben Sie -- in Worten oder als C-Quelltext --, wie man die Funktion\\
- \lstinline{void insert_into_string_sorted (char src, char *target)}
- so gestalten kann,\\
- daß sie in $\mathcal{O}(\log n)$ arbeitet.
- \points{3}
-% \workspace{35}
- \end{enumerate}
-
- \solution
-
- \textbf{Bemerkung:} Die in dieser Aufgabe und ihrer Musterlösung vorkommenden
- Funktionen prüfen nicht, ob durch das Einfügen eines Zeichens der für den
- String reservierte Speicherplatz überläuft. Ein derartiges Verhalten wäre
- in einem "`echten"' Programm ein \textbf{Fehler}, der katastrophale Folgen
- haben kann. Wenn dergleichen hier nicht berücksichtigt wird, dann nur, um
- in einer Klausur nicht den zeitlichen Rahmen zu sprengen.
-
- \begin{enumerate}[\quad(a)]
- \setcounter{enumi}{4}
- \item
- \textbf{Schreiben Sie eine Funktion
- \lstinline{void insert_into_string_sorted (char src, char *target)},
- die voraussetzt, daß der String \lstinline{target} alphabetisch sortiert ist
- und den Buchstaben \lstinline{src} an der\break alphabetisch richtigen Stelle
- einfügt. Diese Funktion darf die bereits vorhandene Funktion\break
- \lstinline|insert_into_string()| aufrufen.}
- \begin{lstlisting}{gobble=8}
- void insert_into_string_sorted (char src, char *target)
- {
- int i = 0;
- while (target[i] && target[i] < src)
- i++;
- insert_into_string (src, target, i);
- }
- \end{lstlisting}
-
- Die Datei \gitfile{hp}{20221128}{loesung-1e.c} enthält die o.\,a.\ Funktion
- sowie zusätzliche Tests.
-
- \item
- \textbf{Wie schnell (Landau-Symbol in Abhängigkeit von der Länge $n$ des Strings)
- arbeitet Ihre Funktion
- \lstinline{void insert_into_string_sorted (char src, char *target)}?
- Begründen Sie Ihre Antwort.}
-
- Die Funktion sucht im Array \textbf{mittels einer Schleife}
- nach der korrekten Position zum Einfügen des Zeichens
- und hat daher von sich aus $\mathcal{O}(n)$.
-
- Anschließend ruft sie die Funktion \lstinline{insert_into_string()} auf,
- die ebenfalls eine Schleife verwendet, um im Array Platz zu Einfügen zu schaffen,
- und daher ebenfalls $\mathcal{O}(n)$ hat.
-
- Es bleibt daher bei $\mathcal{O}(n)$.
-
- \item
- \textbf{Beschreiben Sie -- in Worten oder als C-Quelltext --, wie man die Funktion\\
- \lstinline{void insert_into_string_sorted (char src, char *target)}
- so gestalten kann,\\
- daß sie in $\mathcal{O}(\log n)$ arbeitet.}
-
- In einem alphabetisch sortierten Array kann man die Suche in der Mitte beginnen
- und sich durch Halbieren der Intervalle an die gesuchte Position herantasten.
- Wegen des fortwährenden Halbierens geschieht dies in $\mathcal{O}(\log n)$.
- (Für eine derartige Antwort gäbe es in der Klausur die volle Punktzahl.)
-
- Wenn wir allerdings anschließend für das eigentliche Einfügen die Funktion
- \lstinline{insert_into_string()} verwenden, die dafür $\mathcal{O}(n)$ benötigt,
- kommen wir insgesamt auf $\mathcal{O}(n)$. Ein sortiertes Einfügen in ein Array
- ist daher in $\mathcal{O}(\log n)$ nicht möglich.
- (Wer dies bemerkt, kann zum einen während der Klausur nachfragen,
- wie denn die Aufgabenstellung genau gemeint ist, und sich zum anderen
- für die besondere Sorgfalt Zusatzpunkte verdienen.)
-
- Die Datei \gitfile{hp}{20221128}{loesung-1g.c} enthält einen C-Quelltext,
- die den o.\,a.\ Algorithmus als Funktion implementiert.
- Man beachte die Behandlung des Spezialfalls,
- daß das einzufügende Zeichen am Ende angehängt werden muß.
-
- \end{enumerate}
-
- \clearpage
-
- \exercise{Dynamisches Bit-Array}
-
- Schreiben Sie die folgenden Funktionen zur Verwaltung eines dynamischen Bit-Arrays:
- \begin{itemize}
- \item
- \lstinline{void bit_array_init (int n)}\\
- Das Array initialisieren, so daß man \lstinline{n} Bits darin speichern kann.\\
- Die Array-Größe \lstinline{n} ist keine Konstante, sondern erst im laufenden Programm bekannt.\\
- Die Bits sollen auf den Anfangswert 0 initialisiert werden.
- \item
- \lstinline{void bit_array_set (int i, int value)}\\
- Das Bit mit dem Index \lstinline{i} auf den Wert \lstinline{value} setzen.\\
- Der Index \lstinline{i} darf von \lstinline{0} bis \lstinline{n - 1} gehen;
- der Wert \lstinline{value} darf 1 oder 0 sein.
- \item
- \lstinline{void bit_array_flip (int i)}\\
- Das Bit mit dem Index \lstinline{i} auf den entgegengesetzten Wert setzen,\\
- also auf 1, wenn er vorher 0 ist, bzw.\ auf 0, wenn er vorher 1 ist.\\
- Der Index \lstinline{i} darf von \lstinline{0} bis \lstinline{n - 1} gehen.
- \item
- \lstinline{int bit_array_get (int i)}\\
- Den Wert des Bit mit dem Index \lstinline{i} zurückliefern.\\
- Der Index \lstinline{i} darf von \lstinline{0} bis \lstinline{n - 1} gehen.
- \item
- \lstinline{void bit_array_resize (int new_n)}\\
- Die Größe des Arrays auf \lstinline{new_n} Bits ändern.\\
- Dabei soll der Inhalt des Arrays, soweit er in die neue Größe paßt, erhalten bleiben.\\
- Neu hinzukommende Bits sollen auf 0 initialisiert werden.
- \item
- \lstinline{void bit_array_done (void)}\\
- Den vom Array belegten Speicherplatz wieder freigeben.
- \end{itemize}
- Bei Bedarf dürfen Sie den Funktionen zusätzliche Parameter mitgeben,
- beispielsweise um mehrere Arrays parallel verwalten zu können.
- (In der objektorientierten Programmierung wäre dies der implizite Parameter \lstinline{this},
- der auf die Objekt-Struktur zeigt.)
-
- Die Bits sollen möglichst effizient gespeichert werden,
- z.\,B.\ jeweils 8 Bits in einer \lstinline{uint8_t}-Variablen.
-
- Die Funktionen sollen möglichst robust sein,
- d.\,h.\ das Programm darf auch bei unsinnigen Parameterwerten nicht abstürzen,
- sondern soll eine Fehlermeldung ausgeben.
-
- \medskip
-
- Die folgenden \textbf{Hinweise} beschreiben
- einen möglichen Weg, die Aufgabe zu lösen.
- Es seht Ihnen frei, die Aufgabe auch auf andere Weise zu lösen.
- \begin{itemize}
- \item
- Setzen Sie zunächst voraus, daß das Array die konstante Länge 8 hat,
- und schreiben Sie zunächst nur die Funktionen
- \lstinline{bit_array_set()}, \lstinline{bit_array_flip()} und
- \lstinline{bit_array_get()}.
- \item
- Verallgemeinern Sie nun auf eine konstante Länge,
- bei der es sich um ein Vielfaches von 8 handelt.
- \item
- Implementieren Sie nun die Überprüfung auf unsinnige Parameterwerte.
- Damit können Sie sich gleichzeitig von der Bedingung lösen,
- daß die Länge des Arrays ein Vielfaches von 8 sein muß.
- \item
- Gehen Sie nun von einem statischen zu einem dynamischen Array über,
- und implementieren sie die Funktionen \lstinline{bit_array_init()},
- \lstinline{bit_array_done()} und \lstinline{bit_array_resize()}.
- \end{itemize}
-
-% \points{14}
-%
-% \medskip
-%
-% (Hinweis für die Klausur:
-% Abgabe in digitaler Form ist erwünscht, aber nicht zwingend.)
-
- \clearpage
-
- \solution
-
- Die hier vorgestellte Lösung folgt den Hinweisen.
- \begin{itemize}
- \item
- \textbf{Setzen Sie zunächst voraus, daß das Array die konstante Länge 8 hat,
- und schreiben Sie zunächst nur die Funktionen
- \lstinline{bit_array_set()}, \lstinline{bit_array_flip()} und
- \lstinline{bit_array_get()}.}
-
- Siehe: \gitfile{hp}{2022ws/20221128}{loesung-2-1.c}
-
- Wir speichern in jedem der acht Bit einer \lstinline{uint8_t}-Variablen
- jeweils eine Zahl, die 0 oder 1 sein kann.
- Dies geschieht durch Setzen bzw.\ Löschen bzw.\ Umklappen einzelner Bits
- in der Variablen.
-
- Das Programm enthält zusätzlich eine Funktion \lstinline{output()},
- mit der man sich den Inhalt des Arrays anzeigen lassen kann,
- sowie ein Hauptprogramm \lstinline{main()}, um die Funktionen zu testen.
-
- \item
- \textbf{Verallgemeinern Sie nun auf eine konstante Länge,
- bei der es sich um ein Vielfaches von 8 handelt.}
-
- Siehe: \gitfile{hp}{2022ws/20221128}{loesung-2-2.c}
-
- In diesem Programm setzen wir die Länge auf konstant \lstinline{LENGTH} Bits,
- wobei es sich um eine Präprozessor-Konstante mit dem Wert 32 handelt.
-
- Um \lstinline{LENGTH} Bits zu speichern, benötigen wir ein Array
- der Länge \lstinline{LENGTH / 8} Bytes.
-
- Um auf ein einzelnes Bit zuzugreifen, müssen wir zunächst ermitteln,
- in welchem der Bytes sich befindet. Außerdem interessieren wir uns
- für die Nummer des Bits innerhalb des Bytes.
- Den Array-Index des Bytes erhalten wir, indem wir den Index des Bits
- durch 8 dividieren. Der bei dieser Division verbleibende Rest ist die
- Nummer des Bits innerhalb des Bytes.
-
- Diese Rechnungen führen wir in den drei Funktionen
- \lstinline{bit_array_set()}, \lstinline{bit_array_flip()} und
- \lstinline{bit_array_get()} durch.
- (Diese ist eine eher unelegante Code-Verdopplung -- hier sogar eine Verdreifachung.
- Für den Produktiveinsatz lohnt es sich, darüber nachzudenken,
- wie man diese vermeiden kann, ohne gleichzeitig an Effizienz einzubüßen.
- Hierfür käme z.\,B.\ ein Präprozessor-Makro in Frage.
- Für die Lösung der Übungsaufgabe wird dies hingegen nicht verlangt.)
-
- \item
- \textbf{Implementieren Sie nun die Überprüfung auf unsinnige Parameterwerte.
- Damit können Sie sich gleichzeitig von der Bedingung lösen,
- daß die Länge des Arrays ein Vielfaches von 8 sein muß.}
-
- Siehe: \gitfile{hp}{2022ws/20221128}{loesung-2-3.c}
-
- Um weitere Code-Verdopplungen zu vermeiden,
- führen wir eine Funktion \lstinline{check_index()} ein,
- die alle Prüfungen durchführt.
-
- Wenn die Länge des Arrays kein Vielfaches von 8 ist,
- wird das letzte Byte nicht vollständig genutzt.
- Die einzige Schwierigkeit besteht darin, die korrekte Anzahl von Bytes
- zu ermitteln, nämlich die Länge dividiert durch 8, aber nicht ab-, sondern
- aufgerundet. Am elegantesten geht dies durch vorherige Addition von 7:
- \lstinline{#define BYTES ((LENGTH + 7) / 8)}.
- Es ist aber auch zulässig, die Anzahl der Bytes mit Hilfe einer
- \lstinline{if}-Anweisung zu ermitteln: Länge durch 8 teilen und abrunden;
- falls die Division nicht glatt aufging, um 1 erhöhen.
-
- \item
- \textbf{Gehen Sie nun von einem statischen zu einem dynamischen Array über,
- und implementieren sie die Funktionen \lstinline{bit_array_init()},
- \lstinline{bit_array_done()} und \lstinline{bit_array_resize()}.}
-
- Siehe: \gitfile{hp}{2022ws/20221128}{loesung-2-4.c}.
- Damit ist die Aufgabe gelöst.
-
- Aus den Präprozessor-Konstanten \lstinline{LENGTH} und \lstinline{BYTES}
- werden nun globale \lstinline{int}-Variable.
- Die Funktion \lstinline{bit_array_init()} berechnet die korrekten Werte
- für diese Variablen und legt das Array mittels \lstinline{malloc()} dynamisch
- an. Eine Größenänderung des Arrays erfolgt mittels \lstinline{realloc()},
- das Freigeben mittels \lstinline{free()}.
-
- Das Programm setzt Variable, die aktuell nicht verwendet werden,
- auf den Wert \lstinline{0} bzw.\ \lstinline{NULL}.
- Dies ermöglicht es der Funktion \lstinline{check_index()},
- auch zu prüfen, ob das Array vorher korrekt mit \lstinline{bit_array_init()}
- erzeugt wurde -- oder ob es vielleicht schon wieder mit
- \lstinline{bit_array_done()} freigegeben wurde.
-
- \end{itemize}
-
- \clearpage
-
- \exercise{Objektorientierte Tier-Datenbank}
-
- Das unten dargestellte Programm (Datei: \gitfile{hp}{2022ws/20221128}{aufgabe-3a.c})
- soll Daten von Tieren verwalten.
-
- Beim Compilieren erscheinen die folgende Fehlermeldungen:
- \begin{lstlisting}[style=terminal]
- $ ¡gcc -std=c99 -Wall -O aufgabe-2a.c -o aufgabe-2a¿
- aufgabe-2a.c: In function 'main':
- aufgabe-2a.c:31: error: 'animal' has no member named 'wings'
- aufgabe-2a.c:37: error: 'animal' has no member named 'legs'
- \end{lstlisting}
-
- Der Programmierer nimmt die in Rot dargestellten Ersetzungen vor\\
- (Datei: \gitfile{hp}{2022ws/20221128}{aufgabe-3b.c}).
- Daraufhin gelingt das Compilieren, und die Ausgabe des Programms lautet:
- \begin{lstlisting}[style=terminal]
- $ ¡gcc -std=c99 -Wall -O aufgabe-2b.c -o aufgabe-2b¿
- $ ¡./aufgabe-2b¿
- A duck has 2 legs.
- Error in animal: cow
- \end{lstlisting}
-
- \begin{itemize}
- \item[(a)]
- Erklären Sie die o.\,a.\ Compiler-Fehlermeldungen.
- \points{2}
- \item[(b)]
- Wieso verschwinden die Fehlermeldungen nach den o.\,a.\ Ersetzungen?
- \points{3}
- \item[(c)]
- Erklären Sie die Ausgabe des Programms.
- \points{5}
- \item[(d)]
- Beschreiben Sie -- in Worten und/oder als C-Quelltext -- einen Weg,
- das Programm so zu berichtigen, daß es die Eingabedaten
- (``A duck has 2 wings. A cow has 4 legs.'') korrekt speichert und ausgibt.\\
- \points{4}
-% \item[(e)]
-% Schreiben Sie das Programm so um,
-% daß es keine expliziten Typumwandlungen mehr benötigt.\par
-% Hinweis: Verwenden Sie \lstinline{union}.
-% \points{4}
-% \item[(f)]
-% Schreiben Sie das Programm weiter um,
-% so daß es die Objektinstanzen \lstinline{duck} und \lstinline{cow}
-% dynamisch erzeugt.\par
-% Hinweis: Verwenden Sie \lstinline{malloc()} und schreiben Sie Konstruktoren.
-% \points{4}
-% \item[(g)]
-% Schreiben Sie das Programm weiter um,
-% so daß die Ausgabe nicht mehr direkt im Hauptprogramm erfolgt,
-% sondern stattdessen eine virtuelle Methode \lstinline{print()}
-% aufgerufen wird.\par
-% Hinweis: Verwenden Sie in den Objekten Zeiger auf Funktionen,
-% und initialisieren Sie diese in den Konstruktoren.
-% \points{4}
- \end{itemize}
-
- \begin{minipage}[t]{0.34\textwidth}
- \begin{lstlisting}[gobble=6,xleftmargin=0pt]
- #include <stdio.h>
-
- #define ANIMAL 0
- #define WITH_WINGS 1
- #define WITH_LEGS 2
-
- typedef struct animal
- {
- int type;
- char *name;
- } animal;
-
- typedef struct with_wings
- {
- int wings;
- } with_wings;
-
- typedef struct with_legs
- {
- int legs;
- } with_legs;
- \end{lstlisting}
- \end{minipage}\hfill
- \begin{minipage}[t]{0.65\textwidth}
- \begin{lstlisting}[gobble=6,xleftmargin=0pt]
- int main (void)
- {
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- a[0]->type = WITH_WINGS;
- a[0]->name = "duck";
- a[0]->wings = 2;
-
- animal cow;
- a[1] = &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- a[1]->legs = 4;
-
- for (int i = 0; i < 2; i++)
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name,
- ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name,
- ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
-
- return 0;
- }
- \end{lstlisting}
- \begin{picture}(0,0)
- \color{red}
- \put(3.7,6.207){\vector(-1,0){0.7}}
- \put(3.8,6.207){\makebox(0,0)[l]{\lstinline[basicstyle=\color{red}]{((with_legs *) a[1])->legs = 4;}}}
- \put(4.0,8.735){\vector(-1,0){0.7}}
- \put(4.1,8.735){\makebox(0,0)[l]{\lstinline[basicstyle=\color{red}]{((with_wings *) a[0])->wings = 2;}}}
- \end{picture}
- \end{minipage}
-
- \solution
-
- \begin{itemize}
- \item[(a)]
- \textbf{Erklären Sie die o.\,a.\ Compiler-Fehlermeldungen.}
-
- \lstinline{a[0]} und \lstinline{a[1]}
- sind gemäß der Deklaration \lstinline{animal *a[2]}
- Zeiger auf Variablen vom Typ \lstinline{animal} (ein \lstinline{struct}).
- Wenn man diesen Zeiger dereferenziert (\lstinline{->}),
- erhält man eine \lstinline{animal}-Variable.
- Diese enthält keine Datenfelder \lstinline{wings} bzw.\ \lstinline{legs}.
-
- \item[(b)]
- \textbf{Wieso verschwinden die Fehlermeldungen nach den o.\,a.\ Ersetzungen?}
-
- Durch die \emph{explizite Typumwandlung des Zeigers\/}
- erhalten wir einen Zeiger auf eine \lstinline{with_wings}-
- bzw.\ auf eine \lstinline{with_legs}-Variable.
- Diese enthalten die Datenfelder \lstinline{wings} bzw.\ \lstinline{legs}.
-
- \item[(c)]
- \textbf{Erklären Sie die Ausgabe des Programms.}
-
- Durch die explizite Typumwandlung des Zeigers
- zeigt \lstinline{a[0]} auf eine \lstinline{with_wings}-Variable.
- Diese enthält nur ein einziges Datenfeld \lstinline{wings},
- das an genau derselben Stelle im Speicher liegt
- wie \lstinline{a[0]->type}, also das Datenfeld \lstinline{type}
- der \lstinline{animal}-Variable, auf die der Zeiger \lstinline{a[0]} zeigt.
- Durch die Zuweisung der Zahl \lstinline{2}
- an \lstinline{((with_wings *) a[0])->wings}
- überschreiben wir also \lstinline{a[0]->type},
- so daß das \lstinline{if} in der \lstinline{for}-Schleife
- \lstinline{a[0]} als \lstinline{WITH_LEGS} erkennt.
-
- Bei der Ausgabe \lstinline[style=terminal]{A duck has 2 legs.}
- wird das Datenfeld \lstinline{((with_legs *)a[0])->legs} als Zahl ausgegeben.
- Dieses Datenfeld befindet sich in denselben Speicherzellen wie
- \lstinline{a[0]->type} und \lstinline{((with_wings *)} % :-(
- \lstinline{a[0]->wings}
- und hat daher ebenfalls den Wert 2.
-
- Auf die gleiche Weise überschreiben wir durch die Zuweisung der Zahl 4
- an \lstinline{((with_legs *) a[1])->legs}
- das Datenfeld \lstinline{a[0]->type},
- so daß das \lstinline{if} in der \lstinline{for}-Schleife
- \lstinline{a[1]} als unbekanntes Tier (Nr.\ 4) erkennt und
- \lstinline[style=terminal]{Error in animal: cow} ausgibt.
-
- \item[(d)]
- \textbf{Beschreiben Sie -- in Worten und/oder als C-Quelltext -- einen Weg,
- das Programm so zu berichtigen, daß es die Eingabedaten
- (``A duck has 2 wings. A cow has 4 legs.'') korrekt speichert und ausgibt.}
-
- Damit die \emph{Vererbung\/} zwischen den Objekten
- \lstinline{animal}, \lstinline{with_wings} und \lstinline{with_legs}
- funktioniert, müssen die abgeleiteten Klassen \lstinline{with_wings} und \lstinline{with_legs}
- alle Datenfelder der Basisklasse \lstinline{animal} erben.
- In C geschieht dies explizit; die Datenfelder müssen in den
- abgeleiteten Klassen neu angegeben werden
- (siehe \gitfile{hp}{2022ws/20221128}{loesung-3d-1.c}):
-
- \begin{lstlisting}[gobble=8]
- typedef struct animal
- {
- int type;
- char *name;
- } animal;
-
- typedef struct with_wings
- {
- int type;
- char *name;
- int wings;
- } with_wings;
-
- typedef struct with_legs
- {
- int type;
- char *name;
- int legs;
- } with_legs;
- \end{lstlisting}
-
- Zusätzlich ist es notwendig,
- die Instanzen \lstinline{duck} und \lstinline{cow}
- der abgeleiteten Klassen \lstinline{with_wings} und \lstinline{with_legs}
- auch als solche zu deklarieren,
- damit für sie genügend Speicher reserviert wird:
-
- \begin{lstlisting}[gobble=8]
- animal *a[2];
-
- with_wings duck;
- a[0] = (animal *) &duck;
- a[0]->type = WITH_WINGS;
- a[0]->name = "duck";
- ((with_wings *) a[0])->wings = 2;
-
- with_legs cow;
- a[1] = (animal *) &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- ((with_legs *) a[1])->legs = 4;
- \end{lstlisting}
-
- Wenn man dies vergißt und sie nur als \lstinline{animal} deklariert,
- wird auch nur Speicherplatz für (kleinere)
- \lstinline{animal}-Variable angelegt.
- Dadurch kommt es zu Speicherzugriffen außerhalb der
- deklarierten Variablen, was letztlich zu einem Absturz führt
- (siehe \gitfile{hp}{2022ws/20221128}{loesung-3d-0f.c}).
-
- Für die Zuweisung eines Zeigers auf \lstinline{duck}
- an \lstinline{a[0]}, also an einen Zeiger auf \lstinline{animal}
- wird eine weitere explizite Typumwandlung notwendig.
- Entsprechendes gilt für die Zuweisung eines Zeigers auf \lstinline{cow}
- an \lstinline{a[1]}.
-
- Es ist sinnvoll, explizite Typumwandlungen so weit wie möglich zu vermeiden.
- Es ist einfacher und gleichzeitig sicherer,
- direkt in die Variablen \lstinline{duck} und \lstinline{cow}
- zu schreiben, anstatt dies über die Zeiger \lstinline{a[0]}
- und \lstinline{a[1]} zu tun
- (siehe \gitfile{hp}{2022ws/20221128}{loesung-3d-2.c}):
-
- \begin{lstlisting}[gobble=8]
- animal *a[2];
-
- with_wings duck;
- a[0] = (animal *) &duck;
- duck.type = WITH_WINGS;
- duck.name = "duck";
- duck.wings = 2;
-
- with_legs cow;
- a[1] = (animal *) &cow;
- cow.type = WITH_LEGS;
- cow.name = "cow";
- cow.legs = 4;
- \end{lstlisting}
-
- \item[(e)]
- \textbf{Schreiben Sie das Programm so um,
- daß es keine expliziten Typumwandlungen mehr benötigt.}\par
- \textbf{Hinweis: Verwenden Sie \lstinline{union}.}
-
- Siehe \gitfile{hp}{2022ws/20221128}{loesung-3e.c}.
-
- Diese Lösung basiert auf \gitfile{hp}{2022ws/20221128}{loesung-3d-2.c},
- da diese bereits weniger explizite Typumwandlungen enthält
- als \gitfile{hp}{2022ws/20221128}{loesung-3d-1.c}.
-
- Arbeitsschritte:
- \begin{itemize}
- \item
- Umbenennen des Basistyps \lstinline{animal} in \lstinline{base},
- damit wir den Bezeichner \lstinline{animal}
- für die \lstinline{union} verwenden können
- \item
- Schreiben einer \lstinline{union animal},
- die die drei Klassen \lstinline{base},
- \lstinline{with_wings} und \lstinline{with_legs}
- als Datenfelder enthält
- \item
- Umschreiben der Initialisierungen:
- Zugriff auf Datenfelder erfolgt nun durch
- z.\,B.\ \lstinline{a[0]->b.name}.
- Hierbei ist \lstinline{b} der Name des \lstinline{base}-Datenfelds
- innerhalb der \lstinline{union animal}.
- \item
- Auf gleiche Weise schreiben wir die \lstinline{if}-Bedingungen
- innerhalb der \lstinline{for}-Schleife
- sowie die Parameter der \lstinline{printf()}-Aufrufe um.
- \end{itemize}
- Explizite Typumwandlungen sind nun nicht mehr nötig.
-
- Nachteil dieser Lösung:
- Jede Objekt-Variable belegt nun Speicherplatz
- für die gesamte \lstinline{union animal},
- anstatt nur für die benötigte Variable vom Typ
- \lstinline{with_wings} oder \lstinline{with_legs}.
- Dies kann zu einer Verschwendung von Speicherplatz führen,
- auch wenn dies in diesem Beispielprogramm tatsächlich nicht der Fall ist.
-
- \item[(f)]
- \textbf{Schreiben Sie das Programm weiter um,
- so daß es die Objektinstanzen \lstinline{duck} und \lstinline{cow}
- dynamisch erzeugt.}\par
- \textbf{Hinweis: Verwenden Sie \lstinline{malloc()} und schreiben Sie Konstruktoren.}
-
- Siehe \gitfile{hp}{2022ws/20221128}{loesung-3f.c}.
-
- \item[(g)]
- \textbf{Schreiben Sie das Programm weiter um,
- so daß die Ausgabe nicht mehr direkt im Hauptprogramm erfolgt,
- sondern stattdessen eine virtuelle Methode \lstinline{print()}
- aufgerufen wird.}\par
- \textbf{Hinweis: Verwenden Sie in den Objekten Zeiger auf Funktionen,
- und initialisieren Sie diese in den Konstruktoren.}
-
- Siehe \gitfile{hp}{2022ws/20221128}{loesung-3g.c}.
-
- \end{itemize}
-
-\end{document}
diff --git a/20221128/hp-uebung-20221128.pdf b/20221128/hp-uebung-20221128.pdf
deleted file mode 100644
index 6e4c328cbab5b424929eb4e28f4fd03eb9b506b9..0000000000000000000000000000000000000000
Binary files a/20221128/hp-uebung-20221128.pdf and /dev/null differ
diff --git a/20221128/hp-uebung-20221128.tex b/20221128/hp-uebung-20221128.tex
deleted file mode 100644
index a104f3ab348bbeee242d1d5d705e93ca5d924f8e..0000000000000000000000000000000000000000
--- a/20221128/hp-uebung-20221128.tex
+++ /dev/null
@@ -1,342 +0,0 @@
-% hp-uebung-20221128.pdf - Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Einfügen in Strings (Ergänzung), dynamisches Bit-Array, objektorientierte Tier-Datenbank
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\begin{document}
-
- \section*{Hardwarenahe Programmierung\\
- Übungsaufgaben -- 28.\ November 2022}
-
- Diese Übung enthält Punkteangaben wie in einer Klausur.
- Um zu "`bestehen"', müssen Sie innerhalb von 65 Minuten
- unter Verwendung ausschließlich zugelassener Hilfsmittel
- 11 Punkte (von insgesamt \totalpoints) erreichen.
-
- \exercise{Einfügen in Strings (Ergänzung)}
-
- Diese Aufgabe ist eine Ergänzung von Aufgabe 3 der Übung vom 31.\ Oktober
- 2022 um die Teilaufgaben (e), (f) und (g). Für den "`Klausur-Modus"' können
- Sie die Teilaufgaben (a) bis (d) als "`bereits gelöst"' voraussetzen.
-
- Wir betrachten das folgende Programm (\gitfile{hp}{2022ws/20221128}{aufgabe-1.c}):
-% \begin{lstlisting}[style=numbered]
- \begin{lstlisting}
- #include <stdio.h>
- #include <string.h>
-
- void insert_into_string (char src, char *target, int pos)
- {
- int len = strlen (target);
- for (int i = pos; i < len; i++)
- target[i+1] = target[i];
- target[pos] = src;
- }
-
- int main (void)
- {
- char test[100] = "Hochshule Bochum";
- insert_into_string ('c', test, 5);
- printf ("%s\n", test);
- return 0;
- }
- \end{lstlisting}
- Die Ausgabe des Programms lautet:
- \lstinline[style=terminal]{Hochschhhhhhhhhhh}
-
- \begin{enumerate}[\quad(a)]
- \item
- Erklären Sie, wie die Ausgabe zustandekommt.
-% \points{3}
-% \workspace{12}
- \item
- Schreiben Sie die Funktion \lstinline|insert_into_string()| so um,
- daß sie den Buchstaben \lstinline{src} an der Stelle \lstinline{pos}
- in den String \lstinline{target} einfügt.\par
- Die Ausgabe des Programms müßte dann
- \lstinline[style=terminal]{Hochschule Bochum} lauten.
-% \points{2}
-% \workspace{13}
- \item
- Was kann passieren, wenn Sie die Zeile
- \lstinline{char test[100] = "Hochshule Bochum";}\\
- durch
- \lstinline{char test[] = "Hochshule Bochum";} ersetzen?
- Begründen Sie Ihre Antwort.
-% \points{2}
-% \workspace{10}
- \item
- Was kann passieren, wenn Sie die Zeile
- \lstinline{char test[100] = "Hochshule Bochum";}\\
- durch
- \lstinline{char *test = "Hochshule Bochum";} ersetzen?
- Begründen Sie Ihre Antwort.
-% \points{2}
-% \workspace{10}
- \item
- Schreiben Sie eine Funktion
- \lstinline{void insert_into_string_sorted (char src, char *target)},
- die voraussetzt, daß der String \lstinline{target} alphabetisch sortiert ist
- und den Buchstaben \lstinline{src} an der alphabetisch richtigen Stelle
- einfügt. Diese Funktion darf die bereits vorhandene Funktion
- \lstinline|insert_into_string()| aufrufen.\\
- \points{4}\par
- Zum Testen eignen sich die folgenden Zeilen im Hauptprogramm:
- \begin{lstlisting}[gobble=8]
- char test[100] = "";
- insert_into_string_sorted ('c', test);
- insert_into_string_sorted ('a', test);
- insert_into_string_sorted ('d', test);
- insert_into_string_sorted ('b', test);
- \end{lstlisting}
- Danach sollte \lstinline{test[]} die Zeichenfolge \lstinline{"abcd"} enthalten.
-% \workspace{14}
- \goodbreak
- \item
- Wie schnell (Landau-Symbol in Abhängigkeit von der Länge $n$ des Strings)
- arbeitet Ihre Funktion
- \lstinline{void insert_into_string_sorted (char src, char *target)}?
- Begründen Sie Ihre Antwort.
- \points{1}
-% \workspace{10}
- \item
- Beschreiben Sie -- in Worten oder als C-Quelltext --, wie man die Funktion\\
- \lstinline{void insert_into_string_sorted (char src, char *target)}
- so gestalten kann,\\
- daß sie in $\mathcal{O}(\log n)$ arbeitet.
- \points{3}
-% \workspace{35}
- \end{enumerate}
-
- \exercise{Dynamisches Bit-Array}
-
- Schreiben Sie die folgenden Funktionen zur Verwaltung eines dynamischen Bit-Arrays:
- \begin{itemize}
- \item
- \lstinline{void bit_array_init (int n)}\\
- Das Array initialisieren, so daß man \lstinline{n} Bits darin speichern kann.\\
- Die Array-Größe \lstinline{n} ist keine Konstante, sondern erst im laufenden Programm bekannt.\\
- Die Bits sollen auf den Anfangswert 0 initialisiert werden.
- \item
- \lstinline{void bit_array_set (int i, int value)}\\
- Das Bit mit dem Index \lstinline{i} auf den Wert \lstinline{value} setzen.\\
- Der Index \lstinline{i} darf von \lstinline{0} bis \lstinline{n - 1} gehen;
- der Wert \lstinline{value} darf 1 oder 0 sein.
- \item
- \lstinline{void bit_array_flip (int i)}\\
- Das Bit mit dem Index \lstinline{i} auf den entgegengesetzten Wert setzen,\\
- also auf 1, wenn er vorher 0 ist, bzw.\ auf 0, wenn er vorher 1 ist.\\
- Der Index \lstinline{i} darf von \lstinline{0} bis \lstinline{n - 1} gehen.
- \item
- \lstinline{int bit_array_get (int i)}\\
- Den Wert des Bit mit dem Index \lstinline{i} zurückliefern.\\
- Der Index \lstinline{i} darf von \lstinline{0} bis \lstinline{n - 1} gehen.
- \item
- \lstinline{void bit_array_resize (int new_n)}\\
- Die Größe des Arrays auf \lstinline{new_n} Bits ändern.\\
- Dabei soll der Inhalt des Arrays, soweit er in die neue Größe paßt, erhalten bleiben.\\
- Neu hinzukommende Bits sollen auf 0 initialisiert werden.
- \item
- \lstinline{void bit_array_done (void)}\\
- Den vom Array belegten Speicherplatz wieder freigeben.
- \end{itemize}
- Bei Bedarf dürfen Sie den Funktionen zusätzliche Parameter mitgeben,
- beispielsweise um mehrere Arrays parallel verwalten zu können.
- (In der objektorientierten Programmierung wäre dies der implizite Parameter \lstinline{this},
- der auf die Objekt-Struktur zeigt.)
-
- Die Bits sollen möglichst effizient gespeichert werden,
- z.\,B.\ jeweils 8 Bits in einer \lstinline{uint8_t}-Variablen.
-
- Die Funktionen sollen möglichst robust sein,
- d.\,h.\ das Programm darf auch bei unsinnigen Parameterwerten nicht abstürzen,
- sondern soll eine Fehlermeldung ausgeben.
-
- \medskip
-
- Die folgenden \textbf{Hinweise} beschreiben
- einen möglichen Weg, die Aufgabe zu lösen.
- Es seht Ihnen frei, die Aufgabe auch auf andere Weise zu lösen.
- \begin{itemize}
- \item
- Setzen Sie zunächst voraus, daß das Array die konstante Länge 8 hat,
- und schreiben Sie zunächst nur die Funktionen
- \lstinline{bit_array_set()}, \lstinline{bit_array_flip()} und
- \lstinline{bit_array_get()}.
- \item
- Verallgemeinern Sie nun auf eine konstante Länge,
- bei der es sich um ein Vielfaches von 8 handelt.
- \item
- Implementieren Sie nun die Überprüfung auf unsinnige Parameterwerte.
- Damit können Sie sich gleichzeitig von der Bedingung lösen,
- daß die Länge des Arrays ein Vielfaches von 8 sein muß.
- \item
- Gehen Sie nun von einem statischen zu einem dynamischen Array über,
- und implementieren Sie die Funktionen \lstinline{bit_array_init()},
- \lstinline{bit_array_done()} und \lstinline{bit_array_resize()}.
- \end{itemize}
-
-% \points{14}
-%
-% \medskip
-%
-% (Hinweis für die Klausur:
-% Abgabe in digitaler Form ist erwünscht, aber nicht zwingend.)
-
- \clearpage
- \exercise{Objektorientierte Tier-Datenbank}
-
- Das unten dargestellte Programm (Datei: \gitfile{hp}{2022ws/20221128}{aufgabe-3a.c})
- soll Daten von Tieren verwalten.
-
- Beim Compilieren erscheinen die folgende Fehlermeldungen:
- \begin{lstlisting}[style=terminal]
- $ ¡gcc -std=c99 -Wall -O aufgabe-2a.c -o aufgabe-2a¿
- aufgabe-2a.c: In function 'main':
- aufgabe-2a.c:31: error: 'animal' has no member named 'wings'
- aufgabe-2a.c:37: error: 'animal' has no member named 'legs'
- \end{lstlisting}
-
- Der Programmierer nimmt die in Rot dargestellten Ersetzungen vor
- (Datei: \gitfile{hp}{2022ws/20221128}{aufgabe-3b.c}).
- Daraufhin gelingt das Compilieren, und die Ausgabe des Programms lautet:
- \begin{lstlisting}[style=terminal]
- $ ¡gcc -std=c99 -Wall -O aufgabe-2b.c -o aufgabe-2b¿
- $ ¡./aufgabe-2b¿
- A duck has 2 legs.
- Error in animal: cow
- \end{lstlisting}
-
- \begin{itemize}
- \item[(a)]
- Erklären Sie die o.\,a.\ Compiler-Fehlermeldungen.
- \points{2}
- \item[(b)]
- Wieso verschwinden die Fehlermeldungen nach den o.\,a.\ Ersetzungen?
- \points{3}
- \item[(c)]
- Erklären Sie die Ausgabe des Programms.
- \points{5}
- \item[(d)]
- Beschreiben Sie -- in Worten und/oder als C-Quelltext -- einen Weg,
- das Programm so zu berichtigen, daß es die Eingabedaten
- (``A duck has 2 wings. A cow has 4 legs.'') korrekt speichert und ausgibt.\\
- \points{4}
-% \item[(e)]
-% Schreiben Sie das Programm so um,
-% daß es keine expliziten Typumwandlungen mehr benötigt.\par
-% Hinweis: Verwenden Sie \lstinline{union}.
-% \points{4}
-% \item[(f)]
-% Schreiben Sie das Programm weiter um,
-% so daß es die Objektinstanzen \lstinline{duck} und \lstinline{cow}
-% dynamisch erzeugt.\par
-% Hinweis: Verwenden Sie \lstinline{malloc()} und schreiben Sie Konstruktoren.
-% \points{4}
-% \item[(g)]
-% Schreiben Sie das Programm weiter um,
-% so daß die Ausgabe nicht mehr direkt im Hauptprogramm erfolgt,
-% sondern stattdessen eine virtuelle Methode \lstinline{print()}
-% aufgerufen wird.\par
-% Hinweis: Verwenden Sie in den Objekten Zeiger auf Funktionen,
-% und initialisieren Sie diese in den Konstruktoren.
-% \points{4}
- \end{itemize}
-
- \begin{minipage}[t]{0.34\textwidth}
- \begin{lstlisting}[gobble=6,xleftmargin=0pt]
- #include <stdio.h>
-
- #define ANIMAL 0
- #define WITH_WINGS 1
- #define WITH_LEGS 2
-
- typedef struct animal
- {
- int type;
- char *name;
- } animal;
-
- typedef struct with_wings
- {
- int wings;
- } with_wings;
-
- typedef struct with_legs
- {
- int legs;
- } with_legs;
- \end{lstlisting}
- \end{minipage}\hfill
- \begin{minipage}[t]{0.65\textwidth}
- \begin{lstlisting}[gobble=6,xleftmargin=0pt]
- int main (void)
- {
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- a[0]->type = WITH_WINGS;
- a[0]->name = "duck";
- a[0]->wings = 2;
-
- animal cow;
- a[1] = &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- a[1]->legs = 4;
-
- for (int i = 0; i < 2; i++)
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name,
- ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name,
- ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
-
- return 0;
- }
- \end{lstlisting}
- \begin{picture}(0,0)
- \color{red}
- \put(3.7,6.207){\vector(-1,0){0.7}}
- \put(3.8,6.207){\makebox(0,0)[l]{\lstinline[basicstyle=\color{red}]{((with_legs *) a[1])->legs = 4;}}}
- \put(4.0,8.735){\vector(-1,0){0.7}}
- \put(4.1,8.735){\makebox(0,0)[l]{\lstinline[basicstyle=\color{red}]{((with_wings *) a[0])->wings = 2;}}}
- \end{picture}
- \end{minipage}
-
- \begin{flushright}
- \textit{Viel Erfolg!}
- \end{flushright}
-
- \makeatletter
- \immediate\write\@mainaux{\string\gdef\string\totalpoints{\arabic{points}}}
- \makeatother
-
-\end{document}
diff --git a/20221128/landau-symbols-2.pdf b/20221128/landau-symbols-2.pdf
deleted file mode 120000
index 6b458b6efd8e274824a6dfcaabc4b9c27d196dc4..0000000000000000000000000000000000000000
--- a/20221128/landau-symbols-2.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/landau-symbols-2.pdf
\ No newline at end of file
diff --git a/20221128/landau-symbols-3.pdf b/20221128/landau-symbols-3.pdf
deleted file mode 120000
index 46efa409b35ff5df763c744a423599cba515d886..0000000000000000000000000000000000000000
--- a/20221128/landau-symbols-3.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/landau-symbols-3.pdf
\ No newline at end of file
diff --git a/20221128/landau-symbols.pdf b/20221128/landau-symbols.pdf
deleted file mode 120000
index ca145425bf07439c680632aa0663f84be601a565..0000000000000000000000000000000000000000
--- a/20221128/landau-symbols.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/landau-symbols.pdf
\ No newline at end of file
diff --git a/20221128/loesung-1e.c b/20221128/loesung-1e.c
deleted file mode 100644
index bc41fb0e1f5f826a427038a18798e280fd1a096d..0000000000000000000000000000000000000000
--- a/20221128/loesung-1e.c
+++ /dev/null
@@ -1,33 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-void insert_into_string (char src, char *target, int pos)
-{
- int len = strlen (target);
- for (int i = len; i >= pos; i--)
- target[i + 1] = target[i];
- target[pos] = src;
-}
-
-void insert_into_string_sorted (char src, char *target)
-{
- int i = 0;
- while (target[i] && target[i] < src)
- i++;
- insert_into_string (src, target, i);
-}
-
-int main (void)
-{
- char test[100] = "";
- insert_into_string_sorted ('c', test);
- insert_into_string_sorted ('a', test);
- insert_into_string_sorted ('d', test);
- insert_into_string_sorted ('b', test);
- printf ("test = \"%s\"\n", test);
- for (char ch = 'e'; ch < 'z'; ch += 2)
- insert_into_string_sorted (ch, test);
- insert_into_string_sorted ('n', test);
- printf ("test = \"%s\"\n", test);
- return 0;
-}
diff --git a/20221128/loesung-1g.c b/20221128/loesung-1g.c
deleted file mode 100644
index 4b0c29dfc223fa961cdbf930683e6d79610b002b..0000000000000000000000000000000000000000
--- a/20221128/loesung-1g.c
+++ /dev/null
@@ -1,46 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-void insert_into_string (char src, char *target, int pos)
-{
- int len = strlen (target);
- for (int i = len; i >= pos; i--)
- target[i + 1] = target[i];
- target[pos] = src;
-}
-
-void insert_into_string_sorted (char src, char *target)
-{
- int l = 0;
- int r = 0;
- while (target[r])
- r++;
- int m = (l + r) / 2;
- while (m > l)
- {
- if (src < target[m])
- r = m;
- else
- l = m;
- m = (l + r) / 2;
- }
- if (target[m] == 0 || src < target[m])
- insert_into_string (src, target, m);
- else
- insert_into_string (src, target, m + 1);
-}
-
-int main (void)
-{
- char test[100] = "";
- insert_into_string_sorted ('c', test);
- insert_into_string_sorted ('a', test);
- insert_into_string_sorted ('d', test);
- insert_into_string_sorted ('b', test);
- printf ("test = \"%s\"\n", test);
- for (char ch = 'e'; ch < 'z'; ch += 2)
- insert_into_string_sorted (ch, test);
- insert_into_string_sorted ('n', test);
- printf ("test = \"%s\"\n", test);
- return 0;
-}
diff --git a/20221128/loesung-2-1.c b/20221128/loesung-2-1.c
deleted file mode 100644
index 11ad08a28a2c16e645e4b55c1b0f4556246fd692..0000000000000000000000000000000000000000
--- a/20221128/loesung-2-1.c
+++ /dev/null
@@ -1,50 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-uint8_t buffer = 0;
-
-void bit_array_set (int i, int value)
-{
- uint8_t mask = 1 << i;
- if (value)
- buffer |= mask;
- else
- buffer &= ~mask;
-}
-
-void bit_array_flip (int i)
-{
- uint8_t mask = 1 << i;
- buffer ^= mask;
-}
-
-int bit_array_get (int i)
-{
- uint8_t mask = 1 << i;
- if (buffer & mask)
- return 1;
- else
- return 0;
-}
-
-void output (void)
-{
- for (int i = 0; i < 8; i++)
- {
- if (i % 4 == 0)
- printf (" ");
- printf ("%d", bit_array_get (i));
- }
- printf ("\n");
-}
-
-int main (void)
-{
- output ();
- bit_array_set (2, 1);
- output ();
- bit_array_flip (7);
- output ();
- bit_array_set (2, 0);
- output ();
-}
diff --git a/20221128/loesung-2-2.c b/20221128/loesung-2-2.c
deleted file mode 100644
index e510904b033cf7d55737cee55ad08ecb9510f324..0000000000000000000000000000000000000000
--- a/20221128/loesung-2-2.c
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-#define LENGTH 32
-
-uint8_t buffer[LENGTH / 8] = { 0, 0, 0, 0 };
-
-void bit_array_set (int i, int value)
-{
- int byte_index = i / 8;
- int bit_index = i % 8;
- uint8_t mask = 1 << bit_index;
- if (value)
- buffer[byte_index] |= mask;
- else
- buffer[byte_index] &= ~mask;
-}
-
-void bit_array_flip (int i)
-{
- int byte_index = i / 8;
- int bit_index = i % 8;
- uint8_t mask = 1 << bit_index;
- buffer[byte_index] ^= mask;
-}
-
-int bit_array_get (int i)
-{
- int byte_index = i / 8;
- int bit_index = i % 8;
- uint8_t mask = 1 << bit_index;
- if (buffer[byte_index] & mask)
- return 1;
- else
- return 0;
-}
-
-void output (void)
-{
- for (int i = 0; i < LENGTH; i++)
- {
- if (i % 4 == 0)
- printf (" ");
- printf ("%d", bit_array_get (i));
- }
- printf ("\n");
-}
-
-int main (void)
-{
- output ();
- bit_array_set (12, 1);
- output ();
- bit_array_flip (31);
- output ();
- bit_array_set (12, 0);
- output ();
-}
diff --git a/20221128/loesung-2-3.c b/20221128/loesung-2-3.c
deleted file mode 100644
index 4177464aebf41205169a6bb02b27ac972e3a4f4e..0000000000000000000000000000000000000000
--- a/20221128/loesung-2-3.c
+++ /dev/null
@@ -1,71 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-#include <error.h>
-
-#define LENGTH 29
-#define BYTES ((LENGTH + 7) / 8)
-
-uint8_t buffer[BYTES] = { 0, 0, 0, 0 };
-
-void check_index (int i)
-{
- if (i < 0 || i >= LENGTH)
- error (1, 0, "index %d out of range (0, ..., %d)", i, LENGTH - 1);
-}
-
-void bit_array_set (int i, int value)
-{
- check_index (i);
- int byte_index = i / 8;
- int bit_index = i % 8;
- uint8_t mask = 1 << bit_index;
- if (value)
- buffer[byte_index] |= mask;
- else
- buffer[byte_index] &= ~mask;
-}
-
-void bit_array_flip (int i)
-{
- check_index (i);
- int byte_index = i / 8;
- int bit_index = i % 8;
- uint8_t mask = 1 << bit_index;
- buffer[byte_index] ^= mask;
-}
-
-int bit_array_get (int i)
-{
- check_index (i);
- int byte_index = i / 8;
- int bit_index = i % 8;
- uint8_t mask = 1 << bit_index;
- if (buffer[byte_index] & mask)
- return 1;
- else
- return 0;
-}
-
-void output (void)
-{
- for (int i = 0; i < LENGTH; i++)
- {
- if (i % 4 == 0)
- printf (" ");
- printf ("%d", bit_array_get (i));
- }
- printf ("\n");
-}
-
-int main (void)
-{
- output ();
- bit_array_set (12, 1);
- output ();
- bit_array_flip (28);
- output ();
- bit_array_set (12, 0);
- output ();
- bit_array_flip (31);
- output ();
-}
diff --git a/20221128/loesung-2-4.c b/20221128/loesung-2-4.c
deleted file mode 100644
index 1930580aae8e8b24528852d1dacf58051f6bd6cc..0000000000000000000000000000000000000000
--- a/20221128/loesung-2-4.c
+++ /dev/null
@@ -1,101 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-#include <error.h>
-#include <stdlib.h>
-
-int length = 0;
-int bytes = 0;
-uint8_t *buffer = NULL;
-
-void bit_array_init (int n)
-{
- length = n;
- bytes = (length + 7) / 8;
- if (buffer)
- free (buffer);
- buffer = malloc (bytes * sizeof (uint8_t));
- for (int i = 0; i < bytes; i++)
- buffer[i] = 0;
-}
-
-void bit_array_resize (int new_n)
-{
- length = new_n;
- bytes = (length + 7) / 8;
- buffer = realloc (buffer, bytes * sizeof (uint8_t));
-}
-
-void bit_array_done (void)
-{
- free (buffer);
- buffer = NULL;
- length = 0;
- bytes = 0;
-}
-
-void check_index (int i)
-{
- if (!buffer)
- error (1, 0, "array not initialised");
- if (i < 0 || i >= length)
- error (1, 0, "index %d out of range (0, ..., %d)", i, length - 1);
-}
-
-void bit_array_set (int i, int value)
-{
- check_index (i);
- int byte_index = i / 8;
- int bit_index = i % 8;
- uint8_t mask = 1 << bit_index;
- if (value)
- buffer[byte_index] |= mask;
- else
- buffer[byte_index] &= ~mask;
-}
-
-void bit_array_flip (int i)
-{
- check_index (i);
- int byte_index = i / 8;
- int bit_index = i % 8;
- uint8_t mask = 1 << bit_index;
- buffer[byte_index] ^= mask;
-}
-
-int bit_array_get (int i)
-{
- check_index (i);
- int byte_index = i / 8;
- int bit_index = i % 8;
- uint8_t mask = 1 << bit_index;
- if (buffer[byte_index] & mask)
- return 1;
- else
- return 0;
-}
-
-void output (void)
-{
- for (int i = 0; i < length; i++)
- {
- if (i % 4 == 0)
- printf (" ");
- printf ("%d", bit_array_get (i));
- }
- printf ("\n");
-}
-
-int main (void)
-{
- bit_array_init (29);
- output ();
- bit_array_set (12, 1);
- output ();
- bit_array_flip (28);
- output ();
- bit_array_set (12, 0);
- output ();
- bit_array_flip (31);
- output ();
- bit_array_done ();
-}
diff --git a/20221128/loesung-3d-0f.c b/20221128/loesung-3d-0f.c
deleted file mode 100644
index 04b2d3e8956f4790b3f2ffdf3a314994c640513e..0000000000000000000000000000000000000000
--- a/20221128/loesung-3d-0f.c
+++ /dev/null
@@ -1,54 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int type;
- char *name;
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int type;
- char *name;
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- a[0]->type = WITH_WINGS;
- a[0]->name = "duck";
- ((with_wings *) a[0])->wings = 2;
-
- animal cow;
- a[1] = &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- ((with_legs *) a[1])->legs = 4;
-
- for (int i = 0; i < 2; i++)
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name,
- ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name,
- ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
-
- return 0;
-}
diff --git a/20221128/loesung-3d-1.c b/20221128/loesung-3d-1.c
deleted file mode 100644
index 349523a7d99e33ba81094ffbc8907773b5a3a251..0000000000000000000000000000000000000000
--- a/20221128/loesung-3d-1.c
+++ /dev/null
@@ -1,54 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int type;
- char *name;
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int type;
- char *name;
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- with_wings duck;
- a[0] = (animal *) &duck;
- a[0]->type = WITH_WINGS;
- a[0]->name = "duck";
- ((with_wings *) a[0])->wings = 2;
-
- with_legs cow;
- a[1] = (animal *) &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- ((with_legs *) a[1])->legs = 4;
-
- for (int i = 0; i < 2; i++)
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name,
- ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name,
- ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
-
- return 0;
-}
diff --git a/20221128/loesung-3d-2.c b/20221128/loesung-3d-2.c
deleted file mode 100644
index f831a75eda1f3e784c8e6c1f24a83d9d6b55ee6c..0000000000000000000000000000000000000000
--- a/20221128/loesung-3d-2.c
+++ /dev/null
@@ -1,54 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int type;
- char *name;
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int type;
- char *name;
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- with_wings duck;
- a[0] = (animal *) &duck;
- duck.type = WITH_WINGS;
- duck.name = "duck";
- duck.wings = 2;
-
- with_legs cow;
- a[1] = (animal *) &cow;
- cow.type = WITH_LEGS;
- cow.name = "cow";
- cow.legs = 4;
-
- for (int i = 0; i < 2; i++)
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name,
- ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name,
- ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
-
- return 0;
-}
diff --git a/20221128/loesung-3e.c b/20221128/loesung-3e.c
deleted file mode 100644
index b984d9253b9c379a88f0fc0ca130c88c3103f8f3..0000000000000000000000000000000000000000
--- a/20221128/loesung-3e.c
+++ /dev/null
@@ -1,61 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct
-{
- int type;
- char *name;
-} base;
-
-typedef struct
-{
- int type;
- char *name;
- int wings;
-} with_wings;
-
-typedef struct
-{
- int type;
- char *name;
- int legs;
-} with_legs;
-
-typedef union
-{
- base b;
- with_wings w;
- with_legs l;
-} animal;
-
-int main (void)
-{
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- duck.b.type = WITH_WINGS;
- duck.b.name = "duck";
- duck.w.wings = 2;
-
- animal cow;
- a[1] = &cow;
- cow.b.type = WITH_LEGS;
- cow.b.name = "cow";
- cow.l.legs = 4;
-
- for (int i = 0; i < 2; i++)
- if (a[i]->b.type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->b.name,
- a[i]->l.legs);
- else if (a[i]->b.type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->b.name,
- a[i]->w.wings);
- else
- printf ("Error in animal: %s\n", a[i]->b.name);
-
- return 0;
-}
diff --git a/20221128/loesung-3f.c b/20221128/loesung-3f.c
deleted file mode 100644
index 7b949e6365fc3839e6adc7661e0f8b4dd0c059df..0000000000000000000000000000000000000000
--- a/20221128/loesung-3f.c
+++ /dev/null
@@ -1,69 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct
-{
- int type;
- char *name;
-} base;
-
-typedef struct
-{
- int type;
- char *name;
- int wings;
-} with_wings;
-
-typedef struct
-{
- int type;
- char *name;
- int legs;
-} with_legs;
-
-typedef union
-{
- base b;
- with_wings w;
- with_legs l;
-} animal;
-
-animal *new_with_wings (char *name, int wings)
-{
- animal *a = malloc (sizeof (with_wings));
- a->b.type = WITH_WINGS;
- a->b.name = name;
- a->w.wings = wings;
- return a;
-}
-
-animal *new_with_legs (char *name, int legs)
-{
- animal *a = malloc (sizeof (with_legs));
- a->b.type = WITH_LEGS;
- a->b.name = name;
- a->l.legs = legs;
- return a;
-}
-
-int main (void)
-{
- animal *a[2] = { new_with_wings ("duck", 2),
- new_with_legs ("cow", 4) };
-
- for (int i = 0; i < 2; i++)
- if (a[i]->b.type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->b.name,
- a[i]->l.legs);
- else if (a[i]->b.type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->b.name,
- a[i]->w.wings);
- else
- printf ("Error in animal: %s\n", a[i]->b.name);
-
- return 0;
-}
diff --git a/20221128/loesung-3g.c b/20221128/loesung-3g.c
deleted file mode 100644
index b453a52dbe0ef27399255819808b3f6e562ba3ef..0000000000000000000000000000000000000000
--- a/20221128/loesung-3g.c
+++ /dev/null
@@ -1,77 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-union animal;
-
-typedef struct
-{
- int type;
- char *name;
- void (*print) (union animal *this);
-} base;
-
-typedef struct
-{
- int type;
- char *name;
- void (*print) (union animal *this);
- int wings;
-} with_wings;
-
-typedef struct
-{
- int type;
- char *name;
- void (*print) (union animal *this);
- int legs;
-} with_legs;
-
-typedef union animal
-{
- base b;
- with_wings w;
- with_legs l;
-} animal;
-
-void print_with_wings (animal *this)
-{
- printf ("A %s has %d wings.\n", this->b.name, this->w.wings);
-}
-
-void print_with_legs (animal *this)
-{
- printf ("A %s has %d legs.\n", this->b.name, this->l.legs);
-}
-
-animal *new_with_wings (char *name, int wings)
-{
- animal *a = malloc (sizeof (with_wings));
- a->b.type = WITH_WINGS;
- a->b.name = name;
- a->b.print = print_with_wings;
- a->w.wings = wings;
- return a;
-}
-
-animal *new_with_legs (char *name, int legs)
-{
- animal *a = malloc (sizeof (with_legs));
- a->b.type = WITH_LEGS;
- a->b.name = name;
- a->b.print = print_with_legs;
- a->l.legs = legs;
- return a;
-}
-
-int main (void)
-{
- animal *a[2] = { new_with_wings ("duck", 2),
- new_with_legs ("cow", 4) };
- for (int i = 0; i < 2; i++)
- a[i]->b.print (a[i]);
- return 0;
-}
diff --git a/20221128/logo-hochschule-bochum-cvh-text-v2.pdf b/20221128/logo-hochschule-bochum-cvh-text-v2.pdf
deleted file mode 120000
index 4aa99b8f81061aca6dcaf43eed2d9efef40555f8..0000000000000000000000000000000000000000
--- a/20221128/logo-hochschule-bochum-cvh-text-v2.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
diff --git a/20221128/logo-hochschule-bochum.pdf b/20221128/logo-hochschule-bochum.pdf
deleted file mode 120000
index b6b9491e370e499c9276918182cdb82cb311bcd1..0000000000000000000000000000000000000000
--- a/20221128/logo-hochschule-bochum.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20221128/mathe-20221128-logarithmus.png b/20221128/mathe-20221128-logarithmus.png
deleted file mode 100644
index 1c2cc02a7a06a56707822680c1de37b63b70e7b1..0000000000000000000000000000000000000000
Binary files a/20221128/mathe-20221128-logarithmus.png and /dev/null differ
diff --git a/20221128/mathe-20221128-potenz.png b/20221128/mathe-20221128-potenz.png
deleted file mode 100644
index bd76cb60b73a31b3d70fae3726b543653fce512a..0000000000000000000000000000000000000000
Binary files a/20221128/mathe-20221128-potenz.png and /dev/null differ
diff --git a/20221128/mathe-20221128.xcf.gz b/20221128/mathe-20221128.xcf.gz
deleted file mode 100644
index c1671252bf32db5deb192f767980e9c3f7a26019..0000000000000000000000000000000000000000
Binary files a/20221128/mathe-20221128.xcf.gz and /dev/null differ
diff --git a/20221128/objects-01.c b/20221128/objects-01.c
deleted file mode 100644
index 1a628668fd7b8fb3a0d9886ac14e8e909bc23793..0000000000000000000000000000000000000000
--- a/20221128/objects-01.c
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- int type;
-} t_base;
-
-typedef struct
-{
- int type;
- int content;
-} t_integer;
-
-typedef struct
-{
- int type;
- char *content;
-} t_string;
-
-int main (void)
-{
- t_integer i = { 1, 42 };
- t_string s = { 2, "Hello, world!" };
-
- t_base *object[] = { &i, &s };
-
- return 0;
-}
diff --git a/20221128/objects-02.c b/20221128/objects-02.c
deleted file mode 100644
index a47cfb4276085399afb86795d04b1f6ae20c95bf..0000000000000000000000000000000000000000
--- a/20221128/objects-02.c
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- int type;
-} t_base;
-
-typedef struct
-{
- int type;
- int content;
-} t_integer;
-
-typedef struct
-{
- int type;
- char *content;
-} t_string;
-
-int main (void)
-{
- t_integer i = { 1, 42 };
- t_string s = { 2, "Hello, world!" };
-
- t_base *object[] = { (t_base *) &i, (t_base *) &s };
-
- return 0;
-}
diff --git a/20221128/objects-03.c b/20221128/objects-03.c
deleted file mode 100644
index ff9224c0767ccad39f5b1396720ee73b6a0455fb..0000000000000000000000000000000000000000
--- a/20221128/objects-03.c
+++ /dev/null
@@ -1,34 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- int type;
-} t_base;
-
-typedef struct
-{
- int type;
- int content;
-} t_integer;
-
-typedef struct
-{
- int type;
- char *content;
-} t_string;
-
-int main (void)
-{
- t_integer i = { 1, 42 };
- t_string s = { 2, "Hello, world!" };
-
- t_base *object[] = { (t_base *) &i, (t_base *) &s };
-
- for (int i = 0; i < 2; i++)
- if (object[i]->type == 1)
- printf ("Integer: %d\n", object[i]->content);
- else if (object[i]->type == 2)
- printf ("String: \"%s\"\n", object[i]->content);
-
- return 0;
-}
diff --git a/20221128/objects-04.c b/20221128/objects-04.c
deleted file mode 100644
index ef7bffe80471d4b014258824421dce0557fc41dd..0000000000000000000000000000000000000000
--- a/20221128/objects-04.c
+++ /dev/null
@@ -1,34 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- int type;
-} t_base;
-
-typedef struct
-{
- int type;
- int content;
-} t_integer;
-
-typedef struct
-{
- int type;
- char *content;
-} t_string;
-
-int main (void)
-{
- t_integer i = { 1, 42 };
- t_string s = { 2, "Hello, world!" };
-
- t_base *object[] = { (t_base *) &i, (t_base *) &s };
-
- for (int i = 0; i < 2; i++)
- if (object[i]->type == 1)
- printf ("Integer: %d\n", (t_integer *) object[i]->content);
- else if (object[i]->type == 2)
- printf ("String: \"%s\"\n", (t_string *) object[i]->content);
-
- return 0;
-}
diff --git a/20221128/objects-05.c b/20221128/objects-05.c
deleted file mode 100644
index 820181d87e2a04b81cd2e03aa7980d970cd6c1a6..0000000000000000000000000000000000000000
--- a/20221128/objects-05.c
+++ /dev/null
@@ -1,34 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- int type;
-} t_base;
-
-typedef struct
-{
- int type;
- int content;
-} t_integer;
-
-typedef struct
-{
- int type;
- char *content;
-} t_string;
-
-int main (void)
-{
- t_integer i = { 1, 42 };
- t_string s = { 2, "Hello, world!" };
-
- t_base *object[] = { (t_base *) &i, (t_base *) &s };
-
- for (int i = 0; i < 2; i++)
- if (object[i]->type == 1)
- printf ("Integer: %d\n", ((t_integer *) object[i])->content);
- else if (object[i]->type == 2)
- printf ("String: \"%s\"\n", ((t_string *) object[i])->content);
-
- return 0;
-}
diff --git a/20221128/objects-06.c b/20221128/objects-06.c
deleted file mode 100644
index 86847c9085083e2d5093026619550fb272b5f4ec..0000000000000000000000000000000000000000
--- a/20221128/objects-06.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- int type;
-} t_base;
-
-typedef struct
-{
- int type;
- int content;
-} t_integer;
-
-typedef struct
-{
- int type;
- char *content;
-} t_string;
-
-void print_object (t_base *this)
-{
- if (this->type == 1)
- printf ("Integer: %d\n", ((t_integer *) this)->content);
- else if (this->type == 2)
- printf ("String: \"%s\"\n", ((t_string *) this)->content);
-}
-
-int main (void)
-{
- t_integer i = { 1, 42 };
- t_string s = { 2, "Hello, world!" };
-
- t_base *object[] = { (t_base *) &i, (t_base *) &s };
-
- for (int i = 0; i < 2; i++)
- print_object (object[i]);
-
- return 0;
-}
diff --git a/20221128/objects-07.c b/20221128/objects-07.c
deleted file mode 100644
index b9b24ad65f650aeda194e4570ae853e1a5ad8f11..0000000000000000000000000000000000000000
--- a/20221128/objects-07.c
+++ /dev/null
@@ -1,43 +0,0 @@
-#include <stdio.h>
-
-#define T_BASE 0
-#define T_INTEGER 1
-#define T_STRING 2
-
-typedef struct
-{
- int type;
-} t_base;
-
-typedef struct
-{
- int type;
- int content;
-} t_integer;
-
-typedef struct
-{
- int type;
- char *content;
-} t_string;
-
-void print_object (t_base *this)
-{
- if (this->type == T_INTEGER)
- printf ("Integer: %d\n", ((t_integer *) this)->content);
- else if (this->type == T_STRING)
- printf ("String: \"%s\"\n", ((t_string *) this)->content);
-}
-
-int main (void)
-{
- t_integer i = { T_INTEGER, 42 };
- t_string s = { T_STRING, "Hello, world!" };
-
- t_base *object[] = { (t_base *) &i, (t_base *) &s, NULL };
-
- for (int i = 0; object[i]; i++)
- print_object (object[i]);
-
- return 0;
-}
diff --git a/20221128/objects-08.c b/20221128/objects-08.c
deleted file mode 100644
index 0c93e8f6c3c4b5e504c758dfa87b8510e98c0692..0000000000000000000000000000000000000000
--- a/20221128/objects-08.c
+++ /dev/null
@@ -1,59 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#define T_BASE 0
-#define T_INTEGER 1
-#define T_STRING 2
-
-typedef struct
-{
- int type;
-} t_base;
-
-typedef struct
-{
- int type;
- int content;
-} t_integer;
-
-typedef struct
-{
- int type;
- char *content;
-} t_string;
-
-void print_object (t_base *this)
-{
- if (this->type == T_INTEGER)
- printf ("Integer: %d\n", ((t_integer *) this)->content);
- else if (this->type == T_STRING)
- printf ("String: \"%s\"\n", ((t_string *) this)->content);
-}
-
-t_integer *new_integer (int i)
-{
- t_integer *p = malloc (sizeof (t_integer));
- p->type = T_INTEGER;
- p->content = i;
- return p;
-}
-
-t_string *new_string (char *s)
-{
- t_string *p = malloc (sizeof (t_string));
- p->type = T_STRING;
- p->content = s;
- return p;
-}
-
-int main (void)
-{
- t_base *object[] = { (t_base *) new_integer (42),
- (t_base *) new_string ("Hello, world!"),
- NULL };
-
- for (int i = 0; object[i]; i++)
- print_object (object[i]);
-
- return 0;
-}
diff --git a/20221128/objects-09.c b/20221128/objects-09.c
deleted file mode 100644
index 3355ce354278e9839db0952c6de0d7acca172157..0000000000000000000000000000000000000000
--- a/20221128/objects-09.c
+++ /dev/null
@@ -1,69 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#define T_BASE 0
-#define T_INTEGER 1
-#define T_STRING 2
-
-typedef struct
-{
- int type;
-} t_base;
-
-typedef struct
-{
- int type;
- int content;
-} t_integer;
-
-typedef struct
-{
- int type;
- char *content;
-} t_string;
-
-typedef union
-{
- t_base base;
- t_integer integer;
- t_string string;
-} t_object;
-
-void print_object (t_object *this)
-{
- if (this->base.type == T_INTEGER)
- printf ("Integer: %d\n", this->integer.content);
- else if (this->base.type == T_STRING)
- printf ("String: \"%s\"\n", this->string.content);
-}
-
-t_object *new_integer (int i)
-{
- t_object *p = malloc (sizeof (t_integer));
- p->integer.type = T_INTEGER;
- p->integer.content = i;
- return p;
-}
-
-t_object *new_string (char *s)
-{
- t_object *p = malloc (sizeof (t_string));
- p->string.type = T_STRING;
- p->string.content = s;
- return p;
-}
-
-int main (void)
-{
- t_object *object[] = { new_integer (42),
- new_string ("Hello, world!"),
- NULL };
-
- for (int i = 0; object[i]; i++)
- print_object (object[i]);
-
- for (int i = 0; object[i]; i++)
- free (object[i]);
-
- return 0;
-}
diff --git a/20221128/objects-09a.c b/20221128/objects-09a.c
deleted file mode 100644
index e98c5bd7f08421834d3322d1d7cdd568707ed4ba..0000000000000000000000000000000000000000
--- a/20221128/objects-09a.c
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct
-{
-} t_base;
-
-typedef struct
-{
- int content;
-} t_integer;
-
-typedef struct
-{
- char *content;
-} t_string;
-
-typedef union
-{
- t_base base;
- t_integer integer;
- t_string string;
-} t_object;
-
-void print_object (t_object *this)
-{
-// if (this->base.type == T_INTEGER)
-// printf ("Integer: %d\n", this->integer.content);
-// else if (this->base.type == T_STRING)
-// printf ("String: \"%s\"\n", this->string.content);
-}
-
-t_object *new_integer (int i)
-{
- t_object *p = malloc (sizeof (t_integer));
- p->integer.content = i;
- return p;
-}
-
-t_object *new_string (char *s)
-{
- t_object *p = malloc (sizeof (t_string));
- p->string.content = s;
- return p;
-}
-
-int main (void)
-{
- t_object *object[] = { new_integer (42),
- new_string ("Hello, world!"),
- NULL };
-
- for (int i = 0; object[i]; i++)
- print_object (object[i]);
-
- for (int i = 0; object[i]; i++)
- free (object[i]);
-
- return 0;
-}
diff --git a/20221128/objects-09b.c b/20221128/objects-09b.c
deleted file mode 100644
index f1d8678839e5b2fc66bebf77074a1a2195440444..0000000000000000000000000000000000000000
--- a/20221128/objects-09b.c
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-typedef struct
-{
-} t_base;
-
-typedef struct
-{
- int content;
-} t_integer;
-
-typedef struct
-{
- char *content;
-} t_string;
-
-typedef union
-{
- t_base base;
- t_integer integer;
- t_string string;
-} t_object;
-
-void print_object (t_object *this)
-{
- printf ("Wenn dies eine Integer ist, dann lautet sie: %d.\n", this->integer.content);
- printf ("Wenn dies ein String ist, ist er %zu Zeichen lang.\n",
- strlen (this->string.content));
-}
-
-t_object *new_integer (int i)
-{
- t_object *p = malloc (sizeof (t_integer));
- p->integer.content = i;
- return p;
-}
-
-t_object *new_string (char *s)
-{
- t_object *p = malloc (sizeof (t_string));
- p->string.content = s;
- return p;
-}
-
-int main (void)
-{
- t_object *object[] = { new_integer (42),
- new_string ("Hello, world!"),
- NULL };
-
- for (int i = 0; object[i]; i++)
- print_object (object[i]);
-
- for (int i = 0; object[i]; i++)
- free (object[i]);
-
- return 0;
-}
diff --git a/20221128/objects-09c.c b/20221128/objects-09c.c
deleted file mode 100644
index 6eeff4f335112fea7ef6f4d5b8384a8242f4515b..0000000000000000000000000000000000000000
--- a/20221128/objects-09c.c
+++ /dev/null
@@ -1,61 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-typedef struct
-{
-} t_base;
-
-typedef struct
-{
- int content;
-} t_integer;
-
-typedef struct
-{
- char *content;
-} t_string;
-
-typedef union
-{
- t_base base;
- t_integer integer;
- t_string string;
-} t_object;
-
-void print_object (t_object *this)
-{
- if (this->integer.content < 1000) /* Heuristik --> Aua! =8-O */
- printf ("Integer: %d\n", this->integer.content);
- else
- printf ("String: \"%s\"\n", this->string.content);
-}
-
-t_object *new_integer (int i)
-{
- t_object *p = malloc (sizeof (t_integer));
- p->integer.content = i;
- return p;
-}
-
-t_object *new_string (char *s)
-{
- t_object *p = malloc (sizeof (t_string));
- p->string.content = s;
- return p;
-}
-
-int main (void)
-{
- t_object *object[] = { new_integer (42),
- new_string ("Hello, world!"),
- NULL };
-
- for (int i = 0; object[i]; i++)
- print_object (object[i]);
-
- for (int i = 0; object[i]; i++)
- free (object[i]);
-
- return 0;
-}
diff --git a/20221128/objects-10.c b/20221128/objects-10.c
deleted file mode 100644
index 86787f3d0339bda54baefd062392d8792cd4b2be..0000000000000000000000000000000000000000
--- a/20221128/objects-10.c
+++ /dev/null
@@ -1,76 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#define T_BASE 0
-#define T_INTEGER 1
-#define T_STRING 2
-
-typedef struct
-{
- int type;
- void (*print) (t_object *this);
-} t_base;
-
-typedef struct
-{
- int type;
- void (*print) (t_object *this);
- int content;
-} t_integer;
-
-typedef struct
-{
- int type;
- void (*print) (t_object *this);
- char *content;
-} t_string;
-
-typedef union
-{
- t_base base;
- t_integer integer;
- t_string string;
-} t_object;
-
-void print_integer (t_object *this)
-{
- printf ("Integer: %d\n", this->integer.content);
-}
-
-void print_string (t_object *this)
-{
- printf ("String: \"%s\"\n", this->string.content);
-}
-
-t_object *new_integer (int i)
-{
- t_object *p = malloc (sizeof (t_integer));
- p->integer.type = T_INTEGER;
- p->integer.print = print_integer;
- p->integer.content = i;
- return p;
-}
-
-t_object *new_string (char *s)
-{
- t_object *p = malloc (sizeof (t_string));
- p->string.type = T_STRING;
- p->string.print = print_string;
- p->string.content = s;
- return p;
-}
-
-int main (void)
-{
- t_object *object[] = { new_integer (42),
- new_string ("Hello, world!"),
- NULL };
-
- for (int i = 0; object[i]; i++)
- object[i]->base.print (object[i]);
-
- for (int i = 0; object[i]; i++)
- free (object[i]);
-
- return 0;
-}
diff --git a/20221128/objects-11.c b/20221128/objects-11.c
deleted file mode 100644
index 0a921d8b5c88198cdd07aeb409da6b2a57be33ac..0000000000000000000000000000000000000000
--- a/20221128/objects-11.c
+++ /dev/null
@@ -1,78 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#define T_BASE 0
-#define T_INTEGER 1
-#define T_STRING 2
-
-union t_object;
-
-typedef struct
-{
- int type;
- void (*print) (union t_object *this);
-} t_base;
-
-typedef struct
-{
- int type;
- void (*print) (union t_object *this);
- int content;
-} t_integer;
-
-typedef struct
-{
- int type;
- void (*print) (union t_object *this);
- char *content;
-} t_string;
-
-typedef union t_object
-{
- t_base base;
- t_integer integer;
- t_string string;
-} t_object;
-
-void print_integer (t_object *this)
-{
- printf ("Integer: %d\n", this->integer.content);
-}
-
-void print_string (t_object *this)
-{
- printf ("String: \"%s\"\n", this->string.content);
-}
-
-t_object *new_integer (int i)
-{
- t_object *p = malloc (sizeof (t_integer));
- p->integer.type = T_INTEGER;
- p->integer.print = print_integer;
- p->integer.content = i;
- return p;
-}
-
-t_object *new_string (char *s)
-{
- t_object *p = malloc (sizeof (t_string));
- p->string.type = T_STRING;
- p->string.print = print_string;
- p->string.content = s;
- return p;
-}
-
-int main (void)
-{
- t_object *object[] = { new_integer (42),
- new_string ("Hello, world!"),
- NULL };
-
- for (int i = 0; object[i]; i++)
- object[i]->base.print (object[i]);
-
- for (int i = 0; object[i]; i++)
- free (object[i]);
-
- return 0;
-}
diff --git a/20221128/objects-12.c b/20221128/objects-12.c
deleted file mode 100644
index 3b0dddd0b7eda19d8b0545906dabd76bc9c8a378..0000000000000000000000000000000000000000
--- a/20221128/objects-12.c
+++ /dev/null
@@ -1,69 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-union t_object;
-
-typedef struct
-{
- void (* print) (union t_object *this);
-} t_base;
-
-typedef struct
-{
- void (* print) (union t_object *this);
- int content;
-} t_integer;
-
-typedef struct
-{
- void (* print) (union t_object *this);
- char *content;
-} t_string;
-
-typedef union t_object
-{
- t_base base;
- t_integer integer;
- t_string string;
-} t_object;
-
-void print_integer (t_object *this)
-{
- printf ("Integer: %d\n", this->integer.content);
-}
-
-void print_string (t_object *this)
-{
- printf ("String: \"%s\"\n", this->string.content);
-}
-
-t_object *new_integer (int i)
-{
- t_object *p = malloc (sizeof (t_integer));
- p->integer.print = print_integer;
- p->integer.content = i;
- return p;
-}
-
-t_object *new_string (char *s)
-{
- t_object *p = malloc (sizeof (t_string));
- p->string.print = print_string;
- p->string.content = s;
- return p;
-}
-
-int main (void)
-{
- t_object *object[] = { new_integer (42),
- new_string ("Hello, world!"),
- NULL };
-
- for (int i = 0; object[i]; i++)
- object[i]->base.print (object[i]);
-
- for (int i = 0; object[i]; i++)
- free (object[i]);
-
- return 0;
-}
diff --git a/20221128/objects-14.cpp b/20221128/objects-14.cpp
deleted file mode 100644
index 90329346afd7d1cfd1caad1d267781b25300b4ca..0000000000000000000000000000000000000000
--- a/20221128/objects-14.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#include <stdio.h>
-
-struct TBase
-{
- virtual void print () = 0;
-};
-
-struct TInteger: TBase
-{
- int content;
- virtual void print ();
- TInteger (int i);
-};
-
-struct TString: TBase
-{
- char *content;
- virtual void print ();
- TString (char *s);
-};
-
-void TInteger::print ()
-{
- printf ("Integer: %d\n", content);
-}
-
-void TString::print ()
-{
- printf ("String: \"%s\"\n", content);
-}
-
-TInteger::TInteger (int i)
-{
- content = i;
-}
-
-TString::TString (char *s)
-{
- content = s;
-}
-
-int main (void)
-{
- TBase *object[] = { new TInteger (42),
- new TString ("Hello, world!"),
- NULL };
-
- for (int i = 0; object[i]; i++)
- object[i]->print ();
-
- for (int i = 0; object[i]; i++)
- delete object[i];
-
- return 0;
-}
diff --git a/20221128/pgscript.sty b/20221128/pgscript.sty
deleted file mode 120000
index 95c888478c99ea7fda0fd11ccf669ae91be7178b..0000000000000000000000000000000000000000
--- a/20221128/pgscript.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgscript.sty
\ No newline at end of file
diff --git a/20221128/pgslides.sty b/20221128/pgslides.sty
deleted file mode 120000
index 5be1416f4216f076aa268901f52a15d775e43f64..0000000000000000000000000000000000000000
--- a/20221128/pgslides.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgslides.sty
\ No newline at end of file
diff --git a/20221128/pow-01.c b/20221128/pow-01.c
deleted file mode 100644
index 68429658875b95cfc3204d432abe48276e95ab29..0000000000000000000000000000000000000000
--- a/20221128/pow-01.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-#include <math.h>
-
-int main (void)
-{
- double x = 3.0;
- printf ("x^2 = %lf\n", pow (x, 2.0));
- return 0;
-}
diff --git a/20221128/pow-02.c b/20221128/pow-02.c
deleted file mode 100644
index 23d68909428cc7d04d7269c992e20133a918c2fa..0000000000000000000000000000000000000000
--- a/20221128/pow-02.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-#include <math.h>
-
-int main (void)
-{
- double x = 3.0;
- printf ("sin x = %lf\n", sin (x));
- return 0;
-}
diff --git a/20221128/pow-03.c b/20221128/pow-03.c
deleted file mode 100644
index b83b61b32eb1f9ffca055648bad65e091047199e..0000000000000000000000000000000000000000
--- a/20221128/pow-03.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-#include <math.h>
-
-int main (void)
-{
- double x = 3.0;
- printf ("x^3.5 = %lf\n", pow (x, 3.5));
- return 0;
-}
diff --git a/20221128/pow-04.c b/20221128/pow-04.c
deleted file mode 100644
index 0617af43310580d0acbca2e99b5ff3e1de95c177..0000000000000000000000000000000000000000
--- a/20221128/pow-04.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-#include <math.h>
-
-int main (void)
-{
- double x = 9.0;
- printf ("x^0.5 = %lf\n", pow (x, 0.5));
- return 0;
-}
diff --git a/20221128/pow-05.c b/20221128/pow-05.c
deleted file mode 100644
index 9808de6fda92539fb3f0a80bb46e913edfc71302..0000000000000000000000000000000000000000
--- a/20221128/pow-05.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-#include <math.h>
-
-double my_pow (double x, double a)
-{
- return exp (a * log (x));
-}
-
-int main (void)
-{
- double x = 9.0;
- printf ("x^0.5 = %lf\n", my_pow (x, 0.5));
- return 0;
-}
diff --git a/20221128/pow-06.c b/20221128/pow-06.c
deleted file mode 100644
index 83468217f81917c65fa472c419c14d3c07608209..0000000000000000000000000000000000000000
--- a/20221128/pow-06.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-#include <math.h>
-
-int main (void)
-{
- double x = 3.0;
- printf ("x^2 = %lf\n", x * x);
- return 0;
-}
diff --git a/20221128/pow-07.c b/20221128/pow-07.c
deleted file mode 100644
index ca18127007fed147135436b911b9045bef8d3da6..0000000000000000000000000000000000000000
--- a/20221128/pow-07.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-#include <math.h>
-
-double sqr (double x )
-{
- return x * x;
-}
-
-int main (void)
-{
- double x = 3.0;
- printf ("x^2 = %lf\n", sqr (x));
- return 0;
-}
diff --git a/20221128/pow-08.c b/20221128/pow-08.c
deleted file mode 100644
index 700c632053e97b3adae0ab9f69aa7832678a1232..0000000000000000000000000000000000000000
--- a/20221128/pow-08.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-#include <math.h>
-
-#define G (6.67 * pow (10.0, -11.0))
-
-int main (void)
-{
- printf ("G = %lf\n", G);
- return 0;
-}
diff --git a/20221128/pow-09.c b/20221128/pow-09.c
deleted file mode 100644
index b774b6089add30a68008f561b8652220a6c49ffb..0000000000000000000000000000000000000000
--- a/20221128/pow-09.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-#include <math.h>
-
-#define G (6.67 * pow (10.0, -11.0))
-
-int main (void)
-{
- printf ("G = %lg\n", G);
- return 0;
-}
diff --git a/20221128/pow-10.c b/20221128/pow-10.c
deleted file mode 100644
index c77e6959c14acf7718a0b7a2d5d0c3a148760698..0000000000000000000000000000000000000000
--- a/20221128/pow-10.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-#include <math.h>
-
-#define G 6.67e-11
-
-int main (void)
-{
- printf ("G = %lg\n", G);
- return 0;
-}
diff --git a/20221128/unions-1.c b/20221128/unions-1.c
deleted file mode 100644
index b75a6063b50193e13e9a2fd0ce140db6a8827499..0000000000000000000000000000000000000000
--- a/20221128/unions-1.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-typedef union
-{
- int8_t i;
- uint8_t u;
-} num8_t;
-
-int main (void)
-{
- num8_t test;
- test.i = -1;
- printf ("%d\n", test.u);
- return 0;
-}
diff --git a/20221128/unions-2.c b/20221128/unions-2.c
deleted file mode 100644
index ad96e60b3a4c74f1f77e95aecee657171e288bdd..0000000000000000000000000000000000000000
--- a/20221128/unions-2.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-typedef union
-{
- int64_t i;
- uint64_t u;
-} num8_t;
-
-int main (void)
-{
- num8_t test;
- test.i = -1;
- printf ("%lu\n", test.u);
- return 0;
-}
diff --git a/20221128/unions-3.c b/20221128/unions-3.c
deleted file mode 100644
index be8562a50395e50e007dc1c0b19b98a476935670..0000000000000000000000000000000000000000
--- a/20221128/unions-3.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-typedef union
-{
- char s[8];
- uint64_t x;
-} num_char_t;
-
-int main (void)
-{
- num_char_t test = { "Hello!" };
- printf ("%lx\n", test.x);
- return 0;
-}
diff --git a/20221128/unions-4.c b/20221128/unions-4.c
deleted file mode 100644
index 85ca115d1eebef66b56a7db908f524dd2cc18e1f..0000000000000000000000000000000000000000
--- a/20221128/unions-4.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-typedef union
-{
- char s[8];
- uint64_t x;
-} num_char_t;
-
-int main (void)
-{
- num_char_t test = { "Hello!" };
- printf ("%s\n", test.s);
- return 0;
-}
diff --git a/20221128/unions-5.c b/20221128/unions-5.c
deleted file mode 100644
index e9e8ab798c320a72ac7c08e8e10215b027364aa2..0000000000000000000000000000000000000000
--- a/20221128/unions-5.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-typedef union
-{
- char s[8];
- uint64_t x;
-} num_char_t;
-
-int main (void)
-{
- num_char_t test = { 36762444129608 };
- printf ("%lu\n", test.x);
- return 0;
-}
diff --git a/20221128/unions-6.c b/20221128/unions-6.c
deleted file mode 100644
index dcd1821068bb00db66038bbd8472215469209ea3..0000000000000000000000000000000000000000
--- a/20221128/unions-6.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-typedef union
-{
- char s[8];
- uint64_t x;
-} num_char_t;
-
-int main (void)
-{
- num_char_t test = { x: 36762444129608lu };
- printf ("%s\n", test.s);
- return 0;
-}
diff --git a/20221128/unions-7.c b/20221128/unions-7.c
deleted file mode 100644
index 9c689ec6965d16f8dbf79e9d292e2150ec144440..0000000000000000000000000000000000000000
--- a/20221128/unions-7.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-typedef union
-{
- char s[8];
- uint64_t x;
-} num_char_t;
-
-int main (void)
-{
- num_char_t test;
- test.x = 36762444129608lu;
- printf ("%s\n", test.s);
- return 0;
-}
diff --git a/20221128/unions-8.c b/20221128/unions-8.c
deleted file mode 100644
index e5b6b01db5d8c88b335e4d01728cb976a0afcc0a..0000000000000000000000000000000000000000
--- a/20221128/unions-8.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-typedef union
-{
- char s[8];
- uint64_t x;
-} num_char_t;
-
-int main (void)
-{
- num_char_t test;
- test.x = 36762444129608;
- printf ("%s\n", test.s);
- return 0;
-}
diff --git a/20221205/Makefile-01 b/20221205/Makefile-01
deleted file mode 100644
index 45ab22bf999a86d0681ed79a7f18faa5dd6d4717..0000000000000000000000000000000000000000
--- a/20221205/Makefile-01
+++ /dev/null
@@ -1,2 +0,0 @@
-hello-gtk: hello-gtk.c
- gcc -Wall -O $(pkg-config --cflags gtk+-3.0) hello-gtk.c $(pkg-config --libs gtk+-3.0) -lm -o hello-gtk
diff --git a/20221205/Makefile-02 b/20221205/Makefile-02
deleted file mode 100644
index d7b97c659d91beb4aba4430550ca46fb5a40b0e2..0000000000000000000000000000000000000000
--- a/20221205/Makefile-02
+++ /dev/null
@@ -1,2 +0,0 @@
-hello-gtk: hello-gtk.c
- gcc -Wall -O $(shell pkg-config --cflags gtk+-3.0) hello-gtk.c $(shell pkg-config --libs gtk+-3.0) -lm -o hello-gtk
diff --git a/20221205/aufgabe-1a.c b/20221205/aufgabe-1a.c
deleted file mode 100644
index 61b6e79400afbb8ac0609eb1b72c04b83a0fce41..0000000000000000000000000000000000000000
--- a/20221205/aufgabe-1a.c
+++ /dev/null
@@ -1,50 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- a[0]->type = WITH_WINGS;
- a[0]->name = "duck";
- a[0]->wings = 2;
-
- animal cow;
- a[1] = &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- a[1]->legs = 4;
-
- for (int i = 0; i < 2; i++)
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name,
- ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name,
- ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
-
- return 0;
-}
diff --git a/20221205/aufgabe-1b.c b/20221205/aufgabe-1b.c
deleted file mode 100644
index 2cf3b56f4540f399d3761b0de929d80a1f1de611..0000000000000000000000000000000000000000
--- a/20221205/aufgabe-1b.c
+++ /dev/null
@@ -1,50 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- a[0]->type = WITH_WINGS;
- a[0]->name = "duck";
- ((with_wings *) a[0])->wings = 2;
-
- animal cow;
- a[1] = &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- ((with_legs *) a[1])->legs = 4;
-
- for (int i = 0; i < 2; i++)
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name,
- ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name,
- ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
-
- return 0;
-}
diff --git a/20221205/aufgabe-2.c b/20221205/aufgabe-2.c
deleted file mode 100644
index a1054f2b601850a402dccb6f4878437d1bb6909c..0000000000000000000000000000000000000000
--- a/20221205/aufgabe-2.c
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <stdio.h>
-
-void foreach (int *a, void (*fun) (int x))
-{
- for (int *p = a; *p >= 0; p++)
- fun (*p);
-}
-
-void even_or_odd (int x)
-{
- if (x % 2)
- printf ("%d ist ungerade.\n", x);
- else
- printf ("%d ist gerade.\n", x);
-}
-
-int main (void)
-{
- int numbers[] = { 12, 17, 32, 1, 3, 16, 19, 18, -1 };
- foreach (numbers, even_or_odd);
- return 0;
-}
diff --git a/20221205/aufgabe-3.c b/20221205/aufgabe-3.c
deleted file mode 100644
index 82e5b1ca9e2f896bcbec98bc5c34cdf15d086e26..0000000000000000000000000000000000000000
--- a/20221205/aufgabe-3.c
+++ /dev/null
@@ -1,53 +0,0 @@
-#include <stdio.h>
-
-#define STACK_SIZE 10
-
-int stack[STACK_SIZE];
-int stack_pointer = 0;
-
-void push (int x)
-{
- stack[stack_pointer++] = x;
-}
-
-void show (void)
-{
- printf ("stack content:");
- for (int i = 0; i < stack_pointer; i++)
- printf (" %d", stack[i]);
- if (stack_pointer)
- printf ("\n");
- else
- printf (" (empty)\n");
-}
-
-void insert (int x, int pos)
-{
- for (int i = pos; i < stack_pointer; i++)
- stack[i + 1] = stack[i];
- stack[pos] = x;
- stack_pointer++;
-}
-
-void insert_sorted (int x)
-{
- int i = 0;
- while (i < stack_pointer && x < stack[i])
- i++;
- insert (x, i);
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- show ();
- insert (5, 1);
- show ();
- insert_sorted (42);
- show ();
- insert_sorted (2);
- show ();
- return 0;
-}
diff --git a/20221205/fifo-01.c b/20221205/fifo-01.c
deleted file mode 100644
index 8bce6c07c152381c11ce367027b980a9330be3e0..0000000000000000000000000000000000000000
--- a/20221205/fifo-01.c
+++ /dev/null
@@ -1,31 +0,0 @@
-#include <stdio.h>
-
-#define FIFO_SIZE 10
-
-int fifo[FIFO_SIZE];
-int fifo_pointer = 0;
-
-void push (int x)
-{
- fifo[fifo_pointer++] = x;
-}
-
-int pop (void)
-{
- return fifo[0];
- fifo[0] = fifo[1];
- fifo[1] = fifo[2];
- fifo[2] = fifo[3];
- /* ... */
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/fifo-02.c b/20221205/fifo-02.c
deleted file mode 100644
index f95579893f62180b408ecb10756ac8938b3c9848..0000000000000000000000000000000000000000
--- a/20221205/fifo-02.c
+++ /dev/null
@@ -1,31 +0,0 @@
-#include <stdio.h>
-
-#define FIFO_SIZE 10
-
-int fifo[FIFO_SIZE];
-int fifo_pointer = 0;
-
-void push (int x)
-{
- fifo[fifo_pointer++] = x;
-}
-
-int pop (void)
-{
- fifo[0] = fifo[1];
- fifo[1] = fifo[2];
- fifo[2] = fifo[3];
- /* ... */
- return fifo[0];
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/fifo-03.c b/20221205/fifo-03.c
deleted file mode 100644
index 5214e1b28fb1b060bdaeea7be09e346a644e7f5d..0000000000000000000000000000000000000000
--- a/20221205/fifo-03.c
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <stdio.h>
-
-#define FIFO_SIZE 10
-
-int fifo[FIFO_SIZE];
-int fifo_pointer = 0;
-
-void push (int x)
-{
- fifo[fifo_pointer++] = x;
-}
-
-int pop (void)
-{
- int result = fifo[0];
- fifo[0] = fifo[1];
- fifo[1] = fifo[2];
- fifo[2] = fifo[3];
- /* ... */
- return result;
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/fifo-04.c b/20221205/fifo-04.c
deleted file mode 100644
index 957d5f18f6c8fe9d7c057db3d2467221b9dc463e..0000000000000000000000000000000000000000
--- a/20221205/fifo-04.c
+++ /dev/null
@@ -1,30 +0,0 @@
-#include <stdio.h>
-
-#define FIFO_SIZE 10
-
-int fifo[FIFO_SIZE];
-int fifo_pointer = 0;
-
-void push (int x)
-{
- fifo[fifo_pointer++] = x;
-}
-
-int pop (void)
-{
- int result = fifo[0];
- for (int i = 1; i < FIFO_SIZE; i++)
- fifo[i - 1] = fifo[i];
- return result;
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/fifo-05.c b/20221205/fifo-05.c
deleted file mode 100644
index 092c1cdb5863d5c7bdac98f48ca8527ca3520e6b..0000000000000000000000000000000000000000
--- a/20221205/fifo-05.c
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <stdio.h>
-
-#define FIFO_SIZE 10
-
-int fifo[FIFO_SIZE];
-int fifo_pointer = 0;
-
-void push (int x)
-{
- fifo[fifo_pointer++] = x;
-}
-
-int pop (void)
-{
- int result = fifo[0];
- for (int i = 1; i < FIFO_SIZE; i++)
- fifo[i - 1] = fifo[i];
- return result;
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- push (42);
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/fifo-06.c b/20221205/fifo-06.c
deleted file mode 100644
index 2f055d6ce6df4c2fca950192053a6e008bed38b4..0000000000000000000000000000000000000000
--- a/20221205/fifo-06.c
+++ /dev/null
@@ -1,33 +0,0 @@
-#include <stdio.h>
-
-#define FIFO_SIZE 10
-
-int fifo[FIFO_SIZE];
-int fifo_pointer = 0;
-
-void push (int x)
-{
- fifo[fifo_pointer++] = x;
-}
-
-int pop (void)
-{
- int result = fifo[0];
- for (int i = 1; i < FIFO_SIZE; i++)
- fifo[i - 1] = fifo[i];
- fifo_pointer--;
- return result;
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- push (42);
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/fifo-06a.c b/20221205/fifo-06a.c
deleted file mode 100644
index 6a7b2d3c138908cb7eb06379b9c574f262717af0..0000000000000000000000000000000000000000
--- a/20221205/fifo-06a.c
+++ /dev/null
@@ -1,33 +0,0 @@
-#include <stdio.h>
-
-#define FIFO_SIZE 10
-
-int fifo[FIFO_SIZE];
-int fifo_pointer = 0;
-
-void push (int x)
-{
- fifo[fifo_pointer++] = x;
-}
-
-int pop (void)
-{
- int result = fifo[0];
- for (int i = 1; i < fifo_pointer; i++)
- fifo[i - 1] = fifo[i];
- fifo_pointer--;
- return result;
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- push (42);
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/fifo-07.c b/20221205/fifo-07.c
deleted file mode 100644
index 0d739115c136639f64c4d98c439af7e4d72fe420..0000000000000000000000000000000000000000
--- a/20221205/fifo-07.c
+++ /dev/null
@@ -1,35 +0,0 @@
-#include <stdio.h>
-
-#define FIFO_SIZE 10
-
-int fifo[FIFO_SIZE];
-int fifo_write_pointer = 0;
-int fifo_read_pointer = 0;
-
-void push (int x)
-{
- fifo[fifo_write_pointer++] = x;
- if (fifo_write_pointer >= FIFO_SIZE)
- fifo_write_pointer = 0;
-}
-
-int pop (void)
-{
- int result = fifo[fifo_read_pointer++];
- if (fifo_read_pointer >= FIFO_SIZE)
- fifo_read_pointer = 0;
- return result;
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- push (42);
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/fifo-08.c b/20221205/fifo-08.c
deleted file mode 100644
index b4ff68713645e0a5782b516071022bf71a8c50ac..0000000000000000000000000000000000000000
--- a/20221205/fifo-08.c
+++ /dev/null
@@ -1,50 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#define FIFO_SIZE 10
-
-int fifo[FIFO_SIZE];
-int fifo_write_pointer = 0;
-int fifo_read_pointer = 0;
-
-void push (int x)
-{
- fifo[fifo_write_pointer++] = x;
- if (fifo_write_pointer >= FIFO_SIZE)
- fifo_write_pointer = 0;
- if (fifo_write_pointer == fifo_read_pointer)
- {
- fprintf (stderr, "fifo overflow\n");
- exit (1);
- }
-}
-
-int pop (void)
-{
- if (fifo_read_pointer == fifo_write_pointer)
- {
- fprintf (stderr, "fifo underflow\n");
- exit (1);
- }
- else
- {
- int result = fifo[fifo_read_pointer++];
- if (fifo_read_pointer >= FIFO_SIZE)
- fifo_read_pointer = 0;
- return result;
- }
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- push (42);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/fifo-09.c b/20221205/fifo-09.c
deleted file mode 100644
index 27f77412bac52fd70c52378c25531f03bd93d734..0000000000000000000000000000000000000000
--- a/20221205/fifo-09.c
+++ /dev/null
@@ -1,55 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#define FIFO_SIZE 10
-
-int fifo[FIFO_SIZE];
-int fifo_write_pointer = 0;
-int fifo_read_pointer = 0;
-
-void push (int x)
-{
- int old_fifo_write_pointer = fifo_write_pointer;
- fifo_write_pointer++;
- if (fifo_write_pointer >= FIFO_SIZE)
- fifo_write_pointer = 0;
- if (fifo_write_pointer == fifo_read_pointer)
- {
- fprintf (stderr, "fifo overflow\n");
- exit (1);
- }
- else
- fifo[old_fifo_write_pointer] = x;
-}
-
-int pop (void)
-{
- if (fifo_read_pointer == fifo_write_pointer)
- {
- fprintf (stderr, "fifo underflow\n");
- exit (1);
- }
- else
- {
- int result = fifo[fifo_read_pointer++];
- if (fifo_read_pointer >= FIFO_SIZE)
- fifo_read_pointer = 0;
- return result;
- }
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- for (int i = 0; i < 42; i++)
- push (i);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- push (42);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/hello-gtk.c b/20221205/hello-gtk.c
deleted file mode 100644
index 016867d41e42de57390a21653de467c061e5ded0..0000000000000000000000000000000000000000
--- a/20221205/hello-gtk.c
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <gtk/gtk.h>
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
- gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
- GtkWidget *label = gtk_label_new ("Hello, world!");
- gtk_container_add (GTK_CONTAINER (vbox), label);
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
- gtk_widget_show (button);
- gtk_widget_show (label);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
-}
diff --git a/20221205/hello-gtk.png b/20221205/hello-gtk.png
deleted file mode 120000
index cca99209d86683a9a3b0f70bbc149780bae10ba6..0000000000000000000000000000000000000000
--- a/20221205/hello-gtk.png
+++ /dev/null
@@ -1 +0,0 @@
-../common/hello-gtk.png
\ No newline at end of file
diff --git a/20221205/hp-20221205.pdf b/20221205/hp-20221205.pdf
deleted file mode 100644
index ca3a72255a00f7d3a062ac86a4c0fc4b0fe0ce6f..0000000000000000000000000000000000000000
Binary files a/20221205/hp-20221205.pdf and /dev/null differ
diff --git a/20221205/hp-20221205.tex b/20221205/hp-20221205.tex
deleted file mode 100644
index 9427a3cdf8f5e13f7ef8819c2d8724f98f5f29cc..0000000000000000000000000000000000000000
--- a/20221205/hp-20221205.tex
+++ /dev/null
@@ -1,1184 +0,0 @@
-% hp-20221205.pdf - Lecture Slides on Low-Level Programming
-% Copyright (C) 2012, 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Objektorientierte Programmierung, Datenstrukturen
-
-\documentclass[10pt,t]{beamer}
-
-\usepackage{pgslides}
-\usepackage{pdftricks}
-\usepackage{tikz}
-\usepackage{rotating}
-
-\begin{psinputs}
- \usepackage[utf8]{inputenc}
- \usepackage[german]{babel}
- \usepackage[T1]{fontenc}
- \usepackage{helvet}
- \renewcommand*\familydefault{\sfdefault}
- \usepackage{pstricks,pst-grad}
-\end{psinputs}
-
-\newcommand{\redurl}[1]{\href{#1}{\color{red}\nolinkurl{#1}}}
-
-\title{Hardwarenahe Programmierung}
-\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
-\date{5.\ Dezember 2022}
-
-\begin{document}
-
-\maketitleframe
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \item[\textbf{5}] \textbf{Algorithmen}
- \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
- \begin{itemize}
- \color{medgreen}
- \item[6.0] Dynamische Speicherverwaltung
- \item[6.1] Konzepte und Ziele
- \item[6.2] Beispiel: Zahlen und Buchstaben
- \item[6.3] Unions
- \color{orange}
- \item[6.4] Virtuelle Methoden
- \color{red}
- \item[6.5] Beispiel: Graphische Benutzeroberfläche (GUI)
- \item[6.6] Ausblick: C++
- \end{itemize}
- \item[\textbf{7}] \textbf{Datenstrukturen}
- \end{itemize}
- \vspace*{-1cm}
-
-\end{frame}
-
-\setcounter{section}{5}
-\section{Objektorientierte Programmierung}
-
-\addtocounter{subsection}{-1}
-\subsection{Dynamische Speicherverwaltung}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \begin{itemize}
- \item
- Array: feste Anzahl von Elementen desselben Typs (z.\,B.\ 3 ganze Zahlen)
- \item
- Dynamisches Array: variable Anzahl von Elementen desselben Typs
- \end{itemize}
-
- \bigskip
-
- \begin{lstlisting}
- char *name[] = { "Anna", "Berthold", "Caesar" };
-
- ...
-
- name[3] = "Dieter";
- \end{lstlisting}
-
- \begin{picture}(0,0)
- \color{red}
- \put(0,0){\line(3,1){3.5}}
- \put(0,1){\line(3,-1){3.5}}
- \end{picture}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \bigskip
-
- \begin{lstlisting}
- #include <stdlib.h>
-
- ...
-
- char **name = malloc (3 * sizeof (char *));
- /* Speicherplatz für 3 Zeiger anfordern */
-
- ...
-
- free (name);
- /* Speicherplatz freigeben */
-
- \end{lstlisting}
-
-\end{frame}
-
-\subsection{Konzepte und Ziele}
-
-\begin{frame}
-
- \showsection
- \showsubsection
-
- \begin{itemize}
- \item
-% Array: feste Anzahl von Elementen desselben Typs (z.\,B.\ 3 ganze Zahlen)
- Array: Elemente desselben Typs (z.\,B.\ 3 ganze Zahlen)
-% \item
-% Dynamisches Array: variable Anzahl von Elementen desselben Typs
- \item
- Problem: Elemente unterschiedlichen Typs
- \item
- Lösung: den Typ des Elements zusätzlich speichern \textarrow\ \newterm{Objekt}
- \item
- Problem: Die Elemente sind unterschiedlich groß (Speicherplatz).
- \item
- Lösung: Im Array nicht die Objekte selbst speichern, sondern Zeiger darauf.
- \end{itemize}
- \begin{itemize}
- \item
- Funktionen, die mit dem Objekt arbeiten: \newterm{Methoden}
- \begin{onlyenv}<1>
- \item
- Was die Funktion bewirkt,\\
- hängt vom Typ des Objekts ab
- \item
- Realisierung über endlose \lstinline{if}-Ketten
- \end{onlyenv}
- \begin{onlyenv}<2>
- \item
- Was die Funktion bewirkt
- \begin{picture}(0,0)
- \color{red}
- \put(-4.00,-0.05){\tikz{\draw[thick](0,0.25)--(3.75,-0.05);%
- \draw[thick](-0.1,-0.05)--(3.75,0.3);}}
- \end{picture}%
- Welche Funktion aufgerufen wird,\\
- hängt vom Typ des Objekts ab: \newterm{virtuelle Methode}
- \item
- Realisierung über endlose \lstinline{if}-Ketten%
- \begin{picture}(0,0)
- \color{red}
- \put(-2.75,-0.05){\tikz{\draw[thick](0,0.25)--(2.5,-0.05);%
- \draw[thick](-0.1,-0.05)--(2.5,0.3);}}
- \put(1.5,-1.1){\begin{rotate}{7}\large\bf\textarrow\
- kommt gleich
-% nächste Woche
- \end{rotate}}
- \end{picture}
- Zeiger, die im Objekt gespeichert sind\\
- (Genaugenommen: Tabelle von Zeigern)
- \end{onlyenv}
- \end{itemize}
-
-\end{frame}
-
-\begin{frame}
-
- \showsection
- \showsubsection
-
- \begin{itemize}
- \item
- Problem: Elemente unterschiedlichen Typs
- \item
- Lösung: den Typ des Elements zusätzlich speichern \textarrow\ \newterm{Objekt}
- \item
- \newterm{Methoden\/} und \newterm{virtuelle Methoden}
- \end{itemize}
-
- \begin{itemize}
- \item
- Zeiger auf verschiedene Strukturen\\
- mit einem gemeinsamen Anteil von Datenfeldern\\
- \textarrow\ "`verwandte"' \newterm{Objekte}, \newterm{Klassenhierarchie} von Objekten
- \item
- Struktur, die \emph{nur\/} den gemeinsamen Anteil enthält\\
- \textarrow\ "`Vorfahr"', \newterm{Basisklasse}, \newterm{Vererbung}
- \item
-% Explizite Typumwandlung eines Zeigers auf die Basisklasse\\
-% in einen Zeiger auf die \newterm{abgeleitete Klasse}\\
-% \textarrow\ Man kann ein Array unterschiedlicher Objekte\\
-% \strut\phantom{\textarrow} in einer Schleife abarbeiten.\\
- Zeiger auf die Basisklasse dürfen auf Objekte\\
- der \newterm{abgeleiteten Klasse} zeigen\\
- \textarrow\ \newterm{Polymorphie}
- \end{itemize}
-
-\end{frame}
-
-\subsection{Beispiel: Zahlen und Buchstaben}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \begin{center}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- } t_base;¿
- \end{lstlisting}
- \end{minipage}\\[0.5cm]
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- int content;
- } t_integer;¿
- \end{lstlisting}
- \end{minipage}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- char *content;
- } t_string;¿
- \end{lstlisting}
- \end{minipage}
- \end{center}
-
-\end{frame}
-
-\begin{frame}[fragile]
- \begin{center}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- } t_base;¿
- \end{lstlisting}
- \end{minipage}\\[0.5cm]
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- int content;
- } t_integer;¿
- \end{lstlisting}
- \end{minipage}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- int type;
- char *content;
- } t_string;¿
- \end{lstlisting}
- \end{minipage}\\[0.7cm]
- \begin{onlyenv}<1>
- \begin{minipage}{8cm}
- \begin{lstlisting}[gobble=10]
- ¡t_integer i = { 1, 42 };
- t_string s = { 2, "Hello, world!" };
-
- t_base *object[] = { (t_base *) &i, (t_base *) &s };¿
- \end{lstlisting}
- \end{minipage}%
- \begin{picture}(0,0)
- \color{red}
- \put(-5.4,-0.8){\mbox{$\underbrace{\rule{1.45cm}{0pt}}_{\shortstack{\strut explizite\\Typumwandlung}}$}}
- \end{picture}
- \end{onlyenv}
-% \begin{onlyenv}<2>
-% \begin{minipage}{5cm}
-% \begin{lstlisting}[gobble=10]
-% ¡typedef union
-% {
-% t_base base;
-% t_integer integer;
-% t_string string;
-% } t_object;¿
-% \end{lstlisting}
-% \end{minipage}
-% \end{onlyenv}
- \end{center}
-
-\end{frame}
-
-\subsection{Unions}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Variable teilen sich denselben Speicherplatz.
-
- \medskip
-
- \begin{minipage}[t]{3.7cm}
- \begin{lstlisting}[gobble=6]
- ¡typedef union
- {
- int8_t i;
- uint8_t u;
- } num8_t;¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{4.5cm}
- \begin{lstlisting}[gobble=6]
- ¡int main (void)
- {
- num8_t test;
- test.i = -1;
- printf ("%d\n", test.u);
- return 0;
- }¿
- \end{lstlisting}
- \end{minipage}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Variable teilen sich denselben Speicherplatz.
-
- \medskip
-
- \begin{minipage}[t]{3.7cm}
- \begin{lstlisting}[gobble=6]
- ¡typedef union
- {
- char s[8];
- uint64_t x;
- } num_char_t;¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{4.5cm}
- \begin{lstlisting}[gobble=6]
- ¡int main (void)
- {
- num_char_t test = { "Hello!" };
- printf ("%lx\n", test.x);
- return 0;
- }¿
- \end{lstlisting}
- \end{minipage}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- Variable teilen sich denselben Speicherplatz.
-
- \medskip
-
- \begin{minipage}[t]{3.7cm}
- \begin{lstlisting}[gobble=6]
- ¡typedef union
- {
- t_base base;
- t_integer integer;
- t_string string;
- } t_object;¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{3.0cm}
- \begin{lstlisting}[gobble=6]
-
- ¡typedef struct
- {
- int type;
- } t_base;¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{3.0cm}
- \begin{lstlisting}[gobble=6]
-
- ¡typedef struct
- {
- int type;
- int content;
- } t_integer;¿
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}[t]{3.0cm}
- \begin{lstlisting}[gobble=6]
-
- ¡typedef struct
- {
- int type;
- char *content;
- } t_string;¿
- \end{lstlisting}
- \end{minipage}
-
- \bigskip
-
- \begin{center}
- \begin{minipage}{8.5cm}
- \begin{lstlisting}[gobble=8]
- ¡if (this->base.type == T_INTEGER)
- printf ("Integer: %d\n", this->integer.content);
- else if (this->base.type == T_STRING)
- printf ("String: \"%s\"\n", this->string.content);¿
- \end{lstlisting}
- \end{minipage}
- \end{center}
-
-\end{frame}
-
-\subsection{Virtuelle Methoden}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{lstlisting}
- void print_object (t_object *this)
- {
- if (this->base.type == T_INTEGER)
- printf ("Integer: %d\n", this->integer.content);
- else if (this->base.type == T_STRING)
- printf ("String: \"%s\"\n", this->string.content);
- }
- \end{lstlisting}
-
- \begin{picture}(0,0)
- \color{red}
- \put(9,1.7){\shortstack[l]{if-Kette:\\\strut wird unübersichtlich}}
- \put(1,-2){\mbox{\textarrow}}
- \put(0,-3){\mbox{Zeiger auf Funktionen}}
- \end{picture}
-
- \begin{lstlisting}[xleftmargin=4cm]
- void print_integer (t_object *this)
- {
- printf ("Integer: %d\n", this->integer.content);
- }
-
- void print_string (t_object *this)
- {
- printf ("String: \"%s\"\n", this->string.content);
- }
- \end{lstlisting}
-
-\end{frame}
-
-\begin{frame}[fragile]
- \showsubsection
-
- Zeiger auf Funktionen
-
- \medskip
-
- \begin{lstlisting}
- void (*print) (t_object *this);
- \end{lstlisting}
- \begin{picture}(0,1.2)(0,-0.9)
- \color{red}
- \put(0.95,0.3){\mbox{$\underbrace{\rule{1cm}{0pt}}$}}
- \put(0.2,-0.7){\shortstack{das, worauf print zeigt,\\ist eine Funktion}}
- \end{picture}
-
- \begin{itemize}
- \item
- Objekt enthält Zeiger auf Funktion
- \begin{onlyenv}<1>
- \medskip
- \begin{lstlisting}[gobble=10]
- typedef struct
- {
- void (*print) (union t_object *this);
- int content;
- } t_integer;
- \end{lstlisting}
- \vspace*{-2cm}
- \end{onlyenv}
- \begin{onlyenv}<2->
- \vspace*{-3.5cm} % Why doesn't a picture environment work here??? :-(
- \begin{lstlisting}[gobble=10,xleftmargin=5.5cm]
- typedef struct
- {
- void (*print) (union t_object *this);
- int content;
- } t_integer;
- \end{lstlisting}
- \vspace*{0.85cm}
- \bigskip
- \smallskip
- \end{onlyenv}
- \pause
- \item
- Konstruktor initialisiert diesen Zeiger
- \begin{onlyenv}<2>
- \medskip
- \begin{lstlisting}[gobble=10]
- t_object *new_integer (int i)
- {
- t_object *p = malloc (sizeof (t_integer));
- p->integer.print = print_integer;
- p->integer.content = i;
- return p;
- }
- \end{lstlisting}
- \vspace*{-2cm}
- \end{onlyenv}
- \pause
- \item
- Aufruf: "`automatisch"' die richtige Funktion
- \begin{onlyenv}<3>
- \medskip
- \begin{lstlisting}[gobble=10]
- for (int i = 0; object[i]; i++)
- object[i]->base.print (object[i]);
- \end{lstlisting}
- \end{onlyenv}
- \pause
- \medskip
- \item
- in größeren Projekten:\\
- Objekt enthält Zeiger auf Tabelle von Funktionen
- \end{itemize}
-\end{frame}
-
-\subsection{Beispiel: Graphische Benutzeroberfläche (GUI)}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \scriptsize
- \begin{lstlisting}
- #include <gtk/gtk.h>
-
- int main (int argc, char **argv)
- {
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
- gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
- GtkWidget *label = gtk_label_new ("Hello, world!");
- gtk_container_add (GTK_CONTAINER (vbox), label);
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
- gtk_widget_show (button);
- gtk_widget_show (label);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
- }
- \end{lstlisting}
-
- \vspace*{-6cm}\strut\hfill
- \includegraphics[scale=0.85]{hello-gtk.png}\\[2cm]
- \begin{flushright}
- \normalsize\bf Praktikumsversuch:\\
- Objektorientiertes Zeichenprogramm
- \end{flushright}
-
-\end{frame}
-
-\subsection{Ausblick: C++}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{center}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- void (*print) (union t_object *this);
- } t_base;¿
- \end{lstlisting}
- \end{minipage}\\[0.5cm]
- \begin{minipage}{5.5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- void (*print) (...);
- int content;
- } t_integer;¿
- \end{lstlisting}
- \end{minipage}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- void (*print) (union t_object *this);
- char *content;
- } t_string;¿
- \end{lstlisting}
- \end{minipage}
- \end{center}
-
-\end{frame}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{center}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡struct TBase
- {
- virtual void print (void);
- };¿
- \end{lstlisting}
- \end{minipage}\\[0.5cm]
- \begin{minipage}{5.5cm}
- \begin{lstlisting}[gobble=8]
- ¡struct TInteger: public TBase
- {
- virtual void print (void);
- int content;
- };¿
- \end{lstlisting}
- \end{minipage}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡struct TString: public TBase
- {
- virtual void print (void);
- char *content;
- };¿
- \end{lstlisting}
- \end{minipage}
- \end{center}
-
-\end{frame}
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \item[\textbf{5}] \textbf{Algorithmen}
- \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
- \begin{itemize}
- \vspace*{-\smallskipamount}
- \item[\dots]
- \item[6.3] Unions
- \color{medgreen}
- \item[6.4] Virtuelle Methoden
- \item[6.5] Beispiel: Graphische Benutzeroberfläche (GUI)
- \item[6.6] Ausblick: C++
- \end{itemize}
- \item[\textbf{7}] \textbf{Datenstrukturen}
- \begin{itemize}
- \color{red}
- \item[7.1] Stack und FIFO
- \item[7.2] Verkettete Listen
- \item[7.3] Bäume
- \end{itemize}
- \vspace*{-1cm}
- \end{itemize}
-
-\end{frame}
-
-\section{Datenstrukturen}
-\subsection{Stack und FIFO}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \begin{minipage}{0.48\textwidth}
- Im letzten Praktikumsversuch:
- \begin{itemize}
- \item
- Array nur zum Teil benutzt
- \item
- Variable speichert genutzte Länge
- \item
- Elemente hinten anfügen\\
- oder entfernen
- \arrowitem
- Stack\\
- \strut
- \end{itemize}
- \bigskip
- \begin{itemize}
- \item
- hinten anfügen/entfernen: $\mathcal{O}(1)$\hspace*{-1cm}
- \item
- vorne oder in der Mitte einfügen/entfernen: $\mathcal{O}(n)$
- \end{itemize}
- \end{minipage}\hfill
- \begin{minipage}{0.52\textwidth}
- Auch möglich:
- \begin{itemize}
- \item
- Array nur zum Teil benutzt
- \item
- 2 Variable speichern\\genutzte Länge (ringförmig)
- \item
- Elemente hinten anfügen\\
- oder vorne entfernen
- \arrowitem
- FIFO
- \end{itemize}
- \bigskip
- \begin{itemize}
- \item
- vorne oder hinten\\
- anfügen oder entfernen: $\mathcal{O}(1)$
- \item
- in der Mitte einfügen/entfernen: $\mathcal{O}(n)$
- \end{itemize}
- \end{minipage}\hspace*{-1.5mm}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \bigskip
-
- \begin{minipage}[b]{6cm}
- \begin{center}
- "`First In -- First Out"'
-
- \bigskip
-
- \begin{picture}(6,4)
- \thicklines
- \color{structure}
- \put(0.5,0){\line(1,0){5}}
-
- \put(3.5,0){\only<1-5>{\line(0,1){1}}}
- \put(4.5,0){\only<1-4>{\line(0,1){1}}}
- \put(3.5,1){\only<1-4>{\line(1,0){1}}}
- \put(4.0,0.5){\only<1-4>{\makebox(0,0){\lstinline{3}}}}
- \put(3.0,1.5){\only<1>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
- \put(3.0,1.5){\only<1>{\makebox(0,0)[b]{\lstinline{push (3)}}}}
-
- \put(2.5,0){\only<2-6>{\line(0,1){1}}}
- \put(2.5,1){\only<2-5>{\line(1,0){1}}}
- \put(3.0,0.5){\only<2-5>{\makebox(0,0){\lstinline{7}}}}
- \put(2.0,1.5){\only<2>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
- \put(2.0,1.5){\only<2>{\makebox(0,0)[b]{\lstinline{push (7)}}}}
-
- \put(1.5,0){\only<3-6>{\line(0,1){1}}}
- \put(1.5,1){\only<3-6>{\line(1,0){1}}}
- \put(2.0,0.5){\only<3-6>{\makebox(0,0){\lstinline{137}}}}
- \put(1.0,1.5){\only<3>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
- \put(1.0,1.5){\only<3>{\makebox(0,0)[b]{\lstinline{push (137)}}}}
-
- \put(4.55,1.05){\only<4>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
- \put(5.00,1.60){\only<4>{\makebox(0,0)[b]{\lstinline{pop ()}: 3}}}
-
- \put(3.55,1.05){\only<5>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
- \put(4.00,1.60){\only<5>{\makebox(0,0)[b]{\lstinline{pop ()}: 7}}}
-
- \put(2.55,1.05){\only<6>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
- \put(3.00,1.60){\only<6>{\makebox(0,0)[b]{\lstinline{pop ()}: 137}}}
- \end{picture}
-
- \bigskip
-
- FIFO = Queue = Reihe
- \end{center}
- \end{minipage}\hfill
- \begin{minipage}[b]{6cm}
- \begin{center}
- "`Last In -- First Out"'
-
- \bigskip
-
- \begin{picture}(6,4)
- \thicklines
- \color{structure}
- \put(1.5,0){\line(1,0){3}}
-
- \put(2.5,0){\line(0,1){1}}
- \put(3.5,0){\line(0,1){1}}
- \put(2.5,1){\line(1,0){1}}
- \put(3.0,0.5){\makebox(0,0){\lstinline{3}}}
- \put(2.0,1.5){\only<1>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
- \put(2.0,1.5){\only<1>{\makebox(0,0)[b]{\lstinline{push (3)}}}}
-
- \put(2.5,1){\only<2-5>{\line(0,1){1}}}
- \put(3.5,1){\only<2-5>{\line(0,1){1}}}
- \put(2.5,2){\only<2-5>{\line(1,0){1}}}
- \put(3.0,1.5){\only<2-5>{\makebox(0,0){\lstinline{7}}}}
- \put(2.0,2.5){\only<2>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
- \put(2.0,2.5){\only<2>{\makebox(0,0)[b]{\lstinline{push (7)}}}}
-
- \put(2.5,2){\only<3-4>{\line(0,1){1}}}
- \put(3.5,2){\only<3-4>{\line(0,1){1}}}
- \put(2.5,3){\only<3-4>{\line(1,0){1}}}
- \put(3.0,2.5){\only<3-4>{\makebox(0,0){\lstinline{137}}}}
- \put(2.0,3.5){\only<3>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
- \put(2.0,3.5){\only<3>{\makebox(0,0)[b]{\lstinline{push (137)}}}}
-
- \put(3.55,3.05){\only<4>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
- \put(4.00,3.60){\only<4>{\makebox(0,0)[b]{\lstinline{pop ()}: 137}}}
-
- \put(3.55,2.05){\only<5>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
- \put(4.00,2.60){\only<5>{\makebox(0,0)[b]{\lstinline{pop ()}: 7}}}
-
- \put(3.55,1.05){\only<6>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
- \put(4.00,1.60){\only<6>{\makebox(0,0)[b]{\lstinline{pop ()}: 3}}}
- \end{picture}
-
- \bigskip
-
- LIFO = Stack = Stapel
- \end{center}
- \end{minipage}
-
-%
-% \dots
-
-\end{frame}
-
-\iffalse
-
-\begin{frame}
-
- \showsection
- \showsubsection
-
- \bigskip
-
- \begin{minipage}[t]{6cm}
- Array (Stack, FIFO):\\
- in der Mitte einfügen
- \begin{center}
- \begin{picture}(6,3.8)
- \thicklines
- \color{structure}
- \put(1.5,0){\line(1,0){3}}
-
- \put(2.5,0){\line(0,1){3}}
- \put(3.5,0){\line(0,1){3}}
- \put(2.5,1){\line(1,0){1}}
- \put(3.0,0.5){\makebox(0,0){\lstinline{3}}}
- \put(2.5,1){\line(1,0){1}}
- \put(3.0,1.5){\makebox(0,0){\lstinline{7}}}
- \put(2.5,2){\line(1,0){1}}
- \put(3.0,2.5){\makebox(0,0){\lstinline{137}}}
- \put(2.5,3){\line(1,0){1}}
-
- \put(1.5,1.5){\makebox(0,0)[b]{\lstinline{push (5)}}}
- \put(1.5,1.45){\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.95,-0.45);}}}
-
- \put(3.55,2.5){\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)..controls(0.5,0.45)..(0,0.9);}}}
- \put(3.55,1.5){\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)..controls(0.5,0.45)..(0,0.9);}}}
-
- \pause
- \color{red}
- \put(4.1,3.0){\makebox(0,0)[l]{\textbf{1.}}}
- \put(4.1,2.0){\makebox(0,0)[l]{\textbf{2.}}}
- \put(1.5,1.9){\makebox(0,0)[b]{\textbf{3.}}}
-
- \pause
- \put(6.0,1.5){\makebox(0,0)[tl]{$\mathcal{O}(n)$}}
- \put(5.95,1.45){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-1.3,0.4);}}}
- \put(5.95,1.49){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-1.3,1.1);}}}
- \end{picture}
- \end{center}
- \end{minipage}\pause\hfill
- \begin{minipage}[t]{5cm}
- In Array (Stack, FIFO) \dots
- \begin{itemize}
- \item
- einfügen: $\mathcal{O}(n)$
- \item
- suchen: $\mathcal{O}(n)$
- \item
- geschickt suchen: $\mathcal{O}(\log n)$
- \item
- beim Einfügen sortieren:\\
- $\mathcal{O}(n \log n)$ \hspace*{-1.8cm}\tikz{\draw[red](-1.8,0)--(0,0.2);\draw[red](-1.8,0.2)--(0,0);}
- $\mathcal{O}(n^2)$
- \end{itemize}
- \end{minipage}
-
-\end{frame}
-
-\subsection{Verkettete Listen}
-
-\begin{frame}
-
- \showsection
- \showsubsection
-
- \begin{tikzpicture}
- \color{structure}
- \node(first) at (0,0.5) {first};
- \node[shape=rectangle,draw,line width=1pt](3) at (1,2) {3};
- \node[shape=rectangle,draw,line width=1pt](5) at (2,1) {5};
- \node[shape=rectangle,draw,line width=1pt](7) at (3,2) {7};
- \node[shape=rectangle,draw,line width=1pt](137) at (5,2) {137};
- \node(NULL) at (7,2) {NULL};
- \draw[-latex](first)--(3);
- \only<1>{\draw[-latex](3)--(7);}
- \only<2>{\draw[-latex](3) to[out=0] (5);}
- \only<2>{\draw[-latex](5) to[in=180] (7);}
- \draw[-latex](7)--(137);
- \draw[-latex](137)--(NULL);
- \end{tikzpicture}
- \begin{itemize}
- \item
- Jeder Datensatz enthält einen Zeiger auf das nächste Element.
- \item
- Beim letzten Element zeigt der Zeiger auf \lstinline{NULL}.
- \item
- Eine Variable zeigt auf das erste Element.
- \item
- Wenn die Liste leer ist, zeigt die Variable auf \lstinline{NULL}.
- \arrowitem
- (einfach) \textbf{verkettete Liste}
- \end{itemize}
-
-\end{frame}
-
-\begin{frame}
-
- \showsection
- \showsubsection
-
- \begin{minipage}[t]{5cm}
- In Array (Stack, FIFO) \dots
- \begin{itemize}
- \item
- in der Mitte einfügen: $\mathcal{O}(n)$
- \item
- wahlfreier Zugriff: $\mathcal{O}(1)$
- \item
- suchen: $\mathcal{O}(n)$
- \item
- geschickt suchen: $\mathcal{O}(\log n)$
- \item
- beim Einfügen sortieren:\\
- $\mathcal{O}(n \log n)$ \hspace*{-1.8cm}\tikz{\draw[red](-1.8,0)--(0,0.2);\draw[red](-1.8,0.2)--(0,0);}
- $\mathcal{O}(n^2)$
- \end{itemize}
- \end{minipage}\hfill
- \begin{minipage}[t]{6cm}
- In (einfach) verkettete/r Liste \dots
- \begin{itemize}
- \item
- in der Mitte einfügen: $\mathcal{O}(1)$
- \item
- wahlfreier Zugriff: $\mathcal{O}(n)$
- \item
- suchen: $\mathcal{O}(n)$
- \item
- geschickt \hspace*{-1.7cm}\tikz{\draw[red](-1.7,0)--(0,0.2);\draw[red](-1.7,0.2)--(0,0);}
- suchen: {\color{red}$\mathcal{O}(n)$}
- \item
- beim Einfügen sortieren:
- $\mathcal{O}(n \log n)$ \hspace*{-1.8cm}\tikz{\draw[red](-1.8,0)--(0,0.2);\draw[red](-1.8,0.2)--(0,0);}
- $\mathcal{O}(n^2)$
- \end{itemize}
- \end{minipage}
- \pause
- \medskip
- \begin{center}
- \begin{minipage}[t]{6cm}
- In (ausbalancierten) Bäumen \dots
- \begin{itemize}
- \item
- in der Mitte einfügen: $\mathcal{O}(\log n)$
- \item
- wahlfreier Zugriff: $\mathcal{O}(\log n)$
- \item
- suchen: $\mathcal{O}(\log n)$
- \item
- beim Einfügen sortieren:
- $\mathcal{O}(n \log n)$
- \end{itemize}
- \end{minipage}
- \end{center}
- \vspace*{-1cm}
-
-\end{frame}
-
-\subsection{Bäume}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \begin{minipage}[t]{5cm}
- \vspace*{-6cm}
- \begin{lstlisting}[gobble=6]
- ¡typedef struct node
- {
- int content;
- struct node *left, *right;
- } node;¿
- \end{lstlisting}
-% \bigskip
- \bigskip
- \begin{onlyenv}<6->
- \begin{itemize}
- \item
- Einfügen: rekursiv, $\mathcal{O}(\log n)$
- \item
- Suchen: rekursiv, $\mathcal{O}(\log n)$
- \item
- beim Einfügen sortieren:\\
- rekursiv, $\mathcal{O}(n\log n)$
- \begin{onlyenv}<7->
- \smallskip
- \item
- {\color{red}
- \emph{Worst Case\/}: $\mathcal{O}(n^2)$\\
- vorher bereits sortiert}\\
- \textarrow\ balancierte Bäume\\
- \hspace*{2.15em}Anwendung: Datenbanken\hspace*{-2cm}
- \end{onlyenv}
- \end{itemize}
- \vspace*{-1cm}
- \end{onlyenv}
- \end{minipage}\hfill
- \begin{minipage}[t]{7cm}
- \begin{center}
- \begin{tikzpicture}
- \color{structure}
- \node(root) at (0,0) {\lstinline{node *root;}};
- \begin{onlyenv}<2>
- \node(3) at (-2,-3) {\lstinline{NULL}};
- \node(137) at (2,-3) {\lstinline{NULL}};
- \end{onlyenv}
- \begin{onlyenv}<2->
- \node[shape=rectangle,draw,line width=1pt](7) at (0,-1.5) {7};
- \draw[-latex](root)--(7);
- \draw[-latex](7)--(3);
- \draw[-latex](7)--(137);
- \end{onlyenv}
- \begin{onlyenv}<3>
- \node(3) at (-2,-3) {\lstinline{NULL}};
- \end{onlyenv}
- \begin{onlyenv}<3->
- \node[shape=rectangle,draw,line width=1pt](137) at (2,-3) {137};
- \node(137_left) at (1,-4.5) {\lstinline{NULL}};
- \node(137_right) at (3,-4.5) {\lstinline{NULL}};
- \draw[-latex](137)--(137_left);
- \draw[-latex](137)--(137_right);
- \end{onlyenv}
- \begin{onlyenv}<4>
- \node(5) at (-1,-4.5) {\lstinline{NULL}};
- \end{onlyenv}
- \begin{onlyenv}<4->
- \node[shape=rectangle,draw,line width=1pt](3) at (-2,-3) {3};
- \node(3_left) at (-3,-4.5) {\lstinline{NULL}};
- \draw[-latex](3)--(3_left);
- \draw[-latex](3)--(5);
- \end{onlyenv}
- \begin{onlyenv}<5->
- \node[shape=rectangle,draw,line width=1pt](5) at (-1,-4.5) {5};
- \node(5_left) at (-2,-6) {\lstinline{NULL}};
- \node(5_right) at (0,-6) {\lstinline{NULL}};
- \draw[-latex](5)--(5_left);
- \draw[-latex](5)--(5_right);
- \end{onlyenv}
- \end{tikzpicture}
- \end{center}
- \end{minipage}
-
-\end{frame}
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \item[\textbf{5}] \textbf{Algorithmen}
- \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
- \item[\textbf{7}] \textbf{Datenstrukturen}
- \begin{itemize}
- \color{medgreen}
- \item[7.1] Stack und FIFO
- \item[7.2] Verkettete Listen
- \item[7.3] Bäume
- \end{itemize}
- \end{itemize}
-
-\end{frame}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \item[\textbf{5}] \textbf{Algorithmen}
- \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
- \item[\textbf{7}] \textbf{Datenstrukturen}
- \begin{itemize}
- \item[7.1] Stack und FIFO
- \item[7.2] Verkettete Listen
- \item[7.3] Bäume
- \end{itemize}
- \end{itemize}
-
- \begin{flushright}
- \large\bf\em\color{medgreen}Vielen Dank für Ihre Aufmerksamkeit\\
- und viel Erfolg bei den Prüfungen!
- \end{flushright}
-
-\end{frame}
-
-\fi
-
-\end{document}
diff --git a/20221205/hp-2022ws-p4.pdf b/20221205/hp-2022ws-p4.pdf
deleted file mode 100644
index 4e3f925f9b82012b27bbcd75e66036063d25902b..0000000000000000000000000000000000000000
Binary files a/20221205/hp-2022ws-p4.pdf and /dev/null differ
diff --git a/20221205/hp-2022ws-p4.tex b/20221205/hp-2022ws-p4.tex
deleted file mode 100644
index 1e6a343b0f1fa6b7c8a3601fc81af5dcbb5c17d5..0000000000000000000000000000000000000000
--- a/20221205/hp-2022ws-p4.tex
+++ /dev/null
@@ -1,224 +0,0 @@
-% hp-2022ws-p4.pdf - Labor Notes on Low-Level Programming
-% Copyright (C) 2014, 2015, 2016, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Versuch 4: Objektorientiertes Grafik-Programm
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-\usepackage{multicol}
-\usepackage{amsmath}
-\usepackage{sfmath}
-
-\sloppy
-%\pagestyle{empty}
-\newcommand{\sep}{~$\cdot$~}
-\newcommand{\mylicense}{CC-by-sa (Version 3.0) oder GNU GPL (Version 3 oder höher)}
-
-\begin{document}
-
- \makebox(0,0.005)[tl]{\includegraphics[scale=0.72]{logo-hochschule-bochum-cvh-text-v2.pdf}}\hfill
- \makebox(0,0)[tr]{\includegraphics[scale=0.5]{logo-hochschule-bochum.pdf}}
- \par\bigskip\bigskip
- \begin{center}
- \Large\textbf{Praktikumsversuch 4: Objektorientiertes Grafik-Programm}
- \par\medskip
- \normalsize Hardwarenahe Programmierung\sep
- Wintersemester 2022/23\sep
- Prof.~Dr.~Peter Gerwinski
- \end{center}
-
- Aufgabe: Schreiben Sie ein GTK-Programm,
- mit dem man verschiedene Objekte (z.\,B.\ Rechtecke, Kreise, Dreiecke)
- in eine Grafik einfügen und nachträglich verändern kann
- (z.\,B.\ Position, Größe, Farbe).
-
- (Beispiel: Ich füge zunächst zwei Rechtecke und einen Kreis in eine Grafik ein,
- wähle anschließend das erste Rechteck aus und ändere dessen Farbe.)
-
- \bigskip
-
- Hinweise:
- \vspace*{-\medskipamount}
-
- \begin{itemize}
- \item
- Das Beispielprogramm \gitfile{hp}{2022ws/20221128}{objects-08.c}
- und seine Nachfolger zeigen,
- wie man in C verschiedenartige Objekte
- in einem Array von Zeigern verwaltet.
- \item
- Das Beispielprogramm \gitfile{hp}{2022ws/20221031}{gtk-06.c} zeigt,
- wie man mit Hilfe der GUI-Bibliothek GTK
- verschiedene Objekte in ein Fenster zeichnet.
- \item
- Das Beispielprogramm \gitfile{hp}{2022ws/20221031}{gtk-07.c} zeigt,
- wie man in der GUI-Bibliothek GTK
- Tastatur- und Maus-Eingaben entgegennimmt und verarbeitet.
- \item
- Das Auswählen eines bereits vorhandenen Objekts geht am einfachsten
- mittels Tastatur-Eingaben (z.\,B.\ Ziffer 1 für das erste Objekt usw.).
- Auswahl mit der Maus ist auch möglich, aber schwieriger.
- \item
- Mit Hilfe der Funktion \lstinline{gtk_widget_queue_draw()}
- teilen Sie GTK mit, daß Sie ein \lstinline{GtkWidget}
- neu zeichnen lassen möchten.
- \item
- Das Compilieren eines GTK-Programms
- (z.\,B.\ \gitfile{hp}{2022ws/20221031}{gtk-07.c}) geschieht wie folgt:
- \begin{lstlisting}[style=cmd,gobble=8]
- gcc $(pkg-config --cflags gtk+-3.0) -Wall -O gtk-07.c \
- $(pkg-config --libs gtk+-3.0) -o gtk-07
- \end{lstlisting}
- (Den Backslash am Ende der ersten Zeile entfällt,
- wenn Sie den ganzen Befehl in eine einzige Zeile schreiben.)
-% \item
-% \textbf{Online-Abgabe:}
-% Ihre Quelltexte mit den Lösungen der Praktikumsaufgabe schicken Sie bitte
-% per E-Mail an \file{peter.gerwinski@hs-bochum.de}
-% mit dem \textbf{Betreff:} \lstinline[style=terminal]{Eelei7ri}
-% unter Angabe von Name, Matrikel-Nummer,
-% Studiengang (MI/MP/TI) und Studienmodell (KIA/KIS/GS).
- \end{itemize}
-
- \bigskip
- \textbf{GTK unter GNU/Linux}
- \begin{itemize}
- \item
- Installieren Sie das Entwickler-Paket für GTK-3,\\
- z.\,B.\ unter Debian GNU/Linux und darauf basierenden Systemen:
- \begin{lstlisting}[style=cmd,gobble=8]
- apt-get install libgtk-3-dev
- \end{lstlisting}
- \end{itemize}
-
- \bigskip
- \goodbreak
- \textbf{GTK unter MacOS X}
- \begin{itemize}
- \item
- Zuerst den Paketmanager "`Homebrew"' installieren:
- \begin{lstlisting}[style=cmd,gobble=8]
- /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/
- Homebrew/install/HEAD/install.sh)"
- \end{lstlisting}
- (Die URL nicht trennen, sondern in einer Zeile schreiben.)
- \item
- Danach mit Hilfe von \lstinline[style=cmd]{brew} GTK installieren:
- \begin{lstlisting}[style=cmd,gobble=8]
- brew install gtk+3
- \end{lstlisting}
- \end{itemize}
-
- \bigskip
- \goodbreak
- \textbf{GTK unter Microsoft Windows: Cygwin}
- \begin{itemize}
- \item
- Im Cygwin-Setup-Programm die Pakete \file{libgtk3-devel},
- \file{xorg-server} und \file{dbus-x11} installieren.
- \item
- Bevor Sie GTK-Programme starten können,
- müssen Sie einmalig den X-Server starten:
- \begin{lstlisting}[style=cmd,gobble=8]
- XWin -multiwindow &
- \end{lstlisting}
- \item
- Bevor Sie GTK-Programme starten können,
- müssen Sie einmalig pro Shell-Sitzung\\
- die \lstinline[style=cmd]{DISPLAY}-Variable setzen:
- \begin{lstlisting}[style=cmd,gobble=8]
- export DISPLAY=:0.0
- \end{lstlisting}
- \end{itemize}
-
- \bigskip
- \goodbreak
- \textbf{GTK unter Microsoft Windows: MinGW}
- \begin{itemize}
- \item
- Installieren Sie \file{MSYS2} (Installer).
- \item
- Installieren Sie von der MinGW-Shell aus GTK
- und weitere Entwicklungswerkzeuge:
- \begin{lstlisting}[style=cmd,gobble=8]
- pacman -S mingw-w64-x86_64-gcc
- pacman -S mingw-w64-x86_64-gtk3
- pacman -S mingw-w64-x86_64-pkg-config
- \end{lstlisting}
- \item
- Falls nötig, ergänzen Sie in der MinGW-Shell
- den Pfad zu den neu installierten Programmen:
- \begin{lstlisting}[style=cmd,gobble=8]
- export PATH=$PATH:/mingw64/bin
- \end{lstlisting}
- \end{itemize}
-
- \bigskip
- \goodbreak
- \textbf{GTK unter Microsoft Windows: WSL}
- \begin{itemize}
- \item
- Installieren Sie die GTK-Entwicklungswerkzeuge in ihrer Linux-Umgebung (siehe oben).
- \item
- Installieren Sie einen X-Server für Ihr MS-Windows-System, z.\,B.\ \file{Xming}.
- \item
- Starten Sie Ihren X-Server mit \file{XLaunch}
- und wählen Sie \emph{no access control} aus.
- \item
- Bevor Sie GTK-Programme starten können,
- müssen Sie einmalig pro Shell-Sitzung\\
- die \lstinline[style=cmd]{DISPLAY}-Variable setzen:
- \begin{lstlisting}[style=cmd,gobble=8]
- export DISPLAY=$(cat /etc/resolv.conf \
- | grep nameserver | awk '{print $2}'):0
- \end{lstlisting}
- (Der Backslash ist ein Zeilen-Verlängerungszeichen. Wenn Sie den gesamten\\
- Befehl in einer Zeile eingeben, entfällt der Backslash.)
- \end{itemize}
-
- \bigskip
-
- \strut\hfill\emph{Viel Erfolg!}
-
- \vfill
-
- \begingroup
-
- \small
-
- \setlength{\leftskip}{3cm}
-
- Stand: 8.\ Dezember 2022
-
-% Soweit nicht anders angegeben:\\
- Copyright \copyright\ 2014, 2015, 2016, 2018, 2019, 2020, 2021, 2022\quad Peter Gerwinski\\
- Lizenz: \mylicense
-
- Sie können diese Praktikumsunterlagen einschließlich \LaTeX-Quelltext
-% und Beispielprogramme\\
- herunterladen unter:\\
- \url{https://gitlab.cvh-server.de/pgerwinski/hp}
-
- \endgroup
-
-\end{document}
diff --git a/20221205/hp-musterloesung-20221205.pdf b/20221205/hp-musterloesung-20221205.pdf
deleted file mode 100644
index a1baa1c8ee79891261b0d4c1611ea1ae83295d62..0000000000000000000000000000000000000000
Binary files a/20221205/hp-musterloesung-20221205.pdf and /dev/null differ
diff --git a/20221205/hp-musterloesung-20221205.tex b/20221205/hp-musterloesung-20221205.tex
deleted file mode 100644
index 9de50dc82f9e98ca9c45637187963379b654c6c0..0000000000000000000000000000000000000000
--- a/20221205/hp-musterloesung-20221205.tex
+++ /dev/null
@@ -1,499 +0,0 @@
-% hp-musterloesung-20221205.pdf - Solutions to the Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Objektorientierte Tier-Datenbank (Ergänzung), Iterationsfunktionen, Stack-Operationen
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\begin{document}
-
- \section*{Hardwarenahe Programmierung\\
- Musterlösung zu den Übungsaufgaben -- 5.\ Dezember 2022}
-
- \exercise{Objektorientierte Tier-Datenbank (Ergänzung)}
-
- Diese Aufgabe ist eine Neuauflage
- der Übungsaufgabe 3 vom 28.\ November 2022,
- ergänzt um die Teilaufgaben (e) bis (g).
-
- \medskip
-
- Das auf der nächsten Seite dargestellte Programm
- (Datei: \gitfile{hp}{2022ws/20221205}{aufgabe-1a.c})
- soll Daten von Tieren verwalten.
-
- Beim Compilieren erscheinen die folgende Fehlermeldungen:
- \begin{lstlisting}[style=terminal]
- $ ¡gcc -std=c99 -Wall -O aufgabe-1a.c -o aufgabe-1a¿
- aufgabe-1a.c: In function 'main':
- aufgabe-1a.c:31: error: 'animal' has no member named 'wings'
- aufgabe-1a.c:37: error: 'animal' has no member named 'legs'
- \end{lstlisting}
-
- Der Programmierer nimmt die auf der nächsten Seite in Rot dargestellten Ersetzungen vor\\
- (Datei: \gitfile{hp}{2022ws/20221205}{aufgabe-1b.c}).
- Daraufhin gelingt das Compilieren, und die Ausgabe des Programms lautet:
- \begin{lstlisting}[style=terminal]
- $ ¡gcc -std=c99 -Wall -O aufgabe-1b.c -o aufgabe-1b¿
- $ ¡./aufgabe-1b¿
- A duck has 2 legs.
- Error in animal: cow
- \end{lstlisting}
-
- \begin{itemize}
- \color{gray}
- \item[(a)]
- Erklären Sie die o.\,a.\ Compiler-Fehlermeldungen.
- % \points{2}
- \item[(b)]
- Wieso verschwinden die Fehlermeldungen nach den o.\,a.\ Ersetzungen?
- % \points{3}
- \item[(c)]
- Erklären Sie die Ausgabe des Programms.
- % \points{5}
- \item[(d)]
- Beschreiben Sie -- in Worten und/oder als C-Quelltext -- einen Weg,
- das Programm so zu berichtigen, daß es die Eingabedaten
- (``A duck has 2 wings. A cow has 4 legs.'') korrekt speichert und ausgibt. %\\
- % \points{4}
- \color{black}
- \item[(e)]
- Schreiben Sie das Programm so um,
- daß es keine expliziten Typumwandlungen mehr benötigt.\par
- Hinweis: Verwenden Sie \lstinline{union}.
- \points{4}
- \item[(f)]
- Schreiben Sie das Programm weiter um,
- so daß es die Objektinstanzen \lstinline{duck} und \lstinline{cow}
- dynamisch erzeugt.\par
- Hinweis: Verwenden Sie \lstinline{malloc()} und schreiben Sie Konstruktoren.
- \points{4}
- \item[(g)]
- Schreiben Sie das Programm weiter um,
- so daß die Ausgabe nicht mehr direkt im Hauptprogramm erfolgt,
- sondern stattdessen eine virtuelle Methode \lstinline{print()}
- aufgerufen wird.\par
- Hinweis: Verwenden Sie in den Objekten Zeiger auf Funktionen,
- und initialisieren Sie diese in den Konstruktoren.
- \points{4}
- \end{itemize}
-
- \begin{minipage}[t]{0.34\textwidth}
- \begin{lstlisting}[gobble=6,xleftmargin=0pt]
- #include <stdio.h>
-
- #define ANIMAL 0
- #define WITH_WINGS 1
- #define WITH_LEGS 2
-
- typedef struct animal
- {
- int type;
- char *name;
- } animal;
-
- typedef struct with_wings
- {
- int wings;
- } with_wings;
-
- typedef struct with_legs
- {
- int legs;
- } with_legs;
- \end{lstlisting}
- \end{minipage}\hfill
- \begin{minipage}[t]{0.65\textwidth}
- \begin{lstlisting}[gobble=6,xleftmargin=0pt]
- int main (void)
- {
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- a[0]->type = WITH_WINGS;
- a[0]->name = "duck";
- a[0]->wings = 2;
-
- animal cow;
- a[1] = &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- a[1]->legs = 4;
-
- for (int i = 0; i < 2; i++)
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name,
- ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name,
- ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
-
- return 0;
- }
- \end{lstlisting}
- \begin{picture}(0,0)
- \color{red}
- \put(3.7,6.207){\vector(-1,0){0.7}}
- \put(3.8,6.207){\makebox(0,0)[l]{\lstinline[basicstyle=\color{red}]{((with_legs *) a[1])->legs = 4;}}}
- \put(4.0,8.735){\vector(-1,0){0.7}}
- \put(4.1,8.735){\makebox(0,0)[l]{\lstinline[basicstyle=\color{red}]{((with_wings *) a[0])->wings = 2;}}}
- \end{picture}
- \end{minipage}
-
- \solution
-
- \begin{itemize}
- \item[(e)]
- \textbf{Schreiben Sie das Programm so um,
- daß es keine expliziten Typumwandlungen mehr benötigt.}\par
- \textbf{Hinweis: Verwenden Sie \lstinline{union}.}
-
- Siehe \gitfile{hp}{2022ws/20221205}{loesung-1e.c}.
-
- Diese Lösung basiert auf \gitfile{hp}{2022ws/20221128}{loesung-3d-2.c},
- da diese bereits weniger explizite Typumwandlungen enthält
- als \gitfile{hp}{2022ws/20221128}{loesung-3d-1.c}.
-
- Arbeitsschritte:
- \begin{itemize}
- \item
- Umbenennen des Basistyps \lstinline{animal} in \lstinline{base},
- damit wir den Bezeichner \lstinline{animal}
- für die \lstinline{union} verwenden können
- \item
- Schreiben einer \lstinline{union animal},
- die die drei Klassen \lstinline{base},
- \lstinline{with_wings} und \lstinline{with_legs}
- als Datenfelder enthält
- \item
- Umschreiben der Initialisierungen:
- Zugriff auf Datenfelder erfolgt nun durch
- z.\,B.\ \lstinline{a[0]->b.name}.
- Hierbei ist \lstinline{b} der Name des \lstinline{base}-Datenfelds
- innerhalb der \lstinline{union animal}.
- \item
- Auf gleiche Weise schreiben wir die \lstinline{if}-Bedingungen
- innerhalb der \lstinline{for}-Schleife
- sowie die Parameter der \lstinline{printf()}-Aufrufe um.
- \end{itemize}
- Explizite Typumwandlungen sind nun nicht mehr nötig.
-
- Nachteil dieser Lösung:
- Jede Objekt-Variable belegt nun Speicherplatz
- für die gesamte \lstinline{union animal},
- anstatt nur für die benötigte Variable vom Typ
- \lstinline{with_wings} oder \lstinline{with_legs}.
- Dies kann zu einer Verschwendung von Speicherplatz führen,
- auch wenn dies in diesem Beispielprogramm tatsächlich nicht der Fall ist.
-
- \item[(f)]
- \textbf{Schreiben Sie das Programm weiter um,
- so daß es die Objektinstanzen \lstinline{duck} und \lstinline{cow}
- dynamisch erzeugt.}\par
- \textbf{Hinweis: Verwenden Sie \lstinline{malloc()} und schreiben Sie Konstruktoren.}
-
- Siehe \gitfile{hp}{2022ws/20221205}{loesung-1f.c}.
-
- \item[(g)]
- \textbf{Schreiben Sie das Programm weiter um,
- so daß die Ausgabe nicht mehr direkt im Hauptprogramm erfolgt,
- sondern stattdessen eine virtuelle Methode \lstinline{print()}
- aufgerufen wird.}\par
- \textbf{Hinweis: Verwenden Sie in den Objekten Zeiger auf Funktionen,
- und initialisieren Sie diese in den Konstruktoren.}
-
- Siehe \gitfile{hp}{2022ws/20221205}{loesung-1g.c}.
-
- \end{itemize}
-
- \exercise{Iterationsfunktionen}
-
- Wir betrachten das folgende Programm (\gitfile{hp}{2022ws/20221205}{aufgabe-2.c}):
-
- \begin{minipage}[t]{0.4\textwidth}
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- void foreach (int *a, void (*fun) (int x))
- {
- for (int *p = a; *p >= 0; p++)
- fun (*p);
- }
-
- void even_or_odd (int x)
- {
- if (x % 2)
- printf ("%d ist ungerade.\n", x);
- else
- printf ("%d ist gerade.\n", x);
- }
- \end{lstlisting}
- \end{minipage}\hfill
- \begin{minipage}[t]{0.52\textwidth}
- \begin{lstlisting}[gobble=6]
- int main (void)
- {
- int numbers[] = { 12, 17, 32, 1, 3, 16, 19, 18, -1 };
- foreach (numbers, even_or_odd);
- return 0;
- }
- \end{lstlisting}
- \begin{enumerate}[\quad(a)]
- \item
- Was bedeutet \lstinline{void (*fun) (int x)},
- und welchen Sinn hat seine Verwendung in der Funktion \lstinline{foreach()}?
- \points{2}
- \item
- Schreiben Sie das Hauptprogramm \lstinline{main()} so um,
- daß es unter Verwendung der Funktion \lstinline{foreach()}
- die Summe aller positiven Zahlen in dem Array berechnet.
- Sie dürfen dabei weitere Funktionen sowie globale Variable einführen.
- \points{4}
- \end{enumerate}
- \end{minipage}
-
- \begin{enumerate}[\quad(a)]
- \item
- \textbf{Was bedeutet \lstinline{void (*fun) (int x)},
- und welchen Sinn hat seine Verwendung in der Funktion \lstinline{foreach()}?}
-
- \lstinline{void (*fun) (int x)} deklariert einen Zeiger \lstinline{fun},
- der auf Funktionen zeigen kann, die einen Parameter \lstinline{x}
- vom Typ \lstinline{int} erwarten und keinen Wert zurückgeben (\lstinline{void}).
-
- Durch die Übergabe eines derartigen Parameters an die Funktion \lstinline{foreach()}
- lassen wir dem Aufrufer die Wahl,
- welche Aktion für alle Elemente des Arrays aufgerufen werden soll.
-
- \item
- \textbf{Schreiben Sie das Hauptprogramm \lstinline{main()} so um,
- daß es unter Verwendung der Funktion \lstinline{foreach()}
- die Summe aller positiven Zahlen in dem Array berechnet.
- Sie dürfen dabei weitere Funktionen sowie globale Variable einführen.}
-
- Siehe: \gitfile{hp}{2022ws/20221205}{loesung-2.c}
-
- Damit die Funktion \lstinline{add_up()} Zugriff auf die Variable \lstinline{sum} hat,
- muß diese global sein
- und vor der Funktion \lstinline{add_up()} deklariert werden.
-
- Die Bedingung, daß nur positive Zahlen summiert werden sollen,
- ist durch die Arbeitsweise der Funktion \lstinline{foreach()}
- bereits gewährleistet, da negative Zahlen als Ende-Markierungen dienen.
-
- Wichtig ist, daß die Variable \lstinline{sum}
- vor dem Aufruf der Funktion \lstinline{foreach()}
- auf den Wert \lstinline{0} gesetzt wird.
- In \gitfile{hp}{2022ws/20221205}{loesung-2.c} geschieht dies
- durch die Initialisierung von \lstinline{sum}.
- Wenn mehrere Summen berechnet werden sollen,
- muß dies durch explizite Zuweisungen \lstinline{sum = 0}
- vor den Aufrufen von \lstinline{foreach()} erfolgen.
- \end{enumerate}
-
- \exercise{Stack-Operationen}
-
- Das folgende Programm (\gitfile{hp}{2022ws/20221205}{aufgabe-3.c})
- implementiert einen Stapelspeicher (Stack).
- Dies ist ein Array, das nur bis zu einer variablen Obergrenze (Stack-Pointer)
- tatsächlich genutzt wird.
- An dieser Obergrenze kann man Elemente hinzufügen (push).
-
- In dieser Aufgabe sollen zusätzlich Elemente
- in der Mitte eingefügt werden (insert).
- Die dafür bereits existierenden Funktionen \lstinline{insert()}
- und \lstinline{insert_sorted()} sind jedoch fehlerhaft.
-
- \begin{minipage}[t]{0.5\textwidth}
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- #define STACK_SIZE 10
-
- int stack[STACK_SIZE];
- int stack_pointer = 0;
-
- void push (int x)
- {
- stack[stack_pointer++] = x;
- }
-
- void show (void)
- {
- printf ("stack content:");
- for (int i = 0; i < stack_pointer; i++)
- printf (" %d", stack[i]);
- if (stack_pointer)
- printf ("\n");
- else
- printf (" (empty)\n");
- }
- \end{lstlisting}
- \end{minipage}\hfill
- \begin{minipage}[t]{0.5\textwidth}
- \begin{lstlisting}[gobble=6]
- void insert (int x, int pos)
- {
- for (int i = pos; i < stack_pointer; i++)
- stack[i + 1] = stack[i];
- stack[pos] = x;
- stack_pointer++;
- }
-
- void insert_sorted (int x)
- {
- int i = 0;
- while (i < stack_pointer && x < stack[i])
- i++;
- insert (x, i);
- }
-
- int main (void)
- {
- push (3);
- push (7);
- push (137);
- show ();
- insert (5, 1);
- show ();
- insert_sorted (42);
- show ();
- insert_sorted (2);
- show ();
- return 0;
- }
- \end{lstlisting}
- \end{minipage}
-
- \begin{enumerate}[\quad(a)]
- \item
- Korrigieren Sie das Programm so,
- daß die Funktion \lstinline{insert()} ihren Parameter \lstinline{x}
- an der Stelle \lstinline{pos} in den Stack einfügt
- und den sonstigen Inhalt des Stacks verschiebt, aber nicht zerstört.
- \points{3}
- \item
- Korrigieren Sie das Programm so,
- daß die Funktion \lstinline{insert_sorted()} ihren Parameter \lstinline{x}
- an derjenigen Stelle einfügt, an die er von der Sortierung her gehört.
- (Der Stack wird hierbei vor dem Funktionsaufruf als sortiert vorausgesetzt.)
- \points{2}
- \item
- Schreiben Sie eine zusätzliche Funktion \lstinline{int search (int x)},
- die die Position (Index) des Elements \lstinline{x}
- innerhalb des Stack zurückgibt -- oder die Zahl
- \lstinline{-1}, wenn \lstinline{x} nicht im Stack enthalten ist.
- Der Rechenaufwand darf höchstens $\mathcal{O}(n)$ betragen.
- \points{3}
- \item
- Wie (c), aber der Rechenaufwand darf höchstens $\mathcal{O}(\log n)$ betragen.
- \points{4}
- \end{enumerate}
-
- \solution
-
- \begin{enumerate}[\quad(a)]
- \item
- \textbf{Korrigieren Sie das Programm so,
- daß die Funktion \lstinline{insert()} ihren Parameter \lstinline{x}
- an der Stelle \lstinline{pos} in den Stack einfügt,
- und den sonstigen Inhalt des Stacks verschiebt, aber nicht zerstört.}
-
- Die \lstinline{for}-Schleife in der Funktion \lstinline{insert()}
- durchläuft das Array von unten nach oben.
- Um den Inhalt des Arrays von unten nach oben zu verschieben,
- muß man die Schleife jedoch von oben nach unten durchlaufen.
-
- \goodbreak
- Um die Funktion zu reparieren, ersetze man also
- \begin{lstlisting}[gobble=8]
- for (int i = pos; i < stack_pointer; i++)
- \end{lstlisting}
- durch:
- \begin{lstlisting}[gobble=8]
- for (int i = stack_pointer - 1; i >= pos; i--)
- \end{lstlisting}
- (Siehe auch: \gitfile{hp}{2022ws/20221205}{loesung-3.c})
-
- \item
- \textbf{Korrigieren Sie das Programm so,
- daß die Funktion \lstinline{insert_sorted()} ihren Parameter \lstinline{x}
- an derjenigen Stelle einfügt, an die er von der Sortierung her gehört.
- (Der Stack wird hierbei vor dem Funktionsaufruf als sortiert vorausgesetzt.)}
-
- Der Vergleich \lstinline{x < stack[i]}
- als Bestandteil der \lstinline{while}-Bedingung
- paßt nicht zur Durchlaufrichtung der Schleife (von unten nach oben).
-
- Um die Funktion zu reparieren, kann man daher entweder
- das Kleinerzeichen durch ein Größerzeichen ersetzen
- (\lstinline{x > stack[i]} -- siehe \gitfile{hp}{2022ws/20221205}{loesung-3b-1.c})
- oder die Schleife von oben nach unten durchlaufen
- (siehe \gitfile{hp}{2022ws/20221205}{loesung-3b-2.c}).
-
- Eine weitere Möglichkeit besteht darin,
- das Suchen nach der Einfügeposition
- mit dem Verschieben des Arrays zu kombinieren
- (siehe \gitfile{hp}{2022ws/20221205}{loesung-3.c}).
- Hierdurch spart man sich eine Schleife; das Programm wird schneller.
- (Es bleibt allerdings bei $\mathcal{O}(n)$.)
-
- \item
- \textbf{Schreiben Sie eine zusätzliche Funktion \lstinline{int search (int x)},
- die die Position (Index) des Elements \lstinline{x}
- innerhalb des Stack zurückgibt
- -- oder \lstinline{-1}, wenn \lstinline{x} nicht im Stack enthalten ist.
- Der Rechenaufwand darf höchstens $\mathcal{O}(n)$ betragen.}
-
- Man geht in einer Schleife den Stack (= den genutzten Teil des Arrays) durch.
- Bei Gleichheit gibt man direkt mit \lstinline{return} den Index zurück.
- Nach dem Schleifendurchlauf steht fest,
- daß \lstinline{x} nicht im Stack vorhanden ist;
- man kann dann direkt \lstinline{-1} zurückgeben
- (siehe \gitfile{hp}{2022ws/20221205}{loesung-3c.c}).
-
- Da es sich um eine einzelne Schleife handelt,
- ist die Ordnung $\mathcal{O}(n)$.
-
- \item
- \textbf{Wie (c), aber der Rechenaufwand darf höchstens $\mathcal{O}(\log n)$ betragen.}
-
- Um $\mathcal{O}(\log n)$ zu erreichen,
- halbiert man fortwährend das Intervall von (einschließlich) \lstinline{0}
- bis (ausschließlich) \lstinline{stack_pointer}
- (siehe \gitfile{hp}{2022ws/20221205}{loesung-3d.c}). % --
-% wie in der Funktion \lstinline{push_sorted()}
-% im Beispiel-Programm \gitfile{hp}{2022ws/20221205}{stack-11.c}.
-
-% Ein wichtiger Unterschied besteht darin,
- Wichtig ist,
- daß man nach dem Durchlauf der Schleife noch auf die Gleichheit
- \lstinline{x == stack[left]} (insbesondere nicht: \lstinline{stack[right]})
- prüfen und ggf.\ \lstinline{left} bzw.\ \lstinline{-1} zurückgeben muß.
- \end{enumerate}
-
-\end{document}
diff --git a/20221205/hp-uebung-20221205.pdf b/20221205/hp-uebung-20221205.pdf
deleted file mode 100644
index 4ccdeb9c1be1c4bc31b2f8964702467bd9d70dc6..0000000000000000000000000000000000000000
Binary files a/20221205/hp-uebung-20221205.pdf and /dev/null differ
diff --git a/20221205/hp-uebung-20221205.tex b/20221205/hp-uebung-20221205.tex
deleted file mode 100644
index bda4e34b525d06ef9a2b7b5320b3ab39c31f8951..0000000000000000000000000000000000000000
--- a/20221205/hp-uebung-20221205.tex
+++ /dev/null
@@ -1,329 +0,0 @@
-% hp-uebung-20221205.pdf - Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Objektorientierte Tier-Datenbank (Ergänzung), Iterationsfunktionen, Stack-Operationen
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\begin{document}
-
- \section*{Hardwarenahe Programmierung\\
- Übungsaufgaben -- 5.\ Dezember 2022}
-
- Diese Übung enthält Punkteangaben wie in einer Klausur.
- Um zu "`bestehen"', müssen Sie innerhalb von 85 Minuten
- unter Verwendung ausschließlich zugelassener Hilfsmittel
- 15 Punkte (von insgesamt \totalpoints) erreichen.
-
- \exercise{Objektorientierte Tier-Datenbank (Ergänzung)}
-
- Diese Aufgabe ist eine Neuauflage
- der Übungsaufgabe 3 vom 28.\ November 2022,
- ergänzt um die Teilaufgaben (e) bis (g).
-
- \medskip
-
- Das auf der nächsten Seite dargestellte Programm
- (Datei: \gitfile{hp}{2022ws/20221205}{aufgabe-1a.c})
- soll Daten von Tieren verwalten.
-
- Beim Compilieren erscheinen die folgende Fehlermeldungen:
- \begin{lstlisting}[style=terminal]
- $ ¡gcc -std=c99 -Wall -O aufgabe-1a.c -o aufgabe-1a¿
- aufgabe-1a.c: In function 'main':
- aufgabe-1a.c:31: error: 'animal' has no member named 'wings'
- aufgabe-1a.c:37: error: 'animal' has no member named 'legs'
- \end{lstlisting}
-
- Der Programmierer nimmt die auf der nächsten Seite in Rot dargestellten Ersetzungen vor\\
- (Datei: \gitfile{hp}{2022ws/20221205}{aufgabe-1b.c}).
- Daraufhin gelingt das Compilieren, und die Ausgabe des Programms lautet:
- \begin{lstlisting}[style=terminal]
- $ ¡gcc -std=c99 -Wall -O aufgabe-1b.c -o aufgabe-1b¿
- $ ¡./aufgabe-1b¿
- A duck has 2 legs.
- Error in animal: cow
- \end{lstlisting}
-
- \begin{itemize}
- \color{gray}
- \item[(a)]
- Erklären Sie die o.\,a.\ Compiler-Fehlermeldungen.
- % \points{2}
- \item[(b)]
- Wieso verschwinden die Fehlermeldungen nach den o.\,a.\ Ersetzungen?
- % \points{3}
- \item[(c)]
- Erklären Sie die Ausgabe des Programms.
- % \points{5}
- \item[(d)]
- Beschreiben Sie -- in Worten und/oder als C-Quelltext -- einen Weg,
- das Programm so zu berichtigen, daß es die Eingabedaten
- (``A duck has 2 wings. A cow has 4 legs.'') korrekt speichert und ausgibt. %\\
- % \points{4}
- \color{black}
- \item[(e)]
- Schreiben Sie das Programm so um,
- daß es keine expliziten Typumwandlungen mehr benötigt.\par
- Hinweis: Verwenden Sie \lstinline{union}.
- \points{4}
- \item[(f)]
- Schreiben Sie das Programm weiter um,
- so daß es die Objektinstanzen \lstinline{duck} und \lstinline{cow}
- dynamisch erzeugt.\par
- Hinweis: Verwenden Sie \lstinline{malloc()} und schreiben Sie Konstruktoren.
- \points{4}
- \item[(g)]
- Schreiben Sie das Programm weiter um,
- so daß die Ausgabe nicht mehr direkt im Hauptprogramm erfolgt,
- sondern stattdessen eine virtuelle Methode \lstinline{print()}
- aufgerufen wird.\par
- Hinweis: Verwenden Sie in den Objekten Zeiger auf Funktionen,
- und initialisieren Sie diese in den Konstruktoren.
- \points{4}
- \end{itemize}
-
- \begin{minipage}[t]{0.34\textwidth}
- \begin{lstlisting}[gobble=6,xleftmargin=0pt]
- #include <stdio.h>
-
- #define ANIMAL 0
- #define WITH_WINGS 1
- #define WITH_LEGS 2
-
- typedef struct animal
- {
- int type;
- char *name;
- } animal;
-
- typedef struct with_wings
- {
- int wings;
- } with_wings;
-
- typedef struct with_legs
- {
- int legs;
- } with_legs;
- \end{lstlisting}
- \end{minipage}\hfill
- \begin{minipage}[t]{0.65\textwidth}
- \begin{lstlisting}[gobble=6,xleftmargin=0pt]
- int main (void)
- {
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- a[0]->type = WITH_WINGS;
- a[0]->name = "duck";
- a[0]->wings = 2;
-
- animal cow;
- a[1] = &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- a[1]->legs = 4;
-
- for (int i = 0; i < 2; i++)
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name,
- ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name,
- ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
-
- return 0;
- }
- \end{lstlisting}
- \begin{picture}(0,0)
- \color{red}
- \put(3.7,6.207){\vector(-1,0){0.7}}
- \put(3.8,6.207){\makebox(0,0)[l]{\lstinline[basicstyle=\color{red}]{((with_legs *) a[1])->legs = 4;}}}
- \put(4.0,8.735){\vector(-1,0){0.7}}
- \put(4.1,8.735){\makebox(0,0)[l]{\lstinline[basicstyle=\color{red}]{((with_wings *) a[0])->wings = 2;}}}
- \end{picture}
- \end{minipage}
-
- \vfil
-
- \exercise{Iterationsfunktionen}
-
- Wir betrachten das folgende Programm (\gitfile{hp}{2022ws/20221205}{aufgabe-2.c}):
-
- \begin{minipage}[t]{0.4\textwidth}
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- void foreach (int *a, void (*fun) (int x))
- {
- for (int *p = a; *p >= 0; p++)
- fun (*p);
- }
-
- void even_or_odd (int x)
- {
- if (x % 2)
- printf ("%d ist ungerade.\n", x);
- else
- printf ("%d ist gerade.\n", x);
- }
- \end{lstlisting}
- \end{minipage}\hfill
- \begin{minipage}[t]{0.52\textwidth}
- \begin{lstlisting}[gobble=6]
- int main (void)
- {
- int numbers[] = { 12, 17, 32, 1, 3, 16, 19, 18, -1 };
- foreach (numbers, even_or_odd);
- return 0;
- }
- \end{lstlisting}
- \begin{enumerate}[\quad(a)]
- \item
- Was bedeutet \lstinline{void (*fun) (int x)},
- und welchen Sinn hat seine Verwendung in der Funktion \lstinline{foreach()}?
- \points{2}
- \item
- Schreiben Sie das Hauptprogramm \lstinline{main()} so um,
- daß es unter Verwendung der Funktion \lstinline{foreach()}
- die Summe aller positiven Zahlen in dem Array berechnet.
- Sie dürfen dabei weitere Funktionen sowie globale Variable einführen.
- \points{4}
- \end{enumerate}
- \end{minipage}
-
- \clearpage
-
- \exercise{Stack-Operationen}
-
- Das folgende Programm (\gitfile{hp}{2022ws/20221205}{aufgabe-3.c})
- implementiert einen Stapelspeicher (Stack).
- Dies ist ein Array, das nur bis zu einer variablen Obergrenze (Stack-Pointer)
- tatsächlich genutzt wird.
- An dieser Obergrenze kann man Elemente hinzufügen (push).
-
- In dieser Aufgabe sollen zusätzlich Elemente
- in der Mitte eingefügt werden (insert).
- Die dafür bereits existierenden Funktionen \lstinline{insert()}
- und \lstinline{insert_sorted()} sind jedoch fehlerhaft.
-
- \begin{minipage}[t]{0.5\textwidth}
- \begin{lstlisting}[gobble=6]
- #include <stdio.h>
-
- #define STACK_SIZE 10
-
- int stack[STACK_SIZE];
- int stack_pointer = 0;
-
- void push (int x)
- {
- stack[stack_pointer++] = x;
- }
-
- void show (void)
- {
- printf ("stack content:");
- for (int i = 0; i < stack_pointer; i++)
- printf (" %d", stack[i]);
- if (stack_pointer)
- printf ("\n");
- else
- printf (" (empty)\n");
- }
- \end{lstlisting}
- \end{minipage}\hfill
- \begin{minipage}[t]{0.5\textwidth}
- \begin{lstlisting}[gobble=6]
- void insert (int x, int pos)
- {
- for (int i = pos; i < stack_pointer; i++)
- stack[i + 1] = stack[i];
- stack[pos] = x;
- stack_pointer++;
- }
-
- void insert_sorted (int x)
- {
- int i = 0;
- while (i < stack_pointer && x < stack[i])
- i++;
- insert (x, i);
- }
-
- int main (void)
- {
- push (3);
- push (7);
- push (137);
- show ();
- insert (5, 1);
- show ();
- insert_sorted (42);
- show ();
- insert_sorted (2);
- show ();
- return 0;
- }
- \end{lstlisting}
- \end{minipage}
-
- \begin{enumerate}[\quad(a)]
- \item
- Korrigieren Sie das Programm so,
- daß die Funktion \lstinline{insert()} ihren Parameter \lstinline{x}
- an der Stelle \lstinline{pos} in den Stack einfügt
- und den sonstigen Inhalt des Stacks verschiebt, aber nicht zerstört.
- \points{3}
- \item
- Korrigieren Sie das Programm so,
- daß die Funktion \lstinline{insert_sorted()} ihren Parameter \lstinline{x}
- an derjenigen Stelle einfügt, an die er von der Sortierung her gehört.
- (Der Stack wird hierbei vor dem Funktionsaufruf als sortiert vorausgesetzt.)
- \points{2}
- \item
- Schreiben Sie eine zusätzliche Funktion \lstinline{int search (int x)},
- die die Position (Index) des Elements \lstinline{x}
- innerhalb des Stack zurückgibt -- oder die Zahl
- \lstinline{-1}, wenn \lstinline{x} nicht im Stack enthalten ist.
- Der Rechenaufwand darf höchstens $\mathcal{O}(n)$ betragen.
- \points{3}
- \item
- Wie (c), aber der Rechenaufwand darf höchstens $\mathcal{O}(\log n)$ betragen.
- \points{4}
- \end{enumerate}
-
- \begin{flushright}
- \textit{Viel Erfolg!}
- \end{flushright}
-
- \makeatletter
- \immediate\write\@mainaux{\string\gdef\string\totalpoints{\arabic{points}}}
- \makeatother
-
-\end{document}
diff --git a/20221205/loesung-1e.c b/20221205/loesung-1e.c
deleted file mode 100644
index b984d9253b9c379a88f0fc0ca130c88c3103f8f3..0000000000000000000000000000000000000000
--- a/20221205/loesung-1e.c
+++ /dev/null
@@ -1,61 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct
-{
- int type;
- char *name;
-} base;
-
-typedef struct
-{
- int type;
- char *name;
- int wings;
-} with_wings;
-
-typedef struct
-{
- int type;
- char *name;
- int legs;
-} with_legs;
-
-typedef union
-{
- base b;
- with_wings w;
- with_legs l;
-} animal;
-
-int main (void)
-{
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- duck.b.type = WITH_WINGS;
- duck.b.name = "duck";
- duck.w.wings = 2;
-
- animal cow;
- a[1] = &cow;
- cow.b.type = WITH_LEGS;
- cow.b.name = "cow";
- cow.l.legs = 4;
-
- for (int i = 0; i < 2; i++)
- if (a[i]->b.type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->b.name,
- a[i]->l.legs);
- else if (a[i]->b.type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->b.name,
- a[i]->w.wings);
- else
- printf ("Error in animal: %s\n", a[i]->b.name);
-
- return 0;
-}
diff --git a/20221205/loesung-1f.c b/20221205/loesung-1f.c
deleted file mode 100644
index 7b949e6365fc3839e6adc7661e0f8b4dd0c059df..0000000000000000000000000000000000000000
--- a/20221205/loesung-1f.c
+++ /dev/null
@@ -1,69 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct
-{
- int type;
- char *name;
-} base;
-
-typedef struct
-{
- int type;
- char *name;
- int wings;
-} with_wings;
-
-typedef struct
-{
- int type;
- char *name;
- int legs;
-} with_legs;
-
-typedef union
-{
- base b;
- with_wings w;
- with_legs l;
-} animal;
-
-animal *new_with_wings (char *name, int wings)
-{
- animal *a = malloc (sizeof (with_wings));
- a->b.type = WITH_WINGS;
- a->b.name = name;
- a->w.wings = wings;
- return a;
-}
-
-animal *new_with_legs (char *name, int legs)
-{
- animal *a = malloc (sizeof (with_legs));
- a->b.type = WITH_LEGS;
- a->b.name = name;
- a->l.legs = legs;
- return a;
-}
-
-int main (void)
-{
- animal *a[2] = { new_with_wings ("duck", 2),
- new_with_legs ("cow", 4) };
-
- for (int i = 0; i < 2; i++)
- if (a[i]->b.type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->b.name,
- a[i]->l.legs);
- else if (a[i]->b.type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->b.name,
- a[i]->w.wings);
- else
- printf ("Error in animal: %s\n", a[i]->b.name);
-
- return 0;
-}
diff --git a/20221205/loesung-1g.c b/20221205/loesung-1g.c
deleted file mode 100644
index b453a52dbe0ef27399255819808b3f6e562ba3ef..0000000000000000000000000000000000000000
--- a/20221205/loesung-1g.c
+++ /dev/null
@@ -1,77 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-union animal;
-
-typedef struct
-{
- int type;
- char *name;
- void (*print) (union animal *this);
-} base;
-
-typedef struct
-{
- int type;
- char *name;
- void (*print) (union animal *this);
- int wings;
-} with_wings;
-
-typedef struct
-{
- int type;
- char *name;
- void (*print) (union animal *this);
- int legs;
-} with_legs;
-
-typedef union animal
-{
- base b;
- with_wings w;
- with_legs l;
-} animal;
-
-void print_with_wings (animal *this)
-{
- printf ("A %s has %d wings.\n", this->b.name, this->w.wings);
-}
-
-void print_with_legs (animal *this)
-{
- printf ("A %s has %d legs.\n", this->b.name, this->l.legs);
-}
-
-animal *new_with_wings (char *name, int wings)
-{
- animal *a = malloc (sizeof (with_wings));
- a->b.type = WITH_WINGS;
- a->b.name = name;
- a->b.print = print_with_wings;
- a->w.wings = wings;
- return a;
-}
-
-animal *new_with_legs (char *name, int legs)
-{
- animal *a = malloc (sizeof (with_legs));
- a->b.type = WITH_LEGS;
- a->b.name = name;
- a->b.print = print_with_legs;
- a->l.legs = legs;
- return a;
-}
-
-int main (void)
-{
- animal *a[2] = { new_with_wings ("duck", 2),
- new_with_legs ("cow", 4) };
- for (int i = 0; i < 2; i++)
- a[i]->b.print (a[i]);
- return 0;
-}
diff --git a/20221205/loesung-3.c b/20221205/loesung-3.c
deleted file mode 100644
index 9b87d6c2f977af2843bcc2b75896fb5f00d8fc35..0000000000000000000000000000000000000000
--- a/20221205/loesung-3.c
+++ /dev/null
@@ -1,62 +0,0 @@
-#include <stdio.h>
-
-#define STACK_SIZE 10
-
-int stack[STACK_SIZE];
-int stack_pointer = 0;
-
-void push (int x)
-{
- stack[stack_pointer++] = x;
-}
-
-int pop (void)
-{
- return stack[--stack_pointer];
-}
-
-void show (void)
-{
- printf ("stack content:");
- for (int i = 0; i < stack_pointer; i++)
- printf (" %d", stack[i]);
- if (stack_pointer)
- printf ("\n");
- else
- printf (" (empty)\n");
-}
-
-void insert (int x, int pos)
-{
- for (int i = stack_pointer - 1; i >= pos; i--)
- stack[i + 1] = stack[i];
- stack[pos] = x;
- stack_pointer++;
-}
-
-void insert_sorted (int x)
-{
- int i = stack_pointer - 1;
- while (i >= 0 && x < stack[i])
- {
- stack[i + 1] = stack[i];
- i--;
- }
- stack[i + 1] = x;
- stack_pointer++;
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- show ();
- insert (5, 1);
- show ();
- insert_sorted (42);
- show ();
- insert_sorted (2);
- show ();
- return 0;
-}
diff --git a/20221205/loesung-3b-1.c b/20221205/loesung-3b-1.c
deleted file mode 100644
index cbbe37055109d203105a7ad4acb63d5bef61f4c0..0000000000000000000000000000000000000000
--- a/20221205/loesung-3b-1.c
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stdio.h>
-
-#define STACK_SIZE 10
-
-int stack[STACK_SIZE];
-int stack_pointer = 0;
-
-void push (int x)
-{
- stack[stack_pointer++] = x;
-}
-
-int pop (void)
-{
- return stack[--stack_pointer];
-}
-
-void show (void)
-{
- printf ("stack content:");
- for (int i = 0; i < stack_pointer; i++)
- printf (" %d", stack[i]);
- if (stack_pointer)
- printf ("\n");
- else
- printf (" (empty)\n");
-}
-
-void insert (int x, int pos)
-{
- for (int i = stack_pointer - 1; i >= pos; i--)
- stack[i + 1] = stack[i];
- stack[pos] = x;
- stack_pointer++;
-}
-
-void insert_sorted (int x)
-{
- int i = 0;
- while (i < stack_pointer && x > stack[i])
- i++;
- insert (x, i);
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- show ();
- insert (5, 1);
- show ();
- insert_sorted (42);
- show ();
- insert_sorted (2);
- show ();
- return 0;
-}
diff --git a/20221205/loesung-3b-2.c b/20221205/loesung-3b-2.c
deleted file mode 100644
index b1e1ae846f15a29e9cd53a8d1d689e3ccbefacce..0000000000000000000000000000000000000000
--- a/20221205/loesung-3b-2.c
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stdio.h>
-
-#define STACK_SIZE 10
-
-int stack[STACK_SIZE];
-int stack_pointer = 0;
-
-void push (int x)
-{
- stack[stack_pointer++] = x;
-}
-
-int pop (void)
-{
- return stack[--stack_pointer];
-}
-
-void show (void)
-{
- printf ("stack content:");
- for (int i = 0; i < stack_pointer; i++)
- printf (" %d", stack[i]);
- if (stack_pointer)
- printf ("\n");
- else
- printf (" (empty)\n");
-}
-
-void insert (int x, int pos)
-{
- for (int i = stack_pointer - 1; i >= pos; i--)
- stack[i + 1] = stack[i];
- stack[pos] = x;
- stack_pointer++;
-}
-
-void insert_sorted (int x)
-{
- int i = stack_pointer - 1;
- while (i >= 0 && x < stack[i])
- i--;
- insert (x, i + 1);
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- show ();
- insert (5, 1);
- show ();
- insert_sorted (42);
- show ();
- insert_sorted (2);
- show ();
- return 0;
-}
diff --git a/20221205/loesung-3c.c b/20221205/loesung-3c.c
deleted file mode 100644
index 79d061e3d7b78a2bec05b632e74b083a16d5a326..0000000000000000000000000000000000000000
--- a/20221205/loesung-3c.c
+++ /dev/null
@@ -1,72 +0,0 @@
-#include <stdio.h>
-
-#define STACK_SIZE 10
-
-int stack[STACK_SIZE];
-int stack_pointer = 0;
-
-void push (int x)
-{
- stack[stack_pointer++] = x;
-}
-
-int pop (void)
-{
- return stack[--stack_pointer];
-}
-
-void show (void)
-{
- printf ("stack content:");
- for (int i = 0; i < stack_pointer; i++)
- printf (" %d", stack[i]);
- if (stack_pointer)
- printf ("\n");
- else
- printf (" (empty)\n");
-}
-
-void insert (int x, int pos)
-{
- for (int i = stack_pointer - 1; i >= pos; i--)
- stack[i + 1] = stack[i];
- stack[pos] = x;
- stack_pointer++;
-}
-
-void insert_sorted (int x)
-{
- int i = stack_pointer - 1;
- while (i >= 0 && x < stack[i])
- {
- stack[i + 1] = stack[i];
- i--;
- }
- stack[i + 1] = x;
- stack_pointer++;
-}
-
-int search (int x)
-{
- for (int i = 0; i < stack_pointer; i++)
- if (stack[i] == x)
- return i;
- return -1;
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- show ();
- insert (5, 1);
- show ();
- insert_sorted (42);
- show ();
- insert_sorted (2);
- show ();
- printf ("%d\n", search (42));
- printf ("%d\n", search (1117));
- return 0;
-}
diff --git a/20221205/loesung-3d.c b/20221205/loesung-3d.c
deleted file mode 100644
index 9079d8d3be7a500498aede2cf8e89a7d7db48a35..0000000000000000000000000000000000000000
--- a/20221205/loesung-3d.c
+++ /dev/null
@@ -1,86 +0,0 @@
-#include <stdio.h>
-
-#define STACK_SIZE 10
-
-int stack[STACK_SIZE];
-int stack_pointer = 0;
-
-void push (int x)
-{
- stack[stack_pointer++] = x;
-}
-
-int pop (void)
-{
- return stack[--stack_pointer];
-}
-
-void show (void)
-{
- printf ("stack content:");
- for (int i = 0; i < stack_pointer; i++)
- printf (" %d", stack[i]);
- if (stack_pointer)
- printf ("\n");
- else
- printf (" (empty)\n");
-}
-
-void insert (int x, int pos)
-{
- for (int i = stack_pointer - 1; i >= pos; i--)
- stack[i + 1] = stack[i];
- stack[pos] = x;
- stack_pointer++;
-}
-
-void insert_sorted (int x)
-{
- int i = stack_pointer - 1;
- while (i >= 0 && x < stack[i])
- {
- stack[i + 1] = stack[i];
- i--;
- }
- stack[i + 1] = x;
- stack_pointer++;
-}
-
-int search (int x)
-{
- int left = 0;
- int right = stack_pointer;
- while (left < right - 1)
- {
- int middle = (left + right) / 2;
- if (x < stack[middle])
- right = middle;
- else
- left = middle;
- }
- if (x == stack[left])
- return left;
- else
- return -1;
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- show ();
- insert (5, 1);
- show ();
- insert_sorted (42);
- show ();
- insert_sorted (2);
- show ();
- printf ("%d\n", search (2));
- printf ("%d\n", search (4));
- printf ("%d\n", search (42));
- printf ("%d\n", search (67));
- printf ("%d\n", search (137));
- printf ("%d\n", search (1117));
- return 0;
-}
diff --git a/20221205/logo-hochschule-bochum-cvh-text-v2.pdf b/20221205/logo-hochschule-bochum-cvh-text-v2.pdf
deleted file mode 120000
index 4aa99b8f81061aca6dcaf43eed2d9efef40555f8..0000000000000000000000000000000000000000
--- a/20221205/logo-hochschule-bochum-cvh-text-v2.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
diff --git a/20221205/logo-hochschule-bochum.pdf b/20221205/logo-hochschule-bochum.pdf
deleted file mode 120000
index b6b9491e370e499c9276918182cdb82cb311bcd1..0000000000000000000000000000000000000000
--- a/20221205/logo-hochschule-bochum.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20221205/objects-05a.c b/20221205/objects-05a.c
deleted file mode 100644
index d7a3d1e679f6d659812f1578af946708171539e9..0000000000000000000000000000000000000000
--- a/20221205/objects-05a.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int i = 42;
- char *s = "Hello, world!";
-
- void *object[] = { &i, &s };
-
- for (int i = 0; i < 2; i++)
- if (typeof (object[i]) == int) /* funktioniert nicht */
- printf ("Integer: %d\n", *object[i]);
- else if (typeof (object[i] == char *))
- printf ("String: \"%s\"\n", object[i]);
-
- return 0;
-}
diff --git a/20221205/objects-05b.c b/20221205/objects-05b.c
deleted file mode 100644
index d36aff93853be2b7466e28396729aea995c366f1..0000000000000000000000000000000000000000
--- a/20221205/objects-05b.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int i = 42;
- char *s = "Hello, world!";
-
- int *object[] = { &i, (int *) &s };
-
- for (int i = 0; i < 2; i++)
- if (sizeof (object[i]) == sizeof (int *)) /* funktioniert nicht */
- printf ("Integer: %d\n", *object[i]);
- else if (sizeof (object[i]) == sizeof (char *))
- printf ("String: \"%s\"\n", *((char **) object[i]));
-
- return 0;
-}
diff --git a/20221205/objects-05c.c b/20221205/objects-05c.c
deleted file mode 100644
index e2906e5a62e03db3fbe84b7b6ef7f37da259602f..0000000000000000000000000000000000000000
--- a/20221205/objects-05c.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int i = 42;
- char *s = "Hello, world!";
-
- int *object[] = { &i, (int *) &s };
-
- for (int i = 0; i < 2; i++)
- if (*object[i] > -1000 && *object[i] < 1000)
- printf ("Integer: %d\n", *object[i]);
- else
- printf ("String: \"%s\"\n", *((char **) object[i]));
-
- return 0;
-}
diff --git a/20221205/objects-05d.c b/20221205/objects-05d.c
deleted file mode 100644
index d58a7addfcb7d158e04704f73a057c1f3eb2fe10..0000000000000000000000000000000000000000
--- a/20221205/objects-05d.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <stdio.h>
-#include <signal.h>
-
-void segv_handler (int s)
-{
- printf ("Hello, world!\n");
- signal (SIGSEGV, NULL);
-}
-
-int main (void)
-{
- signal (SIGSEGV, segv_handler);
- printf (42);
-
- return 0;
-}
diff --git a/20221205/objects-05e.c b/20221205/objects-05e.c
deleted file mode 100644
index 892632b726ff235acdf59459ce6462c9f537b417..0000000000000000000000000000000000000000
--- a/20221205/objects-05e.c
+++ /dev/null
@@ -1,25 +0,0 @@
-#include <stdio.h>
-#include <signal.h>
-
-char *s = "Hello, world!";
-int i = 42;
-
-int *object[] = { (int *) &s, &i };
-
-volatile int j;
-
-void segv_handler (int s)
-{
- printf ("Integer: %d\n", *object[j]);
- signal (SIGSEGV, NULL);
-}
-
-int main (void)
-{
- signal (SIGSEGV, segv_handler);
-
- for (j = 0; j < 2; j++)
- printf ("String: \"%s\"\n", *((char **) object[j]));
-
- return 0;
-}
diff --git a/20221205/objects-05f.c b/20221205/objects-05f.c
deleted file mode 100644
index 880d7c04ec4b18b2ef93f5e3d7878077bb0efdf6..0000000000000000000000000000000000000000
--- a/20221205/objects-05f.c
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <stdio.h>
-#include <signal.h>
-
-char *s = "Hello, world!";
-int i = 42;
-
-int *object[] = { (int *) &s, &i };
-
-volatile int j;
-
-void segv_handler (int s)
-{
- printf ("Integer: %d\n", *object[j]);
- signal (SIGSEGV, NULL);
-}
-
-int main (void)
-{
- signal (SIGSEGV, segv_handler);
-
- for (j = 0; j < 2; j++)
- {
- volatile char UAAAH = *(*(char **) object[j]);
- printf ("String: \"%s\"\n", *((char **) object[j]));
- }
-
- return 0;
-}
diff --git a/20221205/objects-05g.c b/20221205/objects-05g.c
deleted file mode 100644
index 1722051b8dc0709a43013c89825d4930cfb59ed7..0000000000000000000000000000000000000000
--- a/20221205/objects-05g.c
+++ /dev/null
@@ -1,30 +0,0 @@
-#include <stdio.h>
-#include <signal.h>
-
-#define UAAAH uaaah
-
-char *s = "Hello, world!";
-int i = 42;
-
-int *object[] = { (int *) &s, &i };
-
-volatile int j;
-
-void segv_handler (int s)
-{
- printf ("Integer: %d\n", *object[j]);
- signal (SIGSEGV, NULL);
-}
-
-int main (void)
-{
- signal (SIGSEGV, segv_handler);
-
- for (j = 0; j < 2; j++)
- {
- volatile char UAAAH = *(*(char **) object[j]);
- printf ("String: \"%s\"\n", *((char **) object[j]));
- }
-
- return 0;
-}
diff --git a/20221205/objects-05h.c b/20221205/objects-05h.c
deleted file mode 100644
index 820c4712e72e6e1ff89b4e0318b033a9608c27cf..0000000000000000000000000000000000000000
--- a/20221205/objects-05h.c
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <stdio.h>
-#include <signal.h>
-
-#define UAAAH uaaah
-
-char *s = "Hello, world!";
-int i = 42;
-
-int *object[] = { (int *) &s, &i };
-
-volatile int j;
-
-void segv_handler (int s)
-{
- printf ("Integer: %d\e[01;30m", *object[j]);
- fflush (stdout);
- signal (SIGSEGV, NULL);
-}
-
-int main (void)
-{
- signal (SIGSEGV, segv_handler);
-
- for (j = 0; j < 2; j++)
- {
- volatile char UAAAH = *(*(char **) object[j]);
- (void) UAAAH;
- printf ("String: \"%s\"\n", *((char **) object[j]));
- }
-
- return 0;
-}
diff --git a/20221205/objects-06a.c b/20221205/objects-06a.c
deleted file mode 100644
index 8a1294bea03009beb408e87494047c3de35eaf69..0000000000000000000000000000000000000000
--- a/20221205/objects-06a.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- int type;
-} t_base;
-
-typedef struct
-{
- int content;
- int type;
-} t_integer;
-
-typedef struct
-{
- char *content;
- int type;
-} t_string;
-
-void print_object (t_base *this)
-{
- if (this->type == 1)
- printf ("Integer: %d\n", ((t_integer *) this)->content);
- else if (this->type == 2)
- printf ("String: \"%s\"\n", ((t_string *) this)->content);
-}
-
-int main (void)
-{
- t_integer i = { 42, 1 };
- t_string s = { "Hello, world!", 2 };
-
- t_base *object[] = { (t_base *) &i, (t_base *) &s };
-
- for (int i = 0; i < 2; i++)
- print_object (object[i]);
-
- return 0;
-}
diff --git a/20221205/objects-13.c b/20221205/objects-13.c
deleted file mode 100644
index 1ed5887177bc6809a2a110bb360a847ad004bf85..0000000000000000000000000000000000000000
--- a/20221205/objects-13.c
+++ /dev/null
@@ -1,78 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-union t_object;
-struct t_vmt;
-
-typedef struct
-{
- struct t_vmt *vmt;
-} t_base;
-
-typedef struct
-{
- struct t_vmt *vmt;
- int content;
-} t_integer;
-
-typedef struct
-{
- struct t_vmt *vmt;
- char *content;
-} t_string;
-
-typedef union t_object
-{
- t_base base;
- t_integer integer;
- t_string string;
-} t_object;
-
-typedef struct t_vmt
-{
- void (*print) (union t_object *this);
-} t_vmt;
-
-void print_integer (t_object *this)
-{
- printf ("Integer: %d\n", this->integer.content);
-}
-
-void print_string (t_object *this)
-{
- printf ("String: \"%s\"\n", this->string.content);
-}
-
-t_vmt vmt_integer = { print_integer };
-t_vmt vmt_string = { print_string };
-
-t_object *new_integer (int i)
-{
- t_object *p = malloc (sizeof (t_integer));
- p->integer.vmt = &vmt_integer;
- p->integer.content = i;
- return p;
-}
-
-t_object *new_string (char *s)
-{
- t_object *p = malloc (sizeof (t_string));
- p->integer.vmt = &vmt_string;
- p->string.content = s;
- return p;
-}
-
-int main (void)
-{
- t_object *object[] = { new_integer (42),
- new_string ("Hello, world!"),
- NULL };
-
- for (int i = 0; object[i]; i++)
- object[i]->base.vmt->print (object[i]);
-
- for (int i = 0; object[i]; i++)
- free (object[i]);
-
- return 0;
-}
diff --git a/20221205/objects-13a.c b/20221205/objects-13a.c
deleted file mode 100644
index 1bf74a5769da98f518718d8b0e8ae952df849a71..0000000000000000000000000000000000000000
--- a/20221205/objects-13a.c
+++ /dev/null
@@ -1,83 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-union t_object;
-struct t_vmt;
-
-typedef struct
-{
- struct t_vmt *vmt;
-} t_base;
-
-typedef struct
-{
- struct t_vmt *vmt;
- int content;
-} t_integer;
-
-typedef struct
-{
- struct t_vmt *vmt;
- char *content;
-} t_string;
-
-typedef union t_object
-{
- t_base base;
- t_integer integer;
- t_string string;
-} t_object;
-
-typedef struct t_vmt
-{
- ssize_t size;
- ssize_t neg_size;
- void (*print) (union t_object *this);
-} t_vmt;
-
-void print_integer (t_object *this)
-{
- printf ("Integer: %d\n", this->integer.content);
-}
-
-void print_string (t_object *this)
-{
- printf ("String: \"%s\"\n", this->string.content);
-}
-
-t_vmt vmt_integer = { sizeof (t_integer), -sizeof (t_integer), print_integer };
-t_vmt vmt_string = { sizeof (t_string), -sizeof (t_string), print_string };
-
-t_object *new_integer (int i)
-{
- t_object *p = malloc (sizeof (t_integer));
- p->integer.vmt = &vmt_integer;
- p->integer.content = i;
- return p;
-}
-
-t_object *new_string (char *s)
-{
- t_object *p = malloc (sizeof (t_string));
- p->integer.vmt = &vmt_string;
- p->string.content = s;
- return p;
-}
-
-int main (void)
-{
- t_object *object[] = { new_integer (42),
- new_string ("Hello, world!"),
- NULL };
-
- for (int i = 0; object[i]; i++)
- if (object[i]->base.vmt
- && object[i]->base.vmt->size > 0
- && object[i]->base.vmt->neg_size == - object[i]->base.vmt->size)
- object[i]->base.vmt->print (object[i]);
-
- for (int i = 0; object[i]; i++)
- free (object[i]);
-
- return 0;
-}
diff --git a/20221205/pgscript.sty b/20221205/pgscript.sty
deleted file mode 120000
index 95c888478c99ea7fda0fd11ccf669ae91be7178b..0000000000000000000000000000000000000000
--- a/20221205/pgscript.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgscript.sty
\ No newline at end of file
diff --git a/20221205/pgslides.sty b/20221205/pgslides.sty
deleted file mode 120000
index 5be1416f4216f076aa268901f52a15d775e43f64..0000000000000000000000000000000000000000
--- a/20221205/pgslides.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgslides.sty
\ No newline at end of file
diff --git a/20221205/stack-00.c b/20221205/stack-00.c
deleted file mode 100644
index 97a17ac787768b1f5ef7597579a4eadf41509607..0000000000000000000000000000000000000000
--- a/20221205/stack-00.c
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <stdio.h>
-
-void push (int x)
-{
- /* FIXME */
-}
-
-int pop (void)
-{
- return 42; /* FIXME */
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/stack-01.c b/20221205/stack-01.c
deleted file mode 100644
index 154331c13743b852e859ca06aee9077af6854b33..0000000000000000000000000000000000000000
--- a/20221205/stack-01.c
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <stdio.h>
-
-#define STACK_SIZE 10
-
-int stack[STACK_SIZE];
-int stack_pointer = 0;
-
-void push (int x)
-{
- stack[stack_pointer] = x;
- stack_pointer++;
-}
-
-int pop (void)
-{
- return 42; /* FIXME */
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/stack-02.c b/20221205/stack-02.c
deleted file mode 100644
index 1eee46152c3d651d09cdeb34d24915bb48f3466a..0000000000000000000000000000000000000000
--- a/20221205/stack-02.c
+++ /dev/null
@@ -1,27 +0,0 @@
-#include <stdio.h>
-
-#define STACK_SIZE 10
-
-int stack[STACK_SIZE];
-int stack_pointer = 0;
-
-void push (int x)
-{
- stack[stack_pointer++] = x;
-}
-
-int pop (void)
-{
- return 42; /* FIXME */
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/stack-03.c b/20221205/stack-03.c
deleted file mode 100644
index b20a444d628a88101416097c79b34e0669b24d21..0000000000000000000000000000000000000000
--- a/20221205/stack-03.c
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <stdio.h>
-
-#define STACK_SIZE 10
-
-int stack[STACK_SIZE];
-int stack_pointer = 0;
-
-void push (int x)
-{
- stack[stack_pointer++] = x;
-}
-
-int pop (void)
-{
- stack_pointer--;
- return stack[stack_pointer];
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/stack-04.c b/20221205/stack-04.c
deleted file mode 100644
index 0d738f95ff81ce1701b4aa8a12df30094b723851..0000000000000000000000000000000000000000
--- a/20221205/stack-04.c
+++ /dev/null
@@ -1,27 +0,0 @@
-#include <stdio.h>
-
-#define STACK_SIZE 10
-
-int stack[STACK_SIZE];
-int stack_pointer = 0;
-
-void push (int x)
-{
- stack[stack_pointer++] = x;
-}
-
-int pop (void)
-{
- return stack[--stack_pointer];
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/stack-05.c b/20221205/stack-05.c
deleted file mode 100644
index 38a187208208488bdb8e988d93442d57730e421e..0000000000000000000000000000000000000000
--- a/20221205/stack-05.c
+++ /dev/null
@@ -1,40 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#define STACK_SIZE 10
-
-int stack[STACK_SIZE];
-int stack_pointer = 0;
-
-void push (int x)
-{
- if (stack_pointer < STACK_SIZE)
- stack[stack_pointer++] = x;
- else
- {
- fprintf (stderr, "stack overflow\n");
- exit (1);
- }
-}
-
-int pop (void)
-{
- if (stack_pointer > 0)
- return stack[--stack_pointer];
- else
- {
- fprintf (stderr, "stack underflow\n");
- exit (1);
- }
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/stack-06.c b/20221205/stack-06.c
deleted file mode 100644
index be00e160384be5e4af05831547ed74b636c3bdf0..0000000000000000000000000000000000000000
--- a/20221205/stack-06.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#define STACK_SIZE 10
-
-int stack[STACK_SIZE];
-int stack_pointer = 0;
-
-void push (int x)
-{
- if (stack_pointer < STACK_SIZE)
- stack[stack_pointer++] = x;
- else
- {
- fprintf (stderr, "stack overflow\n");
- exit (1);
- }
-}
-
-int pop (void)
-{
- if (stack_pointer > 0)
- return stack[--stack_pointer];
- else
- {
- fprintf (stderr, "stack underflow\n");
- exit (1);
- }
-}
-
-int main (void)
-{
- for (int i = 0; i < 42; i++)
- push (i);
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/stack-07.c b/20221205/stack-07.c
deleted file mode 100644
index b583bc281f9ae3acd673ec9ea4de75720084fb50..0000000000000000000000000000000000000000
--- a/20221205/stack-07.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#define STACK_SIZE 10
-
-int stack[STACK_SIZE];
-int stack_pointer = 0;
-
-void push (int x)
-{
- if (stack_pointer < STACK_SIZE)
- stack[stack_pointer++] = x;
- else
- {
- fprintf (stderr, "stack overflow\n");
- exit (1);
- }
-}
-
-int pop (void)
-{
- if (stack_pointer > 0)
- return stack[--stack_pointer];
- else
- {
- fprintf (stderr, "stack underflow\n");
- exit (1);
- }
-}
-
-int main (void)
-{
- push (3);
- push (7);
- push (137);
- for (int i = 0; i < 42; i++)
- printf ("%d\n", pop ());
- return 0;
-}
diff --git a/20221205/stack-07.out b/20221205/stack-07.out
deleted file mode 100644
index 2344cb9a2fd2e0950ddd40193267ea4b208032cb..0000000000000000000000000000000000000000
--- a/20221205/stack-07.out
+++ /dev/null
@@ -1,3 +0,0 @@
-137
-7
-3
diff --git a/20221212/aufgabe-1.c b/20221212/aufgabe-1.c
deleted file mode 100644
index 5b0cb23fdd5ee15a4403808c18d2104ed49caf3f..0000000000000000000000000000000000000000
--- a/20221212/aufgabe-1.c
+++ /dev/null
@@ -1,62 +0,0 @@
-#include <gtk/gtk.h>
-
-#define WIDTH 320
-#define HEIGHT 240
-
-double t = 0.0;
-double dt = 0.2;
-
-int r = 5;
-
-double x = 10;
-double y = 200;
-double vx = 20;
-double vy = -60;
-double g = 9.81;
-
-gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
-{
- GdkRGBA blue = { 0.0, 0.5, 1.0, 1.0 };
-
- gdk_cairo_set_source_rgba (c, &blue);
- cairo_arc (c, x, y, r, 0, 2 * G_PI);
- cairo_fill (c);
-
- return FALSE;
-}
-
-gboolean timer (GtkWidget *widget)
-{
- t += dt;
- x += vx * dt;
- y += vy * dt;
- vx = vx;
- vy = 0.5 * g * (t * t);
- if (y + r >= HEIGHT)
- vy = -vy * 0.9;
- if (x + r >= WIDTH)
- vx = -vx * 0.9;
- if (x - r <= 0)
- vx = -vx * 0.9;
- gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
-}
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
-
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_widget_show (window);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_widget_show (drawing_area);
- gtk_container_add (GTK_CONTAINER (window), drawing_area);
- gtk_widget_set_size_request (drawing_area, WIDTH, HEIGHT);
-
- gtk_main ();
- return 0;
-}
diff --git a/20221212/aufgabe-2.c b/20221212/aufgabe-2.c
deleted file mode 100644
index d0b065941fbc0082bf867d872527299dca97b98f..0000000000000000000000000000000000000000
--- a/20221212/aufgabe-2.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <string.h>
-
-int fun_1 (char *s)
-{
- int x = 0;
- for (int i = 0; i < strlen (s); i++)
- x += s[i];
- return x;
-}
-
-int fun_2 (char *s)
-{
- int i = 0, x = 0;
- int len = strlen (s);
- while (i < len)
- x += s[i++];
- return x;
-}
diff --git a/20221212/aufgabe-3.c b/20221212/aufgabe-3.c
deleted file mode 100644
index ac63ca250c79fd76c26f4045ece703407024a4ce..0000000000000000000000000000000000000000
--- a/20221212/aufgabe-3.c
+++ /dev/null
@@ -1,24 +0,0 @@
-#include <stdio.h>
-
-/* ... */
-
-int main (void)
-{
- pbm_open (14, 14, "test.pbm");
- pbm_line (" ");
- pbm_line (" XXXXXX ");
- pbm_line (" X X ");
- pbm_line (" X X ");
- pbm_line (" X X ");
- pbm_line (" X XX XX X ");
- pbm_line (" X X X X ");
- pbm_line (" X X ");
- pbm_line (" X X X X ");
- pbm_line (" X X X X ");
- pbm_line (" X XXXX X ");
- pbm_line (" X X ");
- pbm_line (" XXXXXX ");
- pbm_line (" ");
- pbm_close ();
- return 0;
-}
diff --git a/20221212/aufgabe-3.pbm b/20221212/aufgabe-3.pbm
deleted file mode 100644
index bc5b70b1ad6f7236ec9469afac311f05fb056946..0000000000000000000000000000000000000000
Binary files a/20221212/aufgabe-3.pbm and /dev/null differ
diff --git a/20221212/aufgabe-3.png b/20221212/aufgabe-3.png
deleted file mode 100644
index e655af0096cc6e50da81c8f820395dfaed27277f..0000000000000000000000000000000000000000
Binary files a/20221212/aufgabe-3.png and /dev/null differ
diff --git a/20221212/hello-gtk.png b/20221212/hello-gtk.png
deleted file mode 120000
index cca99209d86683a9a3b0f70bbc149780bae10ba6..0000000000000000000000000000000000000000
--- a/20221212/hello-gtk.png
+++ /dev/null
@@ -1 +0,0 @@
-../common/hello-gtk.png
\ No newline at end of file
diff --git a/20221212/hp-musterloesung-20221212.pdf b/20221212/hp-musterloesung-20221212.pdf
deleted file mode 100644
index b39527cbb9349c44637186c4bb66c4e1edb7d414..0000000000000000000000000000000000000000
Binary files a/20221212/hp-musterloesung-20221212.pdf and /dev/null differ
diff --git a/20221212/hp-musterloesung-20221212.tex b/20221212/hp-musterloesung-20221212.tex
deleted file mode 100644
index a640276da85b3f56302d18c560a78fa07d577160..0000000000000000000000000000000000000000
--- a/20221212/hp-musterloesung-20221212.tex
+++ /dev/null
@@ -1,378 +0,0 @@
-% hp-musterloesung-20221212.pdf - Solutions to the Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Länge von Strings (Neuauflage), Text-Grafik-Bibliothek, PBM-Grafik
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\begin{document}
-
- \section*{Hardwarenahe Programmierung\\
- Musterlösung zu den Übungsaufgaben -- 12.\ Dezember 2022}
-
- \exercise{Länge von Strings}
-
- Diese Aufgabe ist eine Neuauflage von Aufgabe 2 der
- Übung vom 7.\ November 2022,\\
- ergänzt um die Teilaufgaben (f) und (g).
-
- \medskip
-
- Strings werden in der Programmiersprache C durch Zeiger auf \lstinline{char}-Variable realisiert.
-
- Beispiel: \lstinline{char *hello_world = "Hello, world!\n"}
-
- Die Systembibliothek stellt eine Funktion \lstinline{strlen()} zur Ermittlung der Länge von Strings\\
- zur Verfügung (\lstinline{#include <string.h>}).
-
- \begin{enumerate}[\quad(a)]
- \item
- Auf welche Weise ist die Länge eines Strings gekennzeichnet?
- \points{1}
- \item
- Wie lang ist die Beispiel-String-Konstante \lstinline{"Hello, world!\n"},
- und wieviel Speicherplatz belegt sie?\\
- \points{2}
- \item
- Schreiben Sie eine eigene Funktion \lstinline{int strlen (char *s)},
- die die Länge eines Strings zurückgibt.\\
- \points{3}
- \end{enumerate}
-
- \goodbreak
-
- Wir betrachten nun die folgenden Funktionen (Datei: \gitfile{hp}{2022ws/20221212}{aufgabe-2.c}):
- \begin{center}
- \begin{minipage}{8cm}
- \begin{lstlisting}[gobble=8]
- int fun_1 (char *s)
- {
- int x = 0;
- for (int i = 0; i < strlen (s); i++)
- x += s[i];
- return x;
- }
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}{6cm}
- \vspace*{-1cm}
- \begin{lstlisting}[gobble=8]
- int fun_2 (char *s)
- {
- int i = 0, x = 0;
- int len = strlen (s);
- while (i < len)
- x += s[i++];
- return x;
- }
- \end{lstlisting}
- \vspace*{-1cm}
- \end{minipage}
- \end{center}
- \begin{enumerate}[\quad(a)]\setcounter{enumi}{3}
- \item
- Was bewirken die beiden Funktionen?
- \points{2}
- \item
- Schreiben Sie eine eigene Funktion,
- die dieselbe Aufgabe erledigt wie \lstinline{fun_2()},\\
- nur effizienter.
- \points{4}
- \item
- Von welcher Ordnung (Landau-Symbol) sind die beiden Funktionen
- hinsichtlich der Anzahl ihrer Zugriffe auf die Zeichen im String?
- Begründen Sie Ihre Antwort.
- Sie dürfen für \lstinline{strlen()} Ihre eigene Version der Funktion voraussetzen.
- \points{3}
- \item
- Von welcher Ordnung (Landau-Symbol) ist Ihre effizientere Funktion?\\
- Begründen Sie Ihre Antwort.
- \points{1}
- \end{enumerate}
-
- \solution
-
- \begin{itemize}
- \item[(a)]
- \textbf{Auf welche Weise ist die Länge eines Strings gekennzeichnet?}
-
- Ein String ist ein Array von \lstinline{char}s.
- Nach den eigentlichen Zeichen des Strings enthält das Array
- \textbf{ein Null-Symbol} (Zeichen mit Zahlenwert 0,
- nicht zu verwechseln mit der Ziffer \lstinline{'0'}) als Ende-Markierung.
- Die Länge eines Strings ist die Anzahl der Zeichen
- \emph{vor\/} diesem Symbol.
-
- \item[(b)]
- {\bf Wie lang ist die Beispiel-String-Konstante \lstinline{"Hello, world!\n"},
- und wieviel Speicherplatz belegt sie?}
-
- Sie ist 14 Zeichen lang (\lstinline{'\n'} ist nur 1 Zeichen;
- das Null-Symbol, das das Ende markiert, zählt hier nicht mit)
- und belegt Speicherplatz für 15 Zeichen
- (15 Bytes -- einschließlich Null-Symbol / Ende-Markierung).
-
- \item[(c)]
- \textbf{Schreiben Sie eine eigene Funktion \lstinline{int strlen (char *s)},
- die die Länge eines Strings zurückgibt.}
-
- Siehe die Dateien \gitfile{hp}{2022ws/20221212}{loesung-2c-1.c} (mit Array-Index)
- und \gitfile{hp}{2022ws/20221212}{loesung-2c-2.c} (mit Zeiger-Arithmetik).
- Beide Lösungen sind korrekt und arbeiten gleich schnell.
-
- Die Warnung \lstinline[style=terminal]{conflicting types for built-in function "strlen"}
- kann normalerweise ignoriert werden;
- auf manchen Systemen (z.\,B.\ MinGW) hat jedoch die eingebaute Funktion \lstinline{strlen()}
- beim Linken Vorrang vor der selbstgeschriebenen,
- so daß die selbstgeschriebene Funktion nie aufgerufen wird.
- In solchen Fällen ist es zulässig, die selbstgeschriebene Funktion
- anders zu nennen (z.\,B.\ \lstinline{my_strlen()}).
-
- \item[(d)]
- \textbf{Was bewirken die beiden Funktionen?}
-
- Beide addieren die Zahlenwerte der im String enthaltenen Zeichen
- und geben die Summe als Funktionsergebnis zurück.
-
- Im Falle des Test-Strings \lstinline{"Hello, world!\n"}
- lautet der Rückgabewert 1171 (siehe \gitfile{hp}{2022ws/20221212}{loesung-2d-1.c} und \gitfile{hp}{2022ws/20221212}{loesung-2d-2.c}).
-
- \item[(e)]
- \textbf{Schreiben Sie eine eigene Funktion,
- die dieselbe Aufgabe erledigt wie \lstinline{fun_2()},
- nur effizienter.}
-
- Die Funktion wird effizienter,
- wenn man auf den Aufruf von \lstinline{strlen()} verzichtet
- und stattdessen die Ende-Prüfung in derselben Schleife vornimmt,
- in der man auch die Zahlenwerte der Zeichen des Strings aufsummiert.
-
- Die Funktion \lstinline{fun_3()} in der Datei \gitfile{hp}{2022ws/20221212}{loesung-2e-1.c}
- realisiert dies mit einem Array-Index,
- Die Funktion \lstinline{fun_4()} in der Datei \gitfile{hp}{2022ws/20221212}{loesung-2e-2.c}
- mit Zeiger-Arithmetik.
- Beide Lösungen sind korrekt und arbeiten gleich schnell.
-
- \textbf{Bemerkung:} Die effizientere Version der Funktion
- arbeitet doppelt so schnell wie die ursprüngliche,
- hat aber ebenfalls die Ordnung $\mathcal{O}(n)$ -- siehe unten.
-
- \item[(f)]
- \textbf{Von welcher Ordnung (Landau-Symbol) sind die beiden Funktionen
- hinsichtlich der Anzahl ihrer Zugriffe auf die Zeichen im String?
- Begründen Sie Ihre Antwort.
- Sie dürfen für \lstinline{strlen()} Ihre eigene Version der Funktion voraussetzen.}
-
- Vorüberlegung: \lstinline{strlen()} greift in einer Schleife
- auf alle Zeichen des Strings der Länge $n$ zu,
- hat also $\mathcal{O}(n)$.
-
- \lstinline{fun_1()} ruft in jedem Schleifendurchlauf
- (zum Prüfen der \lstinline{while}-Bedingung) einmal \lstinline{strlen()} auf
- und greift anschließend auf ein Zeichen des Strings zu,
- hat also $\mathcal{O}\bigl(n\cdot(n+1)\bigr) = \mathcal{O}(n^2)$.
-
- \lstinline{fun_2()} ruft einmalig \lstinline{strlen()} auf
- und greift anschließend in einer Schleife auf alle Zeichen des Strings zu,
- hat also $\mathcal{O}(n+n) = \mathcal{O}(n)$.
-
- \item[(g)]
- \textbf{Von welcher Ordnung (Landau-Symbol) ist Ihre effizientere Funktion?\\
- Begründen Sie Ihre Antwort.}
-
- In beiden o.\,a.\ Lösungsvarianten
- -- \gitfile{hp}{2022ws/20221212}{loesung-2e-1.c}
- und \gitfile{hp}{2022ws/20221212}{loesung-2e-2.c} --
- arbeitet die Funktion mit einer einzigen Schleife,
- die gleichzeitig die Zahlenwerte addiert und das Ende des Strings sucht.
-
- Mit jeweils einer einzigen Schleife
- haben beide Funktionen die Ordnung $\mathcal{O}(n)$.
-
- \end{itemize}
-
- \exercise{Text-Grafik-Bibliothek}
-
- Schreiben Sie eine Bibliothek für "`Text-Grafik"' mit folgenden Funktionen:\vspace*{-\medskipamount}
- \begin{itemize}
- \item
- \lstinline|void clear (char c)|\\
- Bildschirm auf Zeichen \lstinline|c| löschen,\\
- also komplett mit diesem Zeichen (z.\,B.: Leerzeichen) füllen
- \item
- \lstinline|void put_point (int x, int y, char c)|\\
- Punkt setzen (z.\,B.\ einen Stern (\lstinline{*}) an die Stelle $(x,y)$ "`malen"')
- \item
- \lstinline|char get_point (int x, int y)|\\
- Punkt lesen
-% \item
-% \lstinline|void fill (int x, int y, char c, char o)|\\
-% Fläche in der "`Farbe"' \lstinline|o|,
-% die den Punkt \lstinline|(x, y)| enthält,
-% mit der "`Farbe"' \lstinline|c| ausmalen
- \item
- \lstinline|void display (void)|\\
- das Gezeichnete auf dem Bildschirm ausgeben
- \end{itemize}
-
- \goodbreak
-
- Hinweise:\vspace*{-\medskipamount}
- \begin{itemize}
- \item
- Eine C-Bibliothek besteht aus (mindestens)
- einer \file{.h}-Datei und einer \file{.c}-Datei.
- \item
- Verwenden Sie ein Array als "`Bildschirm"'.
-
- Vor dem Aufruf der Funktion \lstinline|display()| ist nichts zu sehen;\\
- alle Grafikoperationen erfolgen auf dem Array.
- \item
- Verwenden Sie Präprozessor-Konstante,
- z.\,B.\ \lstinline{WIDTH} und \lstinline{HEIGHT},\\
- um Höhe und Breite des "`Bildschirms"' festzulegen:
- \begin{lstlisting}[gobble=8]
- #define WIDTH 72
- #define HEIGHT 24
- \end{lstlisting}
- \item
- Schreiben Sie zusätzlich ein Test-Programm,
- das alle Funktionen der Bibliothek benutzt,\\
- um ein hübsches Bild (z.\,B.\ ein stilisiertes Gesicht -- "`Smiley"')
- auszugeben.
- \end{itemize}
- \points{8}
-
- \solution
-
- Siehe die Dateien \gitfile{hp}{2022ws/20221212}{textgraph.c} und \gitfile{hp}{2022ws/20221212}{textgraph.h} (Bibliothek)
- sowie \gitfile{hp}{2022ws/20221212}{test-textgraph.c} (Test-Programm).
-
- Diese Lösung erfüllt zusätzlich die Aufgabe,
- bei fehlerhafter Benutzung (Koordinaten außerhalb des Zeichenbereichs)
- eine sinnvolle Fehlermeldung auszugeben,
- anstatt unkontrolliert Speicher zu überschreiben und abzustürzen.
-
- Das Schlüsselwort \lstinline{static}
- bei der Deklaration der Funktion \lstinline{check_coordinates()}
- bedeutet, daß diese Funktion nur lokal (d.\,h.\ innerhalb der Bibliothek)
- verwendet und insbesondere nicht nach außen
- (d.\,h.\ für die Benutzung durch das Hauptprogramm) exportiert wird.
- Dies dient dazu, nicht unnötig Bezeichner zu reservieren
- (Vermeidung von "`Namensraumverschmutzung"').
-
- Man beachte die Verwendung einfacher Anführungszeichen (Apostrophe)
- bei der Angabe von \lstinline{char}-Kon"-stanten (\lstinline{'*'})
- im Gegensatz zur Verwendung doppelter Anführungszeichen
- bei der Angabe von String-Konstanten
- (String = Array von \lstinline{char}s, abgeschlossen mit Null-Symbol).
- Um das einfache Anführungszeichen selbst als \lstinline{char}-Konstante anzugeben,
- ist ein vorangestellter Backslash erforderlich: \lstinline{'\''} ("`Escape-Sequenz"').
- Entsprechendes gilt für die Verwendung doppelter Anführungszeichen
- innerhalb von String-Konstanten:
- \lstinline{printf ("Your name is: \"%s\"", name);}
-
- \exercise{PBM-Grafik}
-
- Bei einer PBM-Grafikdatei handelt es sich
- um ein abgespeichertes C-Array von Bytes (\lstinline{uint8_t}),
- das die Bildinformationen enthält:
- \begin{itemize}\itemsep0pt
- \item Die Datei beginnt mit der Kennung \lstinline{P4},
- danach folgen Breite und Höhe in Pixel als ASCII-Zahlen,
- danach ein Trennzeichen und die eigentlichen Bilddaten.
- \item Jedes Bit entspricht einem Pixel.
- \item Nullen stehen für Weiß, Einsen für Schwarz.
- \item MSB first.
- \item Jede Zeile des Bildes wird auf ganze Bytes aufgefüllt.
- \end{itemize}
- Viele Grafikprogramme können PBM-Dateien öffnen und bearbeiten.
- Der Anfang der Datei (Kennung, Breite und Höhe)
- ist auch in einem Texteditor lesbar.
-
- Beispiel (\gitfile{hp}{2022ws/20221212}{aufgabe-3.pbm}):\hfill
- \makebox(0,0)[tr]{\framebox{\includegraphics[scale=3]{aufgabe-3.png}}}
- \begin{lstlisting}
- P4
- 14 14
- <Bilddaten>
- \end{lstlisting}
-
- In dem untenstehenden Programmfragment (\gitfile{hp}{2022ws/20221212}{aufgabe-3.c})
- wird eine Grafik aus Textzeilen zusammengesetzt,
- so daß man mit einem Texteditor "`malen"' kann:
- \begin{lstlisting}
- #include <stdio.h>
-
- /* ... */
-
- int main (void)
- {
- pbm_open (14, 14, "test.pbm");
- pbm_line (" ");
- pbm_line (" XXXXXX ");
- pbm_line (" X X ");
- pbm_line (" X X ");
- pbm_line (" X X ");
- pbm_line (" X XX XX X ");
- pbm_line (" X X X X ");
- pbm_line (" X X ");
- pbm_line (" X X X X ");
- pbm_line (" X X X X ");
- pbm_line (" X XXXX X ");
- pbm_line (" X X ");
- pbm_line (" XXXXXX ");
- pbm_line (" ");
- pbm_close ();
- return 0;
- }
- \end{lstlisting}
- Ergänzen Sie das Programmfragment so,
- daß es eine Datei \file{test.pbm} erzeugt, die die Grafik enthält.
-
- Das Programm soll typische Benutzerfehler abfangen
- (z.\,B.\ weniger Zeilen als in \lstinline{pbm_open} angegeben),
- keine fehlerhaften Ausgaben produzieren oder abstürzen,
- sondern stattdessen sinnvolle Fehlermeldungen ausgeben.
-
- Zum Vergleich liegt eine Datei \gitfile{hp}{2022ws/20221212}{aufgabe-3.pbm}
- mit dem gewünschten Ergebnis bei,\\
- und die Datei \gitfile{hp}{2022ws/20221212}{aufgabe-3.png} enthält dasselbe Bild.
-
- \points{10}
-
- \solution
-
- Die Datei \gitfile{hp}{2022ws/20221212}{loesung-3.c} enthält eine richtige Lösung.
- Man beachte die Aufrufe der Funktion \lstinline{error()} im Falle von
- falscher Benutzung der Bibliotheksfunktionen.
- Weitere Erklärungen finden Sie als Kommentare im Quelltext.
-
- Die Datei \gitfile{hp}{2022ws/20221212}{loesung-3f.c} enthält eine falsche Lösung.
- (Beide Dateien unterscheiden sich nur in Zeile 46.)
- Dieses Programm speichert die Bits in den Bytes von rechts nach links (LSB first).
- Richtig wäre von links nach rechts (MBS first).
- Das erzeugte Bild ist dementsprechend fehlerhaft.
-
-\end{document}
diff --git a/20221212/hp-uebung-20221212.pdf b/20221212/hp-uebung-20221212.pdf
deleted file mode 100644
index 5c7ca52036ce2787b35c2eab0a31b7da68961bce..0000000000000000000000000000000000000000
Binary files a/20221212/hp-uebung-20221212.pdf and /dev/null differ
diff --git a/20221212/hp-uebung-20221212.tex b/20221212/hp-uebung-20221212.tex
deleted file mode 100644
index 874be4742ac818823b17913de97f2f0524734059..0000000000000000000000000000000000000000
--- a/20221212/hp-uebung-20221212.tex
+++ /dev/null
@@ -1,255 +0,0 @@
-% hp-uebung-20221212.pdf - Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Länge von Strings (Neuauflage), Text-Grafik-Bibliothek, PBM-Grafik
-
-% ? Hüpfender Ball (20211206-3)
-% ! Text-Grafik-Bibliothek (20211213-2)
-% ! PBM-Grafik (20211213-3)
-% ! Länge von Strings (Neuauflage) (20211220-2)
-% ? Hexdumps (20220110-3)
-% ? einfach und doppelt verkettete Listen (20220117-2)
-% ? ternärer Baum (20220117-3)
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\begin{document}
-
- \section*{Hardwarenahe Programmierung\\
- Übungsaufgaben -- 12.\ Dezember 2022}
-
- Diese Übung enthält Punkteangaben wie in einer Klausur.
- Um zu "`bestehen"', müssen Sie innerhalb von 100 Minuten
- unter Verwendung ausschließlich zugelassener Hilfsmittel
- 17 Punkte (von insgesamt \totalpoints) erreichen.
-
- \exercise{Länge von Strings}
-
- Diese Aufgabe ist eine Neuauflage von Aufgabe 2 der
- Übung vom 7.\ November 2022,\\
- ergänzt um die Teilaufgaben (f) und (g).
-
- \medskip
-
- Strings werden in der Programmiersprache C durch Zeiger auf \lstinline{char}-Variable realisiert.
-
- Beispiel: \lstinline{char *hello_world = "Hello, world!\n"}
-
- Die Systembibliothek stellt eine Funktion \lstinline{strlen()} zur Ermittlung der Länge von Strings\\
- zur Verfügung (\lstinline{#include <string.h>}).
-
- \begin{enumerate}[\quad(a)]
- \item
- Auf welche Weise ist die Länge eines Strings gekennzeichnet?
- \points{1}
- \item
- Wie lang ist die Beispiel-String-Konstante \lstinline{"Hello, world!\n"},
- und wieviel Speicherplatz belegt sie?\\
- \points{2}
- \item
- Schreiben Sie eine eigene Funktion \lstinline{int strlen (char *s)},
- die die Länge eines Strings zurückgibt.\\
- \points{3}
- \end{enumerate}
-
- \goodbreak
-
- Wir betrachten nun die folgenden Funktionen (Datei: \gitfile{hp}{2022ws/20221212}{aufgabe-2.c}):
- \begin{center}
- \begin{minipage}{8cm}
- \begin{lstlisting}[gobble=8]
- int fun_1 (char *s)
- {
- int x = 0;
- for (int i = 0; i < strlen (s); i++)
- x += s[i];
- return x;
- }
- \end{lstlisting}
- \end{minipage}%
- \begin{minipage}{6cm}
- \vspace*{-1cm}
- \begin{lstlisting}[gobble=8]
- int fun_2 (char *s)
- {
- int i = 0, x = 0;
- int len = strlen (s);
- while (i < len)
- x += s[i++];
- return x;
- }
- \end{lstlisting}
- \vspace*{-1cm}
- \end{minipage}
- \end{center}
- \begin{enumerate}[\quad(a)]\setcounter{enumi}{3}
- \item
- Was bewirken die beiden Funktionen?
- \points{2}
- \item
- Schreiben Sie eine eigene Funktion,
- die dieselbe Aufgabe erledigt wie \lstinline{fun_2()},\\
- nur effizienter.
- \points{4}
- \item
- Von welcher Ordnung (Landau-Symbol) sind die beiden Funktionen
- hinsichtlich der Anzahl ihrer Zugriffe auf die Zeichen im String?
- Begründen Sie Ihre Antwort.
- Sie dürfen für \lstinline{strlen()} Ihre eigene Version der Funktion voraussetzen.
- \points{3}
- \item
- Von welcher Ordnung (Landau-Symbol) ist Ihre effizientere Funktion?\\
- Begründen Sie Ihre Antwort.
- \points{1}
- \end{enumerate}
-
- \clearpage
- \exercise{Text-Grafik-Bibliothek}
-
- Schreiben Sie eine Bibliothek für "`Text-Grafik"' mit folgenden Funktionen:\vspace*{-\medskipamount}
- \begin{itemize}
- \item
- \lstinline|void clear (char c)|\\
- Bildschirm auf Zeichen \lstinline|c| löschen,\\
- also komplett mit diesem Zeichen (z.\,B.: Leerzeichen) füllen
- \item
- \lstinline|void put_point (int x, int y, char c)|\\
- Punkt setzen (z.\,B.\ einen Stern (\lstinline{*}) an die Stelle $(x,y)$ "`malen"')
- \item
- \lstinline|char get_point (int x, int y)|\\
- Punkt lesen
-% \item
-% \lstinline|void fill (int x, int y, char c, char o)|\\
-% Fläche in der "`Farbe"' \lstinline|o|,
-% die den Punkt \lstinline|(x, y)| enthält,
-% mit der "`Farbe"' \lstinline|c| ausmalen
- \item
- \lstinline|void display (void)|\\
- das Gezeichnete auf dem Bildschirm ausgeben
- \end{itemize}
-
- Hinweise:\vspace*{-\medskipamount}
- \begin{itemize}
- \item
- Eine C-Bibliothek besteht aus (mindestens)
- einer \file{.h}-Datei und einer \file{.c}-Datei.
- \item
- Verwenden Sie ein Array als "`Bildschirm"'.
-
- Vor dem Aufruf der Funktion \lstinline|display()| ist nichts zu sehen;\\
- alle Grafikoperationen erfolgen auf dem Array.
- \item
- Verwenden Sie Präprozessor-Konstante,
- z.\,B.\ \lstinline{WIDTH} und \lstinline{HEIGHT},\\
- um Höhe und Breite des "`Bildschirms"' festzulegen:
- \begin{lstlisting}[gobble=8]
- #define WIDTH 72
- #define HEIGHT 24
- \end{lstlisting}
- \item
- Schreiben Sie zusätzlich ein Test-Programm,
- das alle Funktionen der Bibliothek benutzt,\\
- um ein hübsches Bild (z.\,B.\ ein stilisiertes Gesicht -- "`Smiley"')
- auszugeben.
- \end{itemize}
- \points{8}
-
- \exercise{PBM-Grafik}
-
- Bei einer PBM-Grafikdatei handelt es sich
- um ein abgespeichertes C-Array von Bytes (\lstinline{uint8_t}),
- das die Bildinformationen enthält:
- \begin{itemize}\itemsep0pt
- \item Die Datei beginnt mit der Kennung \lstinline{P4},
- danach folgen Breite und Höhe in Pixel als ASCII-Zahlen,
- danach ein Trennzeichen und die eigentlichen Bilddaten.
- \item Jedes Bit entspricht einem Pixel.
- \item Nullen stehen für Weiß, Einsen für Schwarz.
- \item MSB first.
- \item Jede Zeile des Bildes wird auf ganze Bytes aufgefüllt.
- \end{itemize}
- Viele Grafikprogramme können PBM-Dateien öffnen und bearbeiten.
- Der Anfang der Datei (Kennung, Breite und Höhe)
- ist auch in einem Texteditor lesbar.
-
- Beispiel (\gitfile{hp}{2022ws/20221212}{aufgabe-3.pbm}):\hfill
- \makebox(0,0)[tr]{\framebox{\includegraphics[scale=3]{aufgabe-3.png}}}
- \begin{lstlisting}
- P4
- 14 14
- <Bilddaten>
- \end{lstlisting}
-
- In dem untenstehenden Programmfragment (\gitfile{hp}{2022ws/20221212}{aufgabe-3.c})
- wird eine Grafik aus Textzeilen zusammengesetzt,
- so daß man mit einem Texteditor "`malen"' kann:
- \begin{lstlisting}
- #include <stdio.h>
-
- /* ... */
-
- int main (void)
- {
- pbm_open (14, 14, "test.pbm");
- pbm_line (" ");
- pbm_line (" XXXXXX ");
- pbm_line (" X X ");
- pbm_line (" X X ");
- pbm_line (" X X ");
- pbm_line (" X XX XX X ");
- pbm_line (" X X X X ");
- pbm_line (" X X ");
- pbm_line (" X X X X ");
- pbm_line (" X X X X ");
- pbm_line (" X XXXX X ");
- pbm_line (" X X ");
- pbm_line (" XXXXXX ");
- pbm_line (" ");
- pbm_close ();
- return 0;
- }
- \end{lstlisting}
- Ergänzen Sie das Programmfragment so,
- daß es eine Datei \file{test.pbm} erzeugt, die die Grafik enthält.
-
- Das Programm soll typische Benutzerfehler abfangen
- (z.\,B.\ weniger Zeilen als in \lstinline{pbm_open} angegeben),
- keine fehlerhaften Ausgaben produzieren oder abstürzen,
- sondern stattdessen sinnvolle Fehlermeldungen ausgeben.
-
- Zum Vergleich liegt eine Datei \gitfile{hp}{2022ws/20221212}{aufgabe-3.pbm}
- mit dem gewünschten Ergebnis bei,\\
- und die Datei \gitfile{hp}{2022ws/20221212}{aufgabe-3.png} enthält dasselbe Bild.
-
- \points{10}
-
- \begin{flushright}
- \textit{Viel Erfolg!}
- \end{flushright}
-
- \makeatletter
- \immediate\write\@mainaux{\string\gdef\string\totalpoints{\arabic{points}}}
- \makeatother
-
-\end{document}
diff --git a/20221212/loesung-2c-1.c b/20221212/loesung-2c-1.c
deleted file mode 100644
index 69ddd0e4e749f6ca31bfa3d4f929c333648ef6ea..0000000000000000000000000000000000000000
--- a/20221212/loesung-2c-1.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int strlen (char *s)
-{
- int l = 0;
- while (s[l])
- l++;
- return l;
-}
-
-int main (void)
-{
- printf ("%d\n", strlen ("Hello, world!\n"));
- return 0;
-}
diff --git a/20221212/loesung-2c-2.c b/20221212/loesung-2c-2.c
deleted file mode 100644
index e783c474e485e80d08a6e86f8ae6e179f5a294f4..0000000000000000000000000000000000000000
--- a/20221212/loesung-2c-2.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int strlen (char *s)
-{
- char *s0 = s;
- while (*s)
- s++;
- return s - s0;
-}
-
-int main (void)
-{
- printf ("%d\n", strlen ("Hello, world!\n"));
- return 0;
-}
diff --git a/20221212/loesung-2d-1.c b/20221212/loesung-2d-1.c
deleted file mode 100644
index 57521382c21fb743c6f5f5c65320bc4ac9360b1a..0000000000000000000000000000000000000000
--- a/20221212/loesung-2d-1.c
+++ /dev/null
@@ -1,34 +0,0 @@
-
-#include <stdio.h>
-
-int strlen (char *s)
-{
- int l = 0;
- while (s[l])
- l++;
- return l;
-}
-
-int fun_1 (char *s)
-{
- int x = 0;
- for (int i = 0; i < strlen (s); i++)
- x += s[i];
- return x;
-}
-
-int fun_2 (char *s)
-{
- int i = 0, x = 0;
- int len = strlen (s);
- while (i < len)
- x += s[i++];
- return x;
-}
-
-int main (void)
-{
- printf ("%d\n", fun_1 ("Hello, world!\n"));
- printf ("%d\n", fun_2 ("Hello, world!\n"));
- return 0;
-}
diff --git a/20221212/loesung-2d-2.c b/20221212/loesung-2d-2.c
deleted file mode 100644
index 5f3f0961129aa16fc9c4510ae21bb77b69913b12..0000000000000000000000000000000000000000
--- a/20221212/loesung-2d-2.c
+++ /dev/null
@@ -1,34 +0,0 @@
-
-#include <stdio.h>
-
-int strlen (char *s)
-{
- char *s0 = s;
- while (*s)
- s++;
- return s - s0;
-}
-
-int fun_1 (char *s)
-{
- int x = 0;
- for (int i = 0; i < strlen (s); i++)
- x += s[i];
- return x;
-}
-
-int fun_2 (char *s)
-{
- int i = 0, x = 0;
- int len = strlen (s);
- while (i < len)
- x += s[i++];
- return x;
-}
-
-int main (void)
-{
- printf ("%d\n", fun_1 ("Hello, world!\n"));
- printf ("%d\n", fun_2 ("Hello, world!\n"));
- return 0;
-}
diff --git a/20221212/loesung-2e-1.c b/20221212/loesung-2e-1.c
deleted file mode 100644
index 74f5add0c5f62cccb8f817d40f860893f496db11..0000000000000000000000000000000000000000
--- a/20221212/loesung-2e-1.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int fun_3 (char *s)
-{
- int i = 0, x = 0;
- while (s[i])
- x += s[i++];
- return x;
-}
-
-int main (void)
-{
- printf ("%d\n", fun_3 ("Hello, world!\n"));
- return 0;
-}
diff --git a/20221212/loesung-2e-2.c b/20221212/loesung-2e-2.c
deleted file mode 100644
index b223d2d17c261d7cf1373a8379def8911a45ccb7..0000000000000000000000000000000000000000
--- a/20221212/loesung-2e-2.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int fun_4 (char *s)
-{
- int x = 0;
- while (*s)
- x += *s++;
- return x;
-}
-
-int main (void)
-{
- printf ("%d\n", fun_4 ("Hello, world!\n"));
- return 0;
-}
diff --git a/20221212/loesung-3.c b/20221212/loesung-3.c
deleted file mode 100644
index 8d5733e92e6a1c2d28419adc60321c50f5c18129..0000000000000000000000000000000000000000
--- a/20221212/loesung-3.c
+++ /dev/null
@@ -1,80 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-#include <string.h>
-#include <errno.h>
-#include <error.h>
-
-/* Die Aufgabe besteht darin, die Funktionen pbm_open(),
- * pbm_line() und pbm_close() zu schreiben.
- */
-
-int pbm_width = 0;
-int pbm_height = 0;
-int line_no = 0;
-FILE *pbm_file = NULL; /* globale Variable für die PBM-Datei */
-
-void pbm_open (int width, int height, char *filename)
-{
- pbm_file = fopen (filename, "w");
- if (!pbm_file)
- error (errno, errno, "pbm_open(): cannot open file %s for writing", filename);
- pbm_width = width;
- pbm_height = height;
- fprintf (pbm_file, "P4\n%d %d\n", pbm_width, pbm_height);
-}
-
-void pbm_line (char *line)
-{
- if (!pbm_file)
- error (1, 0, "pbm_line(): PBM file not open");
- if (!line)
- error (1, 0, "pbm_line(): line is NULL");
- if (strlen (line) != pbm_width)
- error (1, 0, "pbm_line(): line length does not match width");
- if (line_no >= pbm_height)
- error (1, 0, "pbm_line(): too many lines");
- int pbm_bytes = (pbm_width + 7) / 8; /* benötigte Bytes pro Zeile (immer aufrunden) */
- uint8_t buffer[pbm_bytes];
- for (int i = 0; i < pbm_bytes; i++) /* Puffer auf 0 initialisieren */
- buffer[i] = 0;
- line_no++;
- for (int x = 0; line[x]; x++)
- {
- int i = x / 8; /* In welches Byte des Puffers gehört dieses Pixel? */
- int b = x % 8; /* Welches Bit innerhalb des Bytes ist dieses Pixel? */
- if (line[x] != ' ') /* Kein Leerzeichen --> Bit auf 1 setzen */
- buffer[i] |= 0x80 >> b; /* MSB first. LSB first wäre 1 << b. */
- }
- for (int i = 0; i < pbm_bytes; i++) /* Puffer in Datei ausgeben */
- fprintf (pbm_file, "%c", buffer[i]);
-}
-
-void pbm_close (void)
-{
- if (!pbm_file)
- error (1, 0, "pbm_close(): PBM file not open");
- if (line_no < pbm_height)
- error (1, 0, "pbm_close(): too few lines");
- fclose (pbm_file);
-}
-
-int main (void)
-{
- pbm_open (14, 14, "test.pbm");
- pbm_line (" ");
- pbm_line (" XXXXXX ");
- pbm_line (" X X ");
- pbm_line (" X X ");
- pbm_line (" X X ");
- pbm_line (" X XX XX X ");
- pbm_line (" X X X X ");
- pbm_line (" X X ");
- pbm_line (" X X X X ");
- pbm_line (" X X X X ");
- pbm_line (" X XXXX X ");
- pbm_line (" X X ");
- pbm_line (" XXXXXX ");
- pbm_line (" ");
- pbm_close ();
- return 0;
-}
diff --git a/20221212/loesung-3f.c b/20221212/loesung-3f.c
deleted file mode 100644
index d358fa1de54ad08a770dc733d089d3d40342bdde..0000000000000000000000000000000000000000
--- a/20221212/loesung-3f.c
+++ /dev/null
@@ -1,80 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-#include <string.h>
-#include <errno.h>
-#include <error.h>
-
-/* Die Aufgabe besteht darin, die Funktionen pbm_open(),
- * pbm_line() und pbm_close() zu schreiben.
- */
-
-int pbm_width = 0;
-int pbm_height = 0;
-int line_no = 0;
-FILE *pbm_file = NULL; /* globale Variable für die PBM-Datei */
-
-void pbm_open (int width, int height, char *filename)
-{
- pbm_file = fopen (filename, "w");
- if (!pbm_file)
- error (errno, errno, "pbm_open(): cannot open file %s for writing", filename);
- pbm_width = width;
- pbm_height = height;
- fprintf (pbm_file, "P4\n%d %d\n", pbm_width, pbm_height);
-}
-
-void pbm_line (char *line)
-{
- if (!pbm_file)
- error (1, 0, "pbm_line(): PBM file not open");
- if (!line)
- error (1, 0, "pbm_line(): line is NULL");
- if (strlen (line) != pbm_width)
- error (1, 0, "pbm_line(): line length does not match width");
- if (line_no >= pbm_height)
- error (1, 0, "pbm_line(): too many lines");
- int pbm_bytes = (pbm_width + 7) / 8; /* benötigte Bytes pro Zeile (immer aufrunden) */
- uint8_t buffer[pbm_bytes];
- for (int i = 0; i < pbm_bytes; i++) /* Puffer auf 0 initialisieren */
- buffer[i] = 0;
- line_no++;
- for (int x = 0; line[x]; x++)
- {
- int i = x / 8; /* In welches Byte des Puffers gehört dieses Pixel? */
- int b = x % 8; /* Welches Bit innerhalb des Bytes ist dieses Pixel? */
- if (line[x] != ' ') /* Kein Leerzeichen --> Bit auf 1 setzen */
- buffer[i] |= 1 << b;
- }
- for (int i = 0; i < pbm_bytes; i++) /* Puffer in Datei ausgeben */
- fprintf (pbm_file, "%c", buffer[i]);
-}
-
-void pbm_close (void)
-{
- if (!pbm_file)
- error (1, 0, "pbm_close(): PBM file not open");
- if (line_no < pbm_height)
- error (1, 0, "pbm_close(): too few lines");
- fclose (pbm_file);
-}
-
-int main (void)
-{
- pbm_open (14, 14, "test.pbm");
- pbm_line (" ");
- pbm_line (" XXXXXX ");
- pbm_line (" X X ");
- pbm_line (" X X ");
- pbm_line (" X X ");
- pbm_line (" X XX XX X ");
- pbm_line (" X X X X ");
- pbm_line (" X X ");
- pbm_line (" X X X X ");
- pbm_line (" X X X X ");
- pbm_line (" X XXXX X ");
- pbm_line (" X X ");
- pbm_line (" XXXXXX ");
- pbm_line (" ");
- pbm_close ();
- return 0;
-}
diff --git a/20221212/logo-hochschule-bochum-cvh-text-v2.pdf b/20221212/logo-hochschule-bochum-cvh-text-v2.pdf
deleted file mode 120000
index 4aa99b8f81061aca6dcaf43eed2d9efef40555f8..0000000000000000000000000000000000000000
--- a/20221212/logo-hochschule-bochum-cvh-text-v2.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
diff --git a/20221212/logo-hochschule-bochum.pdf b/20221212/logo-hochschule-bochum.pdf
deleted file mode 120000
index b6b9491e370e499c9276918182cdb82cb311bcd1..0000000000000000000000000000000000000000
--- a/20221212/logo-hochschule-bochum.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20221212/pgscript.sty b/20221212/pgscript.sty
deleted file mode 120000
index 95c888478c99ea7fda0fd11ccf669ae91be7178b..0000000000000000000000000000000000000000
--- a/20221212/pgscript.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgscript.sty
\ No newline at end of file
diff --git a/20221212/test-textgraph.c b/20221212/test-textgraph.c
deleted file mode 100644
index 4033f61ba55d794afbb5b6c03a0bb55dcc5d3e4e..0000000000000000000000000000000000000000
--- a/20221212/test-textgraph.c
+++ /dev/null
@@ -1,36 +0,0 @@
-#include <stdio.h>
-#include "textgraph.h"
-
-int main (void)
-{
- clear (' ');
- put_point (-5, 10, 'X');
- for (int i = 17; i < 23; i++)
- put_point (i, 5, '*');
- put_point (15, 6, '*');
- put_point (14, 7, '*');
- put_point (13, 8, '*');
- put_point (13, 9, '*');
- put_point (14, 10, '*');
- put_point (15, 11, '*');
- for (int i = 17; i < 23; i++)
- put_point (i, 12, '*');
- put_point (24, 11, '*');
- put_point (25, 10, '*');
- put_point (26, 9, '*');
- put_point (26, 8, '*');
- put_point (25, 7, '*');
- put_point (24, 6, '*');
- put_point (18, 8, 'O');
- put_point (21, 8, 'O');
- put_point (17, 10, '`');
- for (int i = 18; i < 22; i++)
- put_point (i, 10, '-');
- put_point (22, 10, '\'');
- put_point (13, 42, 'Y');
- printf ("get_point (%d, %d): '%c'\n", 13, 9, get_point (13, 9));
- printf ("get_point (%d, %d): '%c'\n", 14, 9, get_point (14, 9));
- printf ("get_point (%d, %d): '%c'\n", 94, 9, get_point (94, 9));
- display ();
- return 0;
-}
diff --git a/20221212/textgraph.c b/20221212/textgraph.c
deleted file mode 100644
index a17f9a91173f9fe871967f5aef509798c0efbb64..0000000000000000000000000000000000000000
--- a/20221212/textgraph.c
+++ /dev/null
@@ -1,46 +0,0 @@
-#include <stdio.h>
-#include "textgraph.h"
-
-char buffer[HEIGHT][WIDTH];
-
-void clear (char c)
-{
- for (int y = 0; y < HEIGHT; y++)
- for (int x = 0; x < WIDTH; x++)
- buffer[y][x] = c;
-}
-
-static int check_coordinates (int x, int y, char *function)
-{
- if (x >= 0 && x < WIDTH && y >= 0 && y < HEIGHT)
- return 1;
- else
- {
- fprintf (stderr, "coordinates (%d,%d) out of range in %s\n", x, y, function);
- return 0;
- }
-}
-
-void put_point (int x, int y, char c)
-{
- if (check_coordinates (x, y, "put_point"))
- buffer[y][x] = c;
-}
-
-char get_point (int x, int y)
-{
- if (check_coordinates (x, y, "get_point"))
- return buffer[y][x];
- else
- return 0;
-}
-
-void display (void)
-{
- for (int y = 0; y < HEIGHT; y++)
- {
- for (int x = 0; x < WIDTH; x++)
- printf ("%c", buffer[y][x]);
- printf ("\n");
- }
-}
diff --git a/20221212/textgraph.h b/20221212/textgraph.h
deleted file mode 100644
index 419e0fbd04f3b5d07d42509ab1980513d434eb07..0000000000000000000000000000000000000000
--- a/20221212/textgraph.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef TEXTGRAPH_H
-#define TEXTGRAPH_H
-
-#define WIDTH 40
-#define HEIGHT 20
-
-extern void clear (char c);
-extern void put_point (int x, int y, char c);
-extern char get_point (int x, int y);
-extern void display (void);
-
-#endif
diff --git a/20221212/tier-datenbank-01.c b/20221212/tier-datenbank-01.c
deleted file mode 100644
index d03f97b80c06c305ab08b491c768165c543afb14..0000000000000000000000000000000000000000
--- a/20221212/tier-datenbank-01.c
+++ /dev/null
@@ -1,48 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- a[0]->type = WITH_WINGS;
- a[0]->name = "duck";
- ((with_wings *) a[0])->wings = 2;
-
- animal cow;
- a[1] = &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- ((with_legs *) a[1])->legs = 4;
-
- for (int i = 0; i < 2; i++)
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name, ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name, ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
-
- return 0;
-}
diff --git a/20221212/tier-datenbank-02.c b/20221212/tier-datenbank-02.c
deleted file mode 100644
index bd3b8afc70b40889bdfb5d8a92c56155c082db2b..0000000000000000000000000000000000000000
--- a/20221212/tier-datenbank-02.c
+++ /dev/null
@@ -1,51 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- a[0]->type = WITH_WINGS;
- a[0]->name = "duck";
- ((with_wings *) a[0])->wings = 2;
-
- animal cow;
- a[1] = &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- ((with_legs *) a[1])->legs = 4;
-
- for (int i = 0; i < 2; i++)
- {
- printf ("a[i]->type = %d\n", a[i]->type);
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name, ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name, ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
- }
-
- return 0;
-}
diff --git a/20221212/tier-datenbank-03.c b/20221212/tier-datenbank-03.c
deleted file mode 100644
index 31029a4a159cf1c93f8cc8238acd54c8f4cca23b..0000000000000000000000000000000000000000
--- a/20221212/tier-datenbank-03.c
+++ /dev/null
@@ -1,51 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- a[0]->type = WITH_WINGS;
- a[0]->name = "duck";
- ((with_wings *) a[0])->wings = 2;
-
- animal cow;
- a[1] = &cow;
-// a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- ((with_legs *) a[1])->legs = 4;
-
- for (int i = 0; i < 2; i++)
- {
- printf ("a[i]->type = %d\n", a[i]->type);
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name, ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name, ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
- }
-
- return 0;
-}
diff --git a/20221212/tier-datenbank-04.c b/20221212/tier-datenbank-04.c
deleted file mode 100644
index c41051f7d1c037b9dd05a9d93b542b4871e59775..0000000000000000000000000000000000000000
--- a/20221212/tier-datenbank-04.c
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- printf ("1: a[0]->type = %d\n", a[0]->type);
- a[0]->type = WITH_WINGS;
- printf ("2: a[0]->type = %d\n", a[0]->type);
- a[0]->name = "duck";
- printf ("3: a[0]->type = %d\n", a[0]->type);
- ((with_wings *) a[0])->wings = 2;
- printf ("4: a[0]->type = %d\n", a[0]->type);
-
- animal cow;
- printf ("5: a[0]->type = %d\n", a[0]->type);
- a[1] = &cow;
- printf ("6: a[0]->type = %d\n", a[0]->type);
- a[1]->type = WITH_LEGS;
- printf ("7: a[0]->type = %d\n", a[0]->type);
- a[1]->name = "cow";
- printf ("8: a[0]->type = %d\n", a[0]->type);
- ((with_legs *) a[1])->legs = 4;
- printf ("9: a[0]->type = %d\n", a[0]->type);
-
- for (int i = 0; i < 2; i++)
- {
- printf ("a[i]->type = %d\n", a[i]->type);
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name, ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name, ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
- }
-
- return 0;
-}
diff --git a/20221212/tier-datenbank-05.c b/20221212/tier-datenbank-05.c
deleted file mode 100644
index fcd9745e2ac3a5b270e3ff50b3d873ac458c1575..0000000000000000000000000000000000000000
--- a/20221212/tier-datenbank-05.c
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- printf ("1: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- a[0]->type = WITH_WINGS;
- printf ("2: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- a[0]->name = "duck";
- printf ("3: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- ((with_wings *) a[0])->wings = 2;
- printf ("4: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
-
- animal cow;
- printf ("5: a[0]->type = %d\n", a[0]->type);
- a[1] = &cow;
- printf ("6: a[0]->type = %d\n", a[0]->type);
- a[1]->type = WITH_LEGS;
- printf ("7: a[0]->type = %d\n", a[0]->type);
- a[1]->name = "cow";
- printf ("8: a[0]->type = %d\n", a[0]->type);
- ((with_legs *) a[1])->legs = 4;
- printf ("9: a[0]->type = %d\n", a[0]->type);
-
- for (int i = 0; i < 2; i++)
- {
- printf ("a[i]->type = %d\n", a[i]->type);
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name, ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name, ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
- }
-
- return 0;
-}
diff --git a/20221212/tier-datenbank-06.c b/20221212/tier-datenbank-06.c
deleted file mode 100644
index 57f45244067cc1ad3d61ed68f4db427af0099fad..0000000000000000000000000000000000000000
--- a/20221212/tier-datenbank-06.c
+++ /dev/null
@@ -1,55 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- printf ("1: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- a[0]->type = WITH_WINGS;
- printf ("2: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- a[0]->name = "duck";
- printf ("3: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- ((with_wings *) a[0])->wings = 2;
- printf ("4: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
-
- animal cow;
- a[1] = &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- ((with_legs *) a[1])->legs = 4;
-
- for (int i = 0; i < 2; i++)
- {
- printf ("a[%d]->type = %d\n", i, a[i]->type);
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name, ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name, ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
- }
-
- return 0;
-}
diff --git a/20221212/tier-datenbank-07.c b/20221212/tier-datenbank-07.c
deleted file mode 100644
index 9472095fb2da3066970d5414f0445c4e43572641..0000000000000000000000000000000000000000
--- a/20221212/tier-datenbank-07.c
+++ /dev/null
@@ -1,57 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int type;
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int type;
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- printf ("1: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- a[0]->type = WITH_WINGS;
- printf ("2: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- a[0]->name = "duck";
- printf ("3: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- ((with_wings *) a[0])->wings = 2;
- printf ("4: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
-
- animal cow;
- a[1] = &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- ((with_legs *) a[1])->legs = 4;
-
- for (int i = 0; i < 2; i++)
- {
- printf ("a[%d]->type = %d\n", i, a[i]->type);
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name, ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name, ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
- }
-
- return 0;
-}
diff --git a/20221212/tier-datenbank-08.c b/20221212/tier-datenbank-08.c
deleted file mode 100644
index 99c3d0826b41eb076af6cccf88c313a68e5a5d13..0000000000000000000000000000000000000000
--- a/20221212/tier-datenbank-08.c
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- int dummy; /* 64-Bit-Alignment */
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int type;
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int type;
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- printf ("1: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- a[0]->type = WITH_WINGS;
- printf ("2: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- a[0]->name = "duck";
- printf ("3: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- ((with_wings *) a[0])->wings = 2;
- printf ("4: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
-
- animal cow;
- a[1] = &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- ((with_legs *) a[1])->legs = 4;
-
- for (int i = 0; i < 2; i++)
- {
- printf ("a[%d]->type = %d\n", i, a[i]->type);
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name, ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name, ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
- }
-
- return 0;
-}
diff --git a/20221212/tier-datenbank-09.c b/20221212/tier-datenbank-09.c
deleted file mode 100644
index 8393ec2786708930bf270d8c4ac1b56d9471f215..0000000000000000000000000000000000000000
--- a/20221212/tier-datenbank-09.c
+++ /dev/null
@@ -1,59 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int type;
- char *name;
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int type;
- char *name;
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- animal duck;
- a[0] = &duck;
- printf ("1: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- a[0]->type = WITH_WINGS;
- printf ("2: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- a[0]->name = "duck";
- printf ("3: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- ((with_wings *) a[0])->wings = 2;
- printf ("4: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
-
- animal cow;
- a[1] = &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- ((with_legs *) a[1])->legs = 4;
-
- for (int i = 0; i < 2; i++)
- {
- printf ("a[%d]->type = %d\n", i, a[i]->type);
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name, ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name, ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
- }
-
- return 0;
-}
diff --git a/20221212/tier-datenbank-10.c b/20221212/tier-datenbank-10.c
deleted file mode 100644
index b146d5cc3b1b24ad3d90012150c43a71ae2ba9f9..0000000000000000000000000000000000000000
--- a/20221212/tier-datenbank-10.c
+++ /dev/null
@@ -1,59 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int type;
- char *name;
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int type;
- char *name;
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- with_wings duck;
- a[0] = &duck;
- printf ("1: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- a[0]->type = WITH_WINGS;
- printf ("2: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- a[0]->name = "duck";
- printf ("3: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- ((with_wings *) a[0])->wings = 2;
- printf ("4: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
-
- with_legs cow;
- a[1] = &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- ((with_legs *) a[1])->legs = 4;
-
- for (int i = 0; i < 2; i++)
- {
- printf ("a[%d]->type = %d\n", i, a[i]->type);
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name, ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name, ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
- }
-
- return 0;
-}
diff --git a/20221212/tier-datenbank-11.c b/20221212/tier-datenbank-11.c
deleted file mode 100644
index b5399a5914b750b5b34c6ec297ab3ab3fc6ba749..0000000000000000000000000000000000000000
--- a/20221212/tier-datenbank-11.c
+++ /dev/null
@@ -1,59 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int type;
- char *name;
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int type;
- char *name;
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- with_wings duck;
- a[0] = (with_wings *) &duck;
- printf ("1: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- a[0]->type = WITH_WINGS;
- printf ("2: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- a[0]->name = "duck";
- printf ("3: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- ((with_wings *) a[0])->wings = 2;
- printf ("4: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
-
- with_legs cow;
- a[1] = (with_legs *) &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- ((with_legs *) a[1])->legs = 4;
-
- for (int i = 0; i < 2; i++)
- {
- printf ("a[%d]->type = %d\n", i, a[i]->type);
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name, ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name, ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
- }
-
- return 0;
-}
diff --git a/20221212/tier-datenbank-12.c b/20221212/tier-datenbank-12.c
deleted file mode 100644
index 83bfb8d6254c3e60ea9530dc61da76ced143dae3..0000000000000000000000000000000000000000
--- a/20221212/tier-datenbank-12.c
+++ /dev/null
@@ -1,66 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef union object
-{
- animal a;
- with_wings w;
- with_legs l;
-} object;
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int type;
- char *name;
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int type;
- char *name;
- int legs;
-} with_legs;
-
-int main (void)
-{
- animal *a[2];
-
- with_wings duck;
- a[0] = (with_wings *) &duck;
- printf ("1: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- a[0]->type = WITH_WINGS;
- printf ("2: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- a[0]->name = "duck";
- printf ("3: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
- ((with_wings *) a[0])->wings = 2;
- printf ("4: a[0]->type = %d, a[0]->wings = %d\n", a[0]->type, ((with_wings *) a[0])->wings);
-
- with_legs cow;
- a[1] = (with_legs *) &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- ((with_legs *) a[1])->legs = 4;
-
- for (int i = 0; i < 2; i++)
- {
- printf ("a[%d]->type = %d\n", i, a[i]->type);
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name, ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name, ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
- }
-
- return 0;
-}
diff --git a/20221212/tier-datenbank-13.c b/20221212/tier-datenbank-13.c
deleted file mode 100644
index e556244ecddc251493d779ad9b743df32c61d853..0000000000000000000000000000000000000000
--- a/20221212/tier-datenbank-13.c
+++ /dev/null
@@ -1,61 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int type;
- char *name;
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int type;
- char *name;
- int legs;
-} with_legs;
-
-typedef union object
-{
- animal a;
- with_wings w;
- with_legs l;
-} object;
-
-int main (void)
-{
- animal *a[2];
-
- with_wings duck;
- a[0] = (animal *) &duck;
- a[0]->type = WITH_WINGS;
- a[0]->name = "duck";
- ((with_wings *) a[0])->wings = 2;
-
- with_legs cow;
- a[1] = (animal *) &cow;
- a[1]->type = WITH_LEGS;
- a[1]->name = "cow";
- ((with_legs *) a[1])->legs = 4;
-
- for (int i = 0; i < 2; i++)
- {
- if (a[i]->type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->name, ((with_legs *) a[i])-> legs);
- else if (a[i]->type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->name, ((with_wings *) a[i])-> wings);
- else
- printf ("Error in animal: %s\n", a[i]->name);
- }
-
- return 0;
-}
diff --git a/20221212/tier-datenbank-14.c b/20221212/tier-datenbank-14.c
deleted file mode 100644
index 74eeb74db0f3369b98b30406dbc535cb79b45ca2..0000000000000000000000000000000000000000
--- a/20221212/tier-datenbank-14.c
+++ /dev/null
@@ -1,61 +0,0 @@
-#include <stdio.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int type;
- char *name;
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int type;
- char *name;
- int legs;
-} with_legs;
-
-typedef union object
-{
- animal a;
- with_wings w;
- with_legs l;
-} object;
-
-int main (void)
-{
- object *a[2];
-
- object duck;
- a[0] = &duck;
- a[0]->a.type = WITH_WINGS;
- a[0]->a.name = "duck";
- a[0]->w.wings = 2;
-
- object cow;
- a[1] = &cow;
- a[1]->a.type = WITH_LEGS;
- a[1]->a.name = "cow";
- a[1]->l.legs = 4;
-
- for (int i = 0; i < 2; i++)
- {
- if (a[i]->a.type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->a.name, a[i]->l.legs);
- else if (a[i]->a.type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->a.name, a[i]->w.wings);
- else
- printf ("Error in animal: %s\n", a[i]->a.name);
- }
-
- return 0;
-}
diff --git a/20221212/tier-datenbank-15.c b/20221212/tier-datenbank-15.c
deleted file mode 100644
index 1fee6ab7722c1d05eb68a22d909a4bcf6175b4d6..0000000000000000000000000000000000000000
--- a/20221212/tier-datenbank-15.c
+++ /dev/null
@@ -1,68 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#define ANIMAL 0
-#define WITH_WINGS 1
-#define WITH_LEGS 2
-
-typedef struct animal
-{
- int type;
- char *name;
-} animal;
-
-typedef struct with_wings
-{
- int type;
- char *name;
- int wings;
-} with_wings;
-
-typedef struct with_legs
-{
- int type;
- char *name;
- int legs;
-} with_legs;
-
-typedef union object
-{
- animal a;
- with_wings w;
- with_legs l;
-} object;
-
-object *new_wings (char *pname, int pwings)
-{
- object *o = malloc (sizeof (with_wings));
- o->a.type = WITH_WINGS;
- o->a.name = pname;
- o->l.legs = pwings;
- return o;
-}
-
-object *new_legs (char *pname, int plegs)
-{
- object *o = malloc (sizeof (with_legs));
- o->a.type = WITH_LEGS;
- o->a.name = pname;
- o->l.legs = plegs;
- return o;
-}
-
-int main (void)
-{
- object *a[2] = { new_wings ("duck", 2), new_legs ("cow", 4) };
-
- for (int i = 0; i < 2; i++)
- {
- if (a[i]->a.type == WITH_LEGS)
- printf ("A %s has %d legs.\n", a[i]->a.name, a[i]->l.legs);
- else if (a[i]->a.type == WITH_WINGS)
- printf ("A %s has %d wings.\n", a[i]->a.name, a[i]->w.wings);
- else
- printf ("Error in animal: %s\n", a[i]->a.name);
- }
-
- return 0;
-}
diff --git a/20221219/hp-20221219.pdf b/20221219/hp-20221219.pdf
deleted file mode 100644
index 92ee79e58267f1a17c4e8148b5c659d57a12ffaa..0000000000000000000000000000000000000000
Binary files a/20221219/hp-20221219.pdf and /dev/null differ
diff --git a/20221219/hp-20221219.tex b/20221219/hp-20221219.tex
deleted file mode 100644
index b8192292385110d8e8c3e66f9c20d84e87bab5ff..0000000000000000000000000000000000000000
--- a/20221219/hp-20221219.tex
+++ /dev/null
@@ -1,786 +0,0 @@
-% hp-20221212.pdf - Lecture Slides on Low-Level Programming
-% Copyright (C) 2012, 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% attribution-sharealike 3.0 license, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Objektorientierte Programmierung, Datenstrukturen
-
-\documentclass[10pt,t]{beamer}
-
-\usepackage{pgslides}
-\usepackage{pdftricks}
-\usepackage{tikz}
-\usepackage{rotating}
-
-\begin{psinputs}
- \usepackage[utf8]{inputenc}
- \usepackage[german]{babel}
- \usepackage[T1]{fontenc}
- \usepackage{helvet}
- \renewcommand*\familydefault{\sfdefault}
- \usepackage{pstricks,pst-grad}
-\end{psinputs}
-
-\newcommand{\redurl}[1]{\href{#1}{\color{red}\nolinkurl{#1}}}
-
-\title{Hardwarenahe Programmierung}
-\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
-\date{12.\ Dezember 2022}
-
-\begin{document}
-
-\maketitleframe
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \item[\textbf{5}] \textbf{Algorithmen}
- \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
- \begin{itemize}
- \vspace*{-\smallskipamount}
- \item[\dots]
- \item[6.3] Unions
- \color{medgreen}
- \item[6.4] Virtuelle Methoden
- \item[6.5] Beispiel: Graphische Benutzeroberfläche (GUI)
- \item[6.6] Ausblick: C++
- \end{itemize}
- \item[\textbf{7}] \textbf{Datenstrukturen}
- \begin{itemize}
- \color{medgreen}
- \item[7.1] Stack und FIFO
- \color{red}
- \item[7.2] Verkettete Listen
- \item[7.3] Bäume
- \end{itemize}
- \vspace*{-1cm}
- \end{itemize}
- \vspace*{-1cm}
-
-\end{frame}
-
-\setcounter{section}{5}
-\section{Objektorientierte Programmierung}
-\setcounter{subsection}{3}
-\subsection{Virtuelle Methoden}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{lstlisting}
- void print_object (t_object *this)
- {
- if (this->base.type == T_INTEGER)
- printf ("Integer: %d\n", this->integer.content);
- else if (this->base.type == T_STRING)
- printf ("String: \"%s\"\n", this->string.content);
- }
- \end{lstlisting}
-
- \begin{picture}(0,0)
- \color{red}
- \put(9,1.7){\shortstack[l]{if-Kette:\\\strut wird unübersichtlich}}
- \put(1,-2){\mbox{\textarrow}}
- \put(0,-3){\mbox{Zeiger auf Funktionen}}
- \end{picture}
-
- \begin{lstlisting}[xleftmargin=4cm]
- void print_integer (t_object *this)
- {
- printf ("Integer: %d\n", this->integer.content);
- }
-
- void print_string (t_object *this)
- {
- printf ("String: \"%s\"\n", this->string.content);
- }
- \end{lstlisting}
-
-\end{frame}
-
-\begin{frame}[fragile]
- \showsubsection
-
- Zeiger auf Funktionen
-
- \medskip
-
- \begin{lstlisting}
- void (*print) (t_object *this);
- \end{lstlisting}
- \begin{picture}(0,1.2)(0,-0.9)
- \color{red}
- \put(0.95,0.3){\mbox{$\underbrace{\rule{1cm}{0pt}}$}}
- \put(0.2,-0.7){\shortstack{das, worauf print zeigt,\\ist eine Funktion}}
- \end{picture}
-
- \begin{itemize}
- \item
- Objekt enthält Zeiger auf Funktion
- \begin{onlyenv}<1>
- \medskip
- \begin{lstlisting}[gobble=10]
- typedef struct
- {
- void (*print) (union t_object *this);
- int content;
- } t_integer;
- \end{lstlisting}
- \vspace*{-2cm}
- \end{onlyenv}
- \begin{onlyenv}<2->
- \vspace*{-3.5cm} % Why doesn't a picture environment work here??? :-(
- \begin{lstlisting}[gobble=10,xleftmargin=5.5cm]
- typedef struct
- {
- void (*print) (union t_object *this);
- int content;
- } t_integer;
- \end{lstlisting}
- \vspace*{0.85cm}
- \bigskip
- \smallskip
- \end{onlyenv}
- \pause
- \item
- Konstruktor initialisiert diesen Zeiger
- \begin{onlyenv}<2>
- \medskip
- \begin{lstlisting}[gobble=10]
- t_object *new_integer (int i)
- {
- t_object *p = malloc (sizeof (t_integer));
- p->integer.print = print_integer;
- p->integer.content = i;
- return p;
- }
- \end{lstlisting}
- \vspace*{-2cm}
- \end{onlyenv}
- \pause
- \item
- Aufruf: "`automatisch"' die richtige Funktion
- \begin{onlyenv}<3>
- \medskip
- \begin{lstlisting}[gobble=10]
- for (int i = 0; object[i]; i++)
- object[i]->base.print (object[i]);
- \end{lstlisting}
- \end{onlyenv}
- \pause
- \medskip
- \item
- in größeren Projekten:\\
- Objekt enthält Zeiger auf Tabelle von Funktionen
- \end{itemize}
-\end{frame}
-
-\subsection{Beispiel: Graphische Benutzeroberfläche (GUI)}
-
-\begin{frame}[fragile]
-
- \showsubsection
-
- \scriptsize
- \begin{lstlisting}
- #include <gtk/gtk.h>
-
- int main (int argc, char **argv)
- {
- gtk_init (&argc, &argv);
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
- GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- gtk_container_add (GTK_CONTAINER (window), vbox);
- gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
- GtkWidget *label = gtk_label_new ("Hello, world!");
- gtk_container_add (GTK_CONTAINER (vbox), label);
- GtkWidget *button = gtk_button_new_with_label ("Quit");
- g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
- gtk_container_add (GTK_CONTAINER (vbox), button);
- gtk_widget_show (button);
- gtk_widget_show (label);
- gtk_widget_show (vbox);
- gtk_widget_show (window);
- gtk_main ();
- return 0;
- }
- \end{lstlisting}
-
- \vspace*{-6cm}\strut\hfill
- \includegraphics[scale=0.85]{hello-gtk.png}\\[2cm]
- \begin{flushright}
- \normalsize\bf Praktikumsversuch:\\
- Objektorientiertes Zeichenprogramm
- \end{flushright}
-
-\end{frame}
-
-\subsection{Ausblick: C++}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{center}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- void (*print) (union t_object *this);
- } t_base;¿
- \end{lstlisting}
- \end{minipage}\\[0.5cm]
- \begin{minipage}{5.5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- void (*print) (...);
- int content;
- } t_integer;¿
- \end{lstlisting}
- \end{minipage}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡typedef struct
- {
- void (*print) (union t_object *this);
- char *content;
- } t_string;¿
- \end{lstlisting}
- \end{minipage}
- \end{center}
-
-\end{frame}
-
-\begin{frame}[fragile]
- \showsubsection
-
- \begin{center}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡struct TBase
- {
- virtual void print (void);
- };¿
- \end{lstlisting}
- \end{minipage}\\[0.5cm]
- \begin{minipage}{5.5cm}
- \begin{lstlisting}[gobble=8]
- ¡struct TInteger: public TBase
- {
- virtual void print (void);
- int content;
- };¿
- \end{lstlisting}
- \end{minipage}
- \begin{minipage}{5cm}
- \begin{lstlisting}[gobble=8]
- ¡struct TString: public TBase
- {
- virtual void print (void);
- char *content;
- };¿
- \end{lstlisting}
- \end{minipage}
- \end{center}
-
-\end{frame}
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \item[\textbf{5}] \textbf{Algorithmen}
- \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
- \begin{itemize}
- \vspace*{-\smallskipamount}
- \item[\dots]
- \item[6.3] Unions
- \color{medgreen}
- \item[6.4] Virtuelle Methoden
- \item[6.5] Beispiel: Graphische Benutzeroberfläche (GUI)
- \item[6.6] Ausblick: C++
- \end{itemize}
- \item[\textbf{7}] \textbf{Datenstrukturen}
- \begin{itemize}
- \color{medgreen}
- \item[7.1] Stack und FIFO
- \color{red}
- \item[7.2] Verkettete Listen
- \item[7.3] Bäume
- \end{itemize}
- \vspace*{-1cm}
- \end{itemize}
-
-\end{frame}
-
-\section{Datenstrukturen}
-\subsection{Stack und FIFO}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \begin{minipage}{0.48\textwidth}
- Im letzten Praktikumsversuch:
- \begin{itemize}
- \item
- Array nur zum Teil benutzt
- \item
- Variable speichert genutzte Länge
- \item
- Elemente hinten anfügen\\
- oder entfernen
- \arrowitem
- Stack\\
- \strut
- \end{itemize}
- \bigskip
- \begin{itemize}
- \item
- hinten anfügen/entfernen: $\mathcal{O}(1)$\hspace*{-1cm}
- \item
- vorne oder in der Mitte einfügen/entfernen: $\mathcal{O}(n)$
- \end{itemize}
- \end{minipage}\hfill
- \begin{minipage}{0.52\textwidth}
- Auch möglich:
- \begin{itemize}
- \item
- Array nur zum Teil benutzt
- \item
- 2 Variable speichern\\genutzte Länge (ringförmig)
- \item
- Elemente hinten anfügen\\
- oder vorne entfernen
- \arrowitem
- FIFO
- \end{itemize}
- \bigskip
- \begin{itemize}
- \item
- vorne oder hinten\\
- anfügen oder entfernen: $\mathcal{O}(1)$
- \item
- in der Mitte einfügen/entfernen: $\mathcal{O}(n)$
- \end{itemize}
- \end{minipage}\hspace*{-1.5mm}
-
-\end{frame}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \bigskip
-
- \begin{minipage}[b]{6cm}
- \begin{center}
- "`First In -- First Out"'
-
- \bigskip
-
- \begin{picture}(6,4)
- \thicklines
- \color{structure}
- \put(0.5,0){\line(1,0){5}}
-
- \put(3.5,0){\only<1-5>{\line(0,1){1}}}
- \put(4.5,0){\only<1-4>{\line(0,1){1}}}
- \put(3.5,1){\only<1-4>{\line(1,0){1}}}
- \put(4.0,0.5){\only<1-4>{\makebox(0,0){\lstinline{3}}}}
- \put(3.0,1.5){\only<1>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
- \put(3.0,1.5){\only<1>{\makebox(0,0)[b]{\lstinline{push (3)}}}}
-
- \put(2.5,0){\only<2-6>{\line(0,1){1}}}
- \put(2.5,1){\only<2-5>{\line(1,0){1}}}
- \put(3.0,0.5){\only<2-5>{\makebox(0,0){\lstinline{7}}}}
- \put(2.0,1.5){\only<2>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
- \put(2.0,1.5){\only<2>{\makebox(0,0)[b]{\lstinline{push (7)}}}}
-
- \put(1.5,0){\only<3-6>{\line(0,1){1}}}
- \put(1.5,1){\only<3-6>{\line(1,0){1}}}
- \put(2.0,0.5){\only<3-6>{\makebox(0,0){\lstinline{137}}}}
- \put(1.0,1.5){\only<3>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
- \put(1.0,1.5){\only<3>{\makebox(0,0)[b]{\lstinline{push (137)}}}}
-
- \put(4.55,1.05){\only<4>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
- \put(5.00,1.60){\only<4>{\makebox(0,0)[b]{\lstinline{pop ()}: 3}}}
-
- \put(3.55,1.05){\only<5>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
- \put(4.00,1.60){\only<5>{\makebox(0,0)[b]{\lstinline{pop ()}: 7}}}
-
- \put(2.55,1.05){\only<6>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
- \put(3.00,1.60){\only<6>{\makebox(0,0)[b]{\lstinline{pop ()}: 137}}}
- \end{picture}
-
- \bigskip
-
- FIFO = Queue = Reihe
- \end{center}
- \end{minipage}\hfill
- \begin{minipage}[b]{6cm}
- \begin{center}
- "`Last In -- First Out"'
-
- \bigskip
-
- \begin{picture}(6,4)
- \thicklines
- \color{structure}
- \put(1.5,0){\line(1,0){3}}
-
- \put(2.5,0){\line(0,1){1}}
- \put(3.5,0){\line(0,1){1}}
- \put(2.5,1){\line(1,0){1}}
- \put(3.0,0.5){\makebox(0,0){\lstinline{3}}}
- \put(2.0,1.5){\only<1>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
- \put(2.0,1.5){\only<1>{\makebox(0,0)[b]{\lstinline{push (3)}}}}
-
- \put(2.5,1){\only<2-5>{\line(0,1){1}}}
- \put(3.5,1){\only<2-5>{\line(0,1){1}}}
- \put(2.5,2){\only<2-5>{\line(1,0){1}}}
- \put(3.0,1.5){\only<2-5>{\makebox(0,0){\lstinline{7}}}}
- \put(2.0,2.5){\only<2>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
- \put(2.0,2.5){\only<2>{\makebox(0,0)[b]{\lstinline{push (7)}}}}
-
- \put(2.5,2){\only<3-4>{\line(0,1){1}}}
- \put(3.5,2){\only<3-4>{\line(0,1){1}}}
- \put(2.5,3){\only<3-4>{\line(1,0){1}}}
- \put(3.0,2.5){\only<3-4>{\makebox(0,0){\lstinline{137}}}}
- \put(2.0,3.5){\only<3>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
- \put(2.0,3.5){\only<3>{\makebox(0,0)[b]{\lstinline{push (137)}}}}
-
- \put(3.55,3.05){\only<4>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
- \put(4.00,3.60){\only<4>{\makebox(0,0)[b]{\lstinline{pop ()}: 137}}}
-
- \put(3.55,2.05){\only<5>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
- \put(4.00,2.60){\only<5>{\makebox(0,0)[b]{\lstinline{pop ()}: 7}}}
-
- \put(3.55,1.05){\only<6>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
- \put(4.00,1.60){\only<6>{\makebox(0,0)[b]{\lstinline{pop ()}: 3}}}
- \end{picture}
-
- \bigskip
-
- LIFO = Stack = Stapel
- \end{center}
- \end{minipage}
-
-%
-% \dots
-
-\end{frame}
-
-\begin{frame}
-
- \showsection
- \showsubsection
-
- \bigskip
-
- \begin{minipage}[t]{6cm}
- Array (Stack, FIFO):\\
- in der Mitte einfügen
- \begin{center}
- \begin{picture}(6,3.8)
- \thicklines
- \color{structure}
- \put(1.5,0){\line(1,0){3}}
-
- \put(2.5,0){\line(0,1){3}}
- \put(3.5,0){\line(0,1){3}}
- \put(2.5,1){\line(1,0){1}}
- \put(3.0,0.5){\makebox(0,0){\lstinline{3}}}
- \put(2.5,1){\line(1,0){1}}
- \put(3.0,1.5){\makebox(0,0){\lstinline{7}}}
- \put(2.5,2){\line(1,0){1}}
- \put(3.0,2.5){\makebox(0,0){\lstinline{137}}}
- \put(2.5,3){\line(1,0){1}}
-
- \put(1.5,1.5){\makebox(0,0)[b]{\lstinline{push (5)}}}
- \put(1.5,1.45){\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.95,-0.45);}}}
-
- \put(3.55,2.5){\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)..controls(0.5,0.45)..(0,0.9);}}}
- \put(3.55,1.5){\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)..controls(0.5,0.45)..(0,0.9);}}}
-
- \pause
- \color{red}
- \put(4.1,3.0){\makebox(0,0)[l]{\textbf{1.}}}
- \put(4.1,2.0){\makebox(0,0)[l]{\textbf{2.}}}
- \put(1.5,1.9){\makebox(0,0)[b]{\textbf{3.}}}
-
- \pause
- \put(6.0,1.5){\makebox(0,0)[tl]{$\mathcal{O}(n)$}}
- \put(5.95,1.45){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-1.3,0.4);}}}
- \put(5.95,1.49){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-1.3,1.1);}}}
- \end{picture}
- \end{center}
- \end{minipage}\pause\hfill
- \begin{minipage}[t]{5cm}
- In Array (Stack, FIFO) \dots
- \begin{itemize}
- \item
- einfügen: $\mathcal{O}(n)$
- \item
- suchen: $\mathcal{O}(n)$
- \item
- geschickt suchen: $\mathcal{O}(\log n)$
- \item
- beim Einfügen sortieren:\\
- $\mathcal{O}(n \log n)$ \hspace*{-1.8cm}\tikz{\draw[red](-1.8,0)--(0,0.2);\draw[red](-1.8,0.2)--(0,0);}
- $\mathcal{O}(n^2)$
- \end{itemize}
- \end{minipage}
-
-\end{frame}
-
-\subsection{Verkettete Listen}
-
-\begin{frame}
-
- \showsection
- \showsubsection
-
- \begin{tikzpicture}
- \color{structure}
- \node(first) at (0,0.5) {first};
- \node[shape=rectangle,draw,line width=1pt](3) at (1,2) {3};
- \node[shape=rectangle,draw,line width=1pt](5) at (2,1) {5};
- \node[shape=rectangle,draw,line width=1pt](7) at (3,2) {7};
- \node[shape=rectangle,draw,line width=1pt](137) at (5,2) {137};
- \node(NULL) at (7,2) {NULL};
- \draw[-latex](first)--(3);
- \only<1>{\draw[-latex](3)--(7);}
- \only<2>{\draw[-latex](3) to[out=0] (5);}
- \only<2>{\draw[-latex](5) to[in=180] (7);}
- \draw[-latex](7)--(137);
- \draw[-latex](137)--(NULL);
- \end{tikzpicture}
- \begin{itemize}
- \item
- Jeder Datensatz enthält einen Zeiger auf das nächste Element.
- \item
- Beim letzten Element zeigt der Zeiger auf \lstinline{NULL}.
- \item
- Eine Variable zeigt auf das erste Element.
- \item
- Wenn die Liste leer ist, zeigt die Variable auf \lstinline{NULL}.
- \arrowitem
- (einfach) \textbf{verkettete Liste}
- \end{itemize}
-
-\end{frame}
-
-\begin{frame}
-
- \showsection
- \showsubsection
-
- \begin{minipage}[t]{5cm}
- In Array (Stack, FIFO) \dots
- \begin{itemize}
- \item
- in der Mitte einfügen: $\mathcal{O}(n)$
- \item
- wahlfreier Zugriff: $\mathcal{O}(1)$
- \item
- suchen: $\mathcal{O}(n)$
- \item
- geschickt suchen: $\mathcal{O}(\log n)$
- \item
- beim Einfügen sortieren:\\
- $\mathcal{O}(n \log n)$ \hspace*{-1.8cm}\tikz{\draw[red](-1.8,0)--(0,0.2);\draw[red](-1.8,0.2)--(0,0);}
- $\mathcal{O}(n^2)$
- \end{itemize}
- \end{minipage}\hfill
- \begin{minipage}[t]{6cm}
- In (einfach) verkettete/r Liste \dots
- \begin{itemize}
- \item
- in der Mitte einfügen: $\mathcal{O}(1)$
- \item
- wahlfreier Zugriff: $\mathcal{O}(n)$
- \item
- suchen: $\mathcal{O}(n)$
- \item
- geschickt \hspace*{-1.7cm}\tikz{\draw[red](-1.7,0)--(0,0.2);\draw[red](-1.7,0.2)--(0,0);}
- suchen: {\color{red}$\mathcal{O}(n)$}
- \item
- beim Einfügen sortieren:
- $\mathcal{O}(n \log n)$ \hspace*{-1.8cm}\tikz{\draw[red](-1.8,0)--(0,0.2);\draw[red](-1.8,0.2)--(0,0);}
- $\mathcal{O}(n^2)$
- \end{itemize}
- \end{minipage}
- \pause
- \medskip
- \begin{center}
- \begin{minipage}[t]{6cm}
- In (ausbalancierten) Bäumen \dots
- \begin{itemize}
- \item
- in der Mitte einfügen: $\mathcal{O}(\log n)$
- \item
- wahlfreier Zugriff: $\mathcal{O}(\log n)$
- \item
- suchen: $\mathcal{O}(\log n)$
- \item
- beim Einfügen sortieren:
- $\mathcal{O}(n \log n)$
- \end{itemize}
- \end{minipage}
- \end{center}
- \vspace*{-1cm}
-
-\end{frame}
-
-\subsection{Bäume}
-
-\begin{frame}[fragile]
-
- \showsection
- \showsubsection
-
- \begin{minipage}[t]{5cm}
- \vspace*{-6cm}
- \begin{lstlisting}[gobble=6]
- ¡typedef struct node
- {
- int content;
- struct node *left, *right;
- } node;¿
- \end{lstlisting}
-% \bigskip
- \bigskip
- \begin{onlyenv}<6->
- \begin{itemize}
- \item
- Einfügen: rekursiv, $\mathcal{O}(\log n)$
- \item
- Suchen: rekursiv, $\mathcal{O}(\log n)$
- \item
- beim Einfügen sortieren:\\
- rekursiv, $\mathcal{O}(n\log n)$
- \begin{onlyenv}<7->
- \smallskip
- \item
- {\color{red}
- \emph{Worst Case\/}: $\mathcal{O}(n^2)$\\
- vorher bereits sortiert}\\
- \textarrow\ balancierte Bäume\\
- \hspace*{2.15em}Anwendung: Datenbanken\hspace*{-2cm}
- \end{onlyenv}
- \end{itemize}
- \vspace*{-1cm}
- \end{onlyenv}
- \end{minipage}\hfill
- \begin{minipage}[t]{7cm}
- \begin{center}
- \begin{tikzpicture}
- \color{structure}
- \node(root) at (0,0) {\lstinline{node *root;}};
- \begin{onlyenv}<2>
- \node(3) at (-2,-3) {\lstinline{NULL}};
- \node(137) at (2,-3) {\lstinline{NULL}};
- \end{onlyenv}
- \begin{onlyenv}<2->
- \node[shape=rectangle,draw,line width=1pt](7) at (0,-1.5) {7};
- \draw[-latex](root)--(7);
- \draw[-latex](7)--(3);
- \draw[-latex](7)--(137);
- \end{onlyenv}
- \begin{onlyenv}<3>
- \node(3) at (-2,-3) {\lstinline{NULL}};
- \end{onlyenv}
- \begin{onlyenv}<3->
- \node[shape=rectangle,draw,line width=1pt](137) at (2,-3) {137};
- \node(137_left) at (1,-4.5) {\lstinline{NULL}};
- \node(137_right) at (3,-4.5) {\lstinline{NULL}};
- \draw[-latex](137)--(137_left);
- \draw[-latex](137)--(137_right);
- \end{onlyenv}
- \begin{onlyenv}<4>
- \node(5) at (-1,-4.5) {\lstinline{NULL}};
- \end{onlyenv}
- \begin{onlyenv}<4->
- \node[shape=rectangle,draw,line width=1pt](3) at (-2,-3) {3};
- \node(3_left) at (-3,-4.5) {\lstinline{NULL}};
- \draw[-latex](3)--(3_left);
- \draw[-latex](3)--(5);
- \end{onlyenv}
- \begin{onlyenv}<5->
- \node[shape=rectangle,draw,line width=1pt](5) at (-1,-4.5) {5};
- \node(5_left) at (-2,-6) {\lstinline{NULL}};
- \node(5_right) at (0,-6) {\lstinline{NULL}};
- \draw[-latex](5)--(5_left);
- \draw[-latex](5)--(5_right);
- \end{onlyenv}
- \end{tikzpicture}
- \end{center}
- \end{minipage}
-
-\end{frame}
-
-\nosectionnonumber{\inserttitle}
-
-\begin{frame}
-
- \shownosectionnonumber
-
- \begin{itemize}
- \item[\textbf{1}] \textbf{Einführung}
- \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
- \item[\textbf{2}] \textbf{Einführung in C}
- \item[\textbf{3}] \textbf{Bibliotheken}
- \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
- \item[\textbf{5}] \textbf{Algorithmen}
- \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
- \item[\textbf{7}] \textbf{Datenstrukturen}
- \begin{itemize}
- \color{medgreen}
- \item[7.1] Stack und FIFO
- \item[7.2] Verkettete Listen
- \item[7.3] Bäume
- \end{itemize}
- \end{itemize}
-
-\end{frame}
-
-\end{document}
diff --git a/20221219/lists-1.c b/20221219/lists-1.c
deleted file mode 100644
index a04067e1403601ef56dd706d6148c1d386884e82..0000000000000000000000000000000000000000
--- a/20221219/lists-1.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- int content;
- node *next;
-} node;
-
-int main (void)
-{
- return 0;
-}
diff --git a/20221219/lists-2.c b/20221219/lists-2.c
deleted file mode 100644
index f27d1d5af7c0c237f0d0286155380ef9452a497a..0000000000000000000000000000000000000000
--- a/20221219/lists-2.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-
-typedef struct node
-{
- int content;
- struct node *next;
-} node;
-
-int main (void)
-{
- return 0;
-}
diff --git a/20221219/lists-3.c b/20221219/lists-3.c
deleted file mode 100644
index 9c9029724efff25263813c5491add92504779d17..0000000000000000000000000000000000000000
--- a/20221219/lists-3.c
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <stdio.h>
-
-typedef struct node
-{
- int content;
- struct node *next;
-} node;
-
-int main (void)
-{
- node node3 = { 3, NULL };
- node node7 = { 7, NULL };
- node node137 = { 137, NULL };
-
- node *first = &node3;
-
- for (node *p = first; p; p = p->next)
- printf ("%d\n", p->content);
-
- return 0;
-}
diff --git a/20221219/lists-4.c b/20221219/lists-4.c
deleted file mode 100644
index e048736b85cc228c35f31644d003e00cdefc5496..0000000000000000000000000000000000000000
--- a/20221219/lists-4.c
+++ /dev/null
@@ -1,25 +0,0 @@
-#include <stdio.h>
-
-typedef struct node
-{
- int content;
- struct node *next;
-} node;
-
-int main (void)
-{
- node node3 = { 3, NULL };
- node node7 = { 7, NULL };
- node node137 = { 137, NULL };
-
- node3.next = &node7;
- node7.next = &node137;
- node137.next = NULL;
-
- node *first = &node3;
-
- for (node *p = first; p; p = p->next)
- printf ("%d\n", p->content);
-
- return 0;
-}
diff --git a/20221219/lists-5.c b/20221219/lists-5.c
deleted file mode 100644
index a0cc620a884c133dd89582de726139091bc9c5d0..0000000000000000000000000000000000000000
--- a/20221219/lists-5.c
+++ /dev/null
@@ -1,29 +0,0 @@
-#include <stdio.h>
-
-typedef struct node
-{
- int content;
- struct node *next;
-} node;
-
-int main (void)
-{
- node node3 = { 3, NULL };
- node node7 = { 7, NULL };
- node node137 = { 137, NULL };
-
- node3.next = &node7;
- node7.next = &node137;
- node137.next = NULL;
-
- node node5 = { 5, NULL };
- node5.next = node3.next;
- node3.next = &node5;
-
- node *first = &node3;
-
- for (node *p = first; p; p = p->next)
- printf ("%d\n", p->content);
-
- return 0;
-}
diff --git a/20221219/logo-hochschule-bochum-cvh-text-v2.pdf b/20221219/logo-hochschule-bochum-cvh-text-v2.pdf
deleted file mode 120000
index 4aa99b8f81061aca6dcaf43eed2d9efef40555f8..0000000000000000000000000000000000000000
--- a/20221219/logo-hochschule-bochum-cvh-text-v2.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
diff --git a/20221219/logo-hochschule-bochum.pdf b/20221219/logo-hochschule-bochum.pdf
deleted file mode 120000
index b6b9491e370e499c9276918182cdb82cb311bcd1..0000000000000000000000000000000000000000
--- a/20221219/logo-hochschule-bochum.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20221219/pgslides.sty b/20221219/pgslides.sty
deleted file mode 120000
index 5be1416f4216f076aa268901f52a15d775e43f64..0000000000000000000000000000000000000000
--- a/20221219/pgslides.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgslides.sty
\ No newline at end of file
diff --git a/20221219/tree-01.c b/20221219/tree-01.c
deleted file mode 100644
index d347186a019709e416529c1b73c32f268e0fce57..0000000000000000000000000000000000000000
--- a/20221219/tree-01.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- int content;
- node *left, *right;
-} node;
-
-int main (void)
-{
- node *root = NULL;
- return 0;
-}
diff --git a/20221219/tree-02.c b/20221219/tree-02.c
deleted file mode 100644
index 7e591c3282329f0211c479dfa1b8c82f3dc755a3..0000000000000000000000000000000000000000
--- a/20221219/tree-02.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-int main (void)
-{
- node *root = NULL;
- return 0;
-}
diff --git a/20221219/tree-03.c b/20221219/tree-03.c
deleted file mode 100644
index b88b8671bbda9efe1031d09e3caa60ebeea8ccea..0000000000000000000000000000000000000000
--- a/20221219/tree-03.c
+++ /dev/null
@@ -1,31 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-void insert (node *root, int content)
-{
- node *p = malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- root = p;
-}
-
-void output (node *root)
-{
- if (root)
- printf ("%d\n", root->content);
-}
-
-int main (void)
-{
- node *root = NULL;
- insert (root, 7);
- output (root);
- return 0;
-}
diff --git a/20221219/tree-04.c b/20221219/tree-04.c
deleted file mode 100644
index db3b53dde184a82e1f85aa46e1f7e76b38e6b775..0000000000000000000000000000000000000000
--- a/20221219/tree-04.c
+++ /dev/null
@@ -1,37 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-node *root = NULL;
-
-void insert (int content)
-{
- node *p = malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- if (root == NULL)
- root = p;
-}
-
-void output (void)
-{
- if (root)
- printf ("%d\n", root->content);
- else
- printf ("root is NULL\n");
-}
-
-int main (void)
-{
- insert (7);
- insert (137);
- insert (3);
- output ();
- return 0;
-}
diff --git a/20221219/tree-05.c b/20221219/tree-05.c
deleted file mode 100644
index 628d8803131ca8ff163a085ee8ff4cb6ede0bc88..0000000000000000000000000000000000000000
--- a/20221219/tree-05.c
+++ /dev/null
@@ -1,44 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-node *root = NULL;
-
-void insert (int content)
-{
- node *p = malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- if (root == NULL)
- root = p;
- else
- {
- if (content > root->content)
- root->right = p;
- else
- root->left = p;
- }
-}
-
-void output (void)
-{
- if (root)
- printf ("%d\n", root->content);
- else
- printf ("root is NULL\n");
-}
-
-int main (void)
-{
- insert (7);
- insert (137);
- insert (3);
- output ();
- return 0;
-}
diff --git a/20221219/tree-06.c b/20221219/tree-06.c
deleted file mode 100644
index f38634d004a020104e65e04cf437c87085dd0d18..0000000000000000000000000000000000000000
--- a/20221219/tree-06.c
+++ /dev/null
@@ -1,50 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-node *root = NULL;
-
-void insert (int content)
-{
- node *p = malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- if (root == NULL)
- root = p;
- else
- {
- if (content > root->content)
- root->right = p;
- else
- root->left = p;
- }
-}
-
-void output (void)
-{
- if (root)
- {
- if (root->left)
- printf ("%d\n", root->left->content);
- printf ("%d\n", root->content);
- if (root->right)
- printf ("%d\n", root->right->content);
- }
- else
- printf ("root is NULL\n");
-}
-
-int main (void)
-{
- insert (7);
- insert (137);
- insert (3);
- output ();
- return 0;
-}
diff --git a/20221219/tree-07.c b/20221219/tree-07.c
deleted file mode 100644
index df1dd66b3e1a5892235bcaa894888f8becb4de85..0000000000000000000000000000000000000000
--- a/20221219/tree-07.c
+++ /dev/null
@@ -1,71 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-node *root = NULL;
-
-void insert (int content)
-{
- node *p = malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- if (root == NULL)
- root = p;
- else
- {
- node *save_root = root;
- if (content > root->content)
- {
- root = root->left;
- insert (content);
- }
- else
- {
- root = root->right;
- insert (content);
- }
- root = save_root;
- }
-}
-
-void output (void)
-{
- if (root)
- {
- if (root->left)
- {
- node *save_root = root;
- root = root->left;
- output ();
- root = save_root;
- }
- printf ("%d\n", root->content);
- if (root->right)
- {
- node *save_root = root;
- root = root->right;
- output ();
- root = save_root;
- }
- }
- else
- printf ("root is NULL\n");
-}
-
-int main (void)
-{
- insert (7);
- insert (137);
- insert (3);
- insert (1117);
- insert (42);
- insert (13);
- output ();
- return 0;
-}
diff --git a/20221219/tree-08.c b/20221219/tree-08.c
deleted file mode 100644
index fd3cafcad82fb4b9bbc6d7c905c1005d7c202f6e..0000000000000000000000000000000000000000
--- a/20221219/tree-08.c
+++ /dev/null
@@ -1,73 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-node *root = NULL;
-
-void insert (int content)
-{
- node *p = malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- if (root == NULL)
- root = p;
- else
- {
- node *save_root = root;
- if (content > root->content)
- {
- root = root->left;
- insert (content);
- save_root->left = root;
- }
- else
- {
- root = root->right;
- insert (content);
- save_root->right = root;
- }
- root = save_root;
- }
-}
-
-void output (void)
-{
- if (root)
- {
- if (root->left)
- {
- node *save_root = root;
- root = root->left;
- output ();
- root = save_root;
- }
- printf ("%d\n", root->content);
- if (root->right)
- {
- node *save_root = root;
- root = root->right;
- output ();
- root = save_root;
- }
- }
- else
- printf ("root is NULL\n");
-}
-
-int main (void)
-{
- insert (7);
- insert (137);
- insert (3);
- insert (1117);
- insert (42);
- insert (13);
- output ();
- return 0;
-}
diff --git a/20221219/tree-09.c b/20221219/tree-09.c
deleted file mode 100644
index 6b44c1108c747f4e6021ddf92d771d77288af18d..0000000000000000000000000000000000000000
--- a/20221219/tree-09.c
+++ /dev/null
@@ -1,73 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-node *root = NULL;
-
-void insert (int content)
-{
- node *p = malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- if (root == NULL)
- root = p;
- else
- {
- node *save_root = root;
- if (content < root->content)
- {
- root = root->left;
- insert (content);
- save_root->left = root;
- }
- else
- {
- root = root->right;
- insert (content);
- save_root->right = root;
- }
- root = save_root;
- }
-}
-
-void output (void)
-{
- if (root)
- {
- if (root->left)
- {
- node *save_root = root;
- root = root->left;
- output ();
- root = save_root;
- }
- printf ("%d\n", root->content);
- if (root->right)
- {
- node *save_root = root;
- root = root->right;
- output ();
- root = save_root;
- }
- }
- else
- printf ("root is NULL\n");
-}
-
-int main (void)
-{
- insert (7);
- insert (137);
- insert (3);
- insert (1117);
- insert (42);
- insert (13);
- output ();
- return 0;
-}
diff --git a/20221219/tree-10.c b/20221219/tree-10.c
deleted file mode 100644
index 26a5575d8c0dbd139b08ca9365ad0a667223841b..0000000000000000000000000000000000000000
--- a/20221219/tree-10.c
+++ /dev/null
@@ -1,63 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-node *root = NULL;
-
-void insert (int content)
-{
- node *p = malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- if (root == NULL)
- root = p;
- else
- {
- node *save_root = root;
- if (content < root->content)
- {
- root = root->left;
- insert (content);
- save_root->left = root;
- }
- else
- {
- root = root->right;
- insert (content);
- save_root->right = root;
- }
- root = save_root;
- }
-}
-
-void output (node *root)
-{
- if (root)
- {
- if (root->left)
- output (root->left);
- printf ("%d\n", root->content);
- if (root->right)
- output (root->right);
- }
- else
- printf ("root is NULL\n");
-}
-
-int main (void)
-{
- insert (7);
- insert (137);
- insert (3);
- insert (1117);
- insert (42);
- insert (13);
- output (root);
- return 0;
-}
diff --git a/20221219/tree-11.c b/20221219/tree-11.c
deleted file mode 100644
index 508b24316bf6696abc9225fac3fe7ef398a7e094..0000000000000000000000000000000000000000
--- a/20221219/tree-11.c
+++ /dev/null
@@ -1,61 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-node *root = NULL;
-
-void insert (int content)
-{
- node *p = malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- if (root == NULL)
- root = p;
- else
- {
- node *save_root = root;
- if (content < root->content)
- {
- root = root->left;
- insert (content);
- save_root->left = root;
- }
- else
- {
- root = root->right;
- insert (content);
- save_root->right = root;
- }
- root = save_root;
- }
-}
-
-void output (node *root)
-{
- if (root)
- {
- output (root->left);
- printf ("%d\n", root->content);
- output (root->right);
- }
- else
- printf ("root is NULL\n");
-}
-
-int main (void)
-{
- insert (7);
- insert (137);
- insert (3);
- insert (1117);
- insert (42);
- insert (13);
- output (root);
- return 0;
-}
diff --git a/20221219/tree-12.c b/20221219/tree-12.c
deleted file mode 100644
index ff07e64e6dceb10266dc6d376d68fd15bc59e68b..0000000000000000000000000000000000000000
--- a/20221219/tree-12.c
+++ /dev/null
@@ -1,59 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-node *root = NULL;
-
-void insert (int content)
-{
- node *p = malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- if (root == NULL)
- root = p;
- else
- {
- node *save_root = root;
- if (content < root->content)
- {
- root = root->left;
- insert (content);
- save_root->left = root;
- }
- else
- {
- root = root->right;
- insert (content);
- save_root->right = root;
- }
- root = save_root;
- }
-}
-
-void output (node *root)
-{
- if (root)
- {
- output (root->left);
- printf ("%d\n", root->content);
- output (root->right);
- }
-}
-
-int main (void)
-{
- insert (7);
- insert (137);
- insert (3);
- insert (1117);
- insert (42);
- insert (13);
- output (root);
- return 0;
-}
diff --git a/20221219/tree-13.c b/20221219/tree-13.c
deleted file mode 100644
index 236930ed75a80984bfe343a582320470180db3ad..0000000000000000000000000000000000000000
--- a/20221219/tree-13.c
+++ /dev/null
@@ -1,55 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-node *root = NULL;
-
-node *insert (node *root, int content)
-{
- node *p = malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- if (root == NULL)
- return p;
- else
- {
- if (content < root->content)
- {
- root->left = insert (root->left, content);
- return root;
- }
- else
- {
- root->right = insert (root->right, content);
- return root;
- }
- }
-}
-
-void output (node *root)
-{
- if (root)
- {
- output (root->left);
- printf ("%d\n", root->content);
- output (root->right);
- }
-}
-
-int main (void)
-{
- root = insert (root, 7);
- root = insert (root, 137);
- root = insert (root, 3);
- root = insert (root, 1117);
- root = insert (root, 42);
- root = insert (root, 13);
- output (root);
- return 0;
-}
diff --git a/20221219/tree-14.c b/20221219/tree-14.c
deleted file mode 100644
index a95a1fc5acec20d7fa0fcf714af2d5d746899c1c..0000000000000000000000000000000000000000
--- a/20221219/tree-14.c
+++ /dev/null
@@ -1,55 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-node *root = NULL;
-
-node *insert (node *root, int content)
-{
- node *p = malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- if (root == NULL)
- return p;
- else
- {
- if (content < root->content)
- {
- root->left = insert (root->left, content);
- return root;
- }
- else
- {
- root->right = insert (root->right, content);
- return root;
- }
- }
-}
-
-void output (node *root)
-{
- if (root)
- {
- output (root->left);
- printf ("%d\n", root->content);
- output (root->right);
- }
-}
-
-int main (void)
-{
- insert (root, 7);
- insert (root, 137);
- insert (root, 3);
- insert (root, 1117);
- insert (root, 42);
- insert (root, 13);
- output (root);
- return 0;
-}
diff --git a/20221219/tree-15.c b/20221219/tree-15.c
deleted file mode 100644
index 929d253f77de0cc15a6707dd499420965eb9daca..0000000000000000000000000000000000000000
--- a/20221219/tree-15.c
+++ /dev/null
@@ -1,48 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-void insert (node **root, int content)
-{
- node *p = malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- if (*root == NULL)
- *root = p;
- else
- {
- if (content < root->content)
- insert (&root->left, content);
- else
- insert (&root->right, content);
- }
-}
-
-void output (node *root)
-{
- if (root)
- {
- output (root->left);
- printf ("%d\n", root->content);
- output (root->right);
- }
-}
-
-int main (void)
-{
- node *root = NULL;
- insert (&root, 7);
- insert (&root, 137);
- insert (&root, 3);
- insert (&root, 1117);
- insert (&root, 42);
- insert (&root, 13);
- output (root);
- return 0;
-}
diff --git a/20221219/tree-16.c b/20221219/tree-16.c
deleted file mode 100644
index be7163d4fdf57b897887bb861418e342e5061961..0000000000000000000000000000000000000000
--- a/20221219/tree-16.c
+++ /dev/null
@@ -1,48 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-void insert (node **root, int content)
-{
- node *p = malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- if (*root == NULL)
- *root = p;
- else
- {
- if (content < (*root)->content)
- insert (&(*root)->left, content);
- else
- insert (&(*root)->right, content);
- }
-}
-
-void output (node *root)
-{
- if (root)
- {
- output (root->left);
- printf ("%d\n", root->content);
- output (root->right);
- }
-}
-
-int main (void)
-{
- node *root = NULL;
- insert (&root, 7);
- insert (&root, 137);
- insert (&root, 3);
- insert (&root, 1117);
- insert (&root, 42);
- insert (&root, 13);
- output (root);
- return 0;
-}
diff --git a/20221219/tree-16a.cpp b/20221219/tree-16a.cpp
deleted file mode 100644
index e11b48316a1ecae2c3263f85ee7e2c3616b3e912..0000000000000000000000000000000000000000
--- a/20221219/tree-16a.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-void insert (node *&root, int content)
-{
- node *p = (node *) malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- if (root == NULL)
- root = p;
- else
- {
- if (content < root->content)
- insert (root->left, content);
- else
- insert (root->right, content);
- }
-}
-
-void output (node *root)
-{
- if (root)
- {
- output (root->left);
- printf ("%d\n", root->content);
- output (root->right);
- }
-}
-
-int main (void)
-{
- node *root = NULL;
- insert (root, 7);
- insert (root, 137);
- insert (root, 3);
- insert (root, 1117);
- insert (root, 42);
- insert (root, 13);
- output (root);
- return 0;
-}
diff --git a/20221219/tree-3a.c b/20221219/tree-3a.c
deleted file mode 100644
index 8031ec72af9bcb97b83c46b296ab5f2464832fcd..0000000000000000000000000000000000000000
--- a/20221219/tree-3a.c
+++ /dev/null
@@ -1,33 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-void insert (node *root, int content)
-{
- node *p = malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- root = p;
-}
-
-void output (node *root)
-{
- if (root)
- printf ("%d\n", root->content);
- else
- printf ("root is NULL\n");
-}
-
-int main (void)
-{
- node *root = NULL;
- insert (root, 7);
- output (root);
- return 0;
-}
diff --git a/20221219/tree-3b.c b/20221219/tree-3b.c
deleted file mode 100644
index 5b47c41b61d5a76380bccefc98f2fd3057ad645b..0000000000000000000000000000000000000000
--- a/20221219/tree-3b.c
+++ /dev/null
@@ -1,34 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-node *root = NULL;
-
-void insert (int content)
-{
- node *p = malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- root = p;
-}
-
-void output (void)
-{
- if (root)
- printf ("%d\n", root->content);
- else
- printf ("root is NULL\n");
-}
-
-int main (void)
-{
- insert (7);
- output ();
- return 0;
-}
diff --git a/20221219/tree-3c.c b/20221219/tree-3c.c
deleted file mode 100644
index 63ffbaa792e5bc4d122f96e5cfd32e7579c2077c..0000000000000000000000000000000000000000
--- a/20221219/tree-3c.c
+++ /dev/null
@@ -1,33 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *left, *right;
-} node;
-
-node *insert (node *root, int content)
-{
- node *p = malloc (sizeof (node));
- p->content = content;
- p->left = NULL;
- p->right = NULL;
- return p;
-}
-
-void output (node *root)
-{
- if (root)
- printf ("%d\n", root->content);
- else
- printf ("root is NULL\n");
-}
-
-int main (void)
-{
- node *root = NULL;
- root = insert (root, 7);
- output (root);
- return 0;
-}
diff --git a/20230109/aufgabe-1.c b/20230109/aufgabe-1.c
deleted file mode 100644
index f26ce5d665012e2cdbaac8b0f43f01d40f338254..0000000000000000000000000000000000000000
--- a/20230109/aufgabe-1.c
+++ /dev/null
@@ -1,47 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *next;
-} node;
-
-void output_list (node *first)
-{
- for (node *p = first; p; p = p->next)
- printf ("%d ", p->content);
- printf ("\n");
-}
-
-void insert_into_list (node *what, node *where)
-{
- what->next = where->next;
- where->next = what;
-}
-
-int main (void)
-{
- node *element3 = malloc (sizeof (node));
- node *element7 = malloc (sizeof (node));
- node *element137 = malloc (sizeof (node));
-
- element3->content = 3;
- element7->content = 7;
- element137->content = 137;
-
- node *first = element3;
- element3->next = element7;
- element7->next = element137;
- element137->next = NULL;
-
- output_list (first);
-
- node *element5 = malloc (sizeof (node));
- element5->content = 5;
- insert_into_list (element5, element3);
-
- output_list (first);
-
- return 0;
-}
diff --git a/20230109/aufgabe-1b-gpt.c b/20230109/aufgabe-1b-gpt.c
deleted file mode 100644
index 3b75051963b0f8f325725a2b71305c88f9a6b8e6..0000000000000000000000000000000000000000
--- a/20230109/aufgabe-1b-gpt.c
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-void insert_into_string (char src, char *target, int pos) {
- // Bestimme die Länge des Strings target
- int len = strlen(target);
-
- // Verschiebe alle Zeichen des Strings ab der Stelle pos um eine Stelle nach rechts
- for (int i = len; i > pos; i--) {
- target[i] = target[i-1];
- }
-
- // Füge das Zeichen src an der Stelle pos ein
- target[pos] = src;
-}
-
-int main (void)
-{
- char test[] = "Hochshule Bochum";
- insert_into_string ('c', test, 5);
- printf ("%s\n", test);
- return 0;
-}
diff --git a/20230109/aufgabe-1e-gpt.c b/20230109/aufgabe-1e-gpt.c
deleted file mode 100644
index 7e010cb2b66d3dd447b0aa9e64c9d591fc9cb0d3..0000000000000000000000000000000000000000
--- a/20230109/aufgabe-1e-gpt.c
+++ /dev/null
@@ -1,42 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-void insert_into_string (char src, char *target, int pos) {
- // Bestimme die Länge des Strings target
- int len = strlen(target);
-
- // Verschiebe alle Zeichen des Strings ab der Stelle pos um eine Stelle nach rechts
- for (int i = len; i > pos; i--) {
- target[i] = target[i-1];
- }
-
- // Füge das Zeichen src an der Stelle pos ein
- target[pos] = src;
-}
-
-void insert_into_string_sorted (char src, char *target) {
- // Bestimme die Länge des Strings target
- int len = strlen(target);
-
- // Iteriere über alle Zeichen des Strings target
- for (int i = 0; i < len; i++) { // Wenn das aktuelle Zeichen alphabetisch hinter src liegt, füge src an dieser Stelle ein
- if (target[i] > src) {
- insert_into_string(src, target, i);
- return;
- }
- }
-
- // Wenn src das letzte Zeichen im String ist, füge es am Ende des Strings ein
- insert_into_string(src, target, len);
-}
-
-int main (void)
-{
- char test[100] = "";
- insert_into_string_sorted ('c', test);
- insert_into_string_sorted ('a', test);
- insert_into_string_sorted ('d', test);
- insert_into_string_sorted ('b', test);
- printf ("%s\n", test);
- return 0;
-}
diff --git a/20230109/aufgabe-1g-gpt.c b/20230109/aufgabe-1g-gpt.c
deleted file mode 100644
index 047fa6f565913323f715d8b9a7ce413e70a2b07a..0000000000000000000000000000000000000000
--- a/20230109/aufgabe-1g-gpt.c
+++ /dev/null
@@ -1,52 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-void insert_into_string (char src, char *target, int pos) {
- // Bestimme die Länge des Strings target
- int len = strlen(target);
-
- // Verschiebe alle Zeichen des Strings ab der Stelle pos um eine Stelle nach rechts
- for (int i = len; i > pos; i--) {
- target[i] = target[i-1];
- }
-
- // Füge das Zeichen src an der Stelle pos ein
- target[pos] = src;
-}
-
-void insert_into_string_sorted (char src, char *target) {
- // Bestimme die Länge des Strings target
- int len = strlen(target);
-
- // Setze die Grenzen für die binäre Suche auf das erste und letzte Zeichen des Strings
- int left = 0;
- int right = len - 1;
-
- // Führe die binäre Suche durch, bis left und right auf dasselbe Zeichen zeigen
- while (left < right) { // Bestimme die Mitte des aktuellen Suchbereichs
- int mid = (left + right) / 2;
-
- // Wenn src alphabetisch vor dem aktuellen Zeichen liegt, suche im linken Teilbereich weiter
- if (src < target[mid]) {
- right = mid;
- }
- // Wenn src alphabetisch hinter dem aktuellen Zeichen liegt, suche im rechten Teilbereich weiter
- else {
- left = mid + 1;
- }
- }
-
- // Füge src an der Stelle left in den String ein
- insert_into_string(src, target, left);
-}
-
-int main (void)
-{
- char test[100] = "";
- insert_into_string_sorted ('c', test);
- insert_into_string_sorted ('a', test);
- insert_into_string_sorted ('d', test);
- insert_into_string_sorted ('b', test);
- printf ("%s\n", test);
- return 0;
-}
diff --git a/20230109/aufgabe-3.c b/20230109/aufgabe-3.c
deleted file mode 100644
index 5b0cb23fdd5ee15a4403808c18d2104ed49caf3f..0000000000000000000000000000000000000000
--- a/20230109/aufgabe-3.c
+++ /dev/null
@@ -1,62 +0,0 @@
-#include <gtk/gtk.h>
-
-#define WIDTH 320
-#define HEIGHT 240
-
-double t = 0.0;
-double dt = 0.2;
-
-int r = 5;
-
-double x = 10;
-double y = 200;
-double vx = 20;
-double vy = -60;
-double g = 9.81;
-
-gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
-{
- GdkRGBA blue = { 0.0, 0.5, 1.0, 1.0 };
-
- gdk_cairo_set_source_rgba (c, &blue);
- cairo_arc (c, x, y, r, 0, 2 * G_PI);
- cairo_fill (c);
-
- return FALSE;
-}
-
-gboolean timer (GtkWidget *widget)
-{
- t += dt;
- x += vx * dt;
- y += vy * dt;
- vx = vx;
- vy = 0.5 * g * (t * t);
- if (y + r >= HEIGHT)
- vy = -vy * 0.9;
- if (x + r >= WIDTH)
- vx = -vx * 0.9;
- if (x - r <= 0)
- vx = -vx * 0.9;
- gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
-}
-
-int main (int argc, char **argv)
-{
- gtk_init (&argc, &argv);
-
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_widget_show (window);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_widget_show (drawing_area);
- gtk_container_add (GTK_CONTAINER (window), drawing_area);
- gtk_widget_set_size_request (drawing_area, WIDTH, HEIGHT);
-
- gtk_main ();
- return 0;
-}
diff --git a/20230109/aufgabe-4.c b/20230109/aufgabe-4.c
deleted file mode 100644
index 2bcd5e63a71f212b7243d1f7d9c92406d1e41e77..0000000000000000000000000000000000000000
--- a/20230109/aufgabe-4.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- char buffer[100];
- fgets (buffer, 100, stdin);
- for (char *p = buffer; *p; p++)
- printf ("%02x", *p);
- printf ("\n");
-}
diff --git a/20230109/hp-20230109.txt b/20230109/hp-20230109.txt
deleted file mode 100644
index 7f2127e54ae3a8e7a9046a1bb1c082c0dec0ad97..0000000000000000000000000000000000000000
--- a/20230109/hp-20230109.txt
+++ /dev/null
@@ -1,430 +0,0 @@
-Klausur vom 13.2.2018, gelöst von ChatGPT
-
-Aufgabe 1
-
-(a) Das Programm fügt das Zeichen 'c' an der Stelle 5 in die Zeichenkette 'test'
- ein. Allerdings wird das Programm nicht korrekt implementiert, da der Inhalt
- der Zeichenkette nach der Stelle 5 nicht korrekt verschoben wird. Die Schleife
- 'for (int i = pos; i < len; i++)' sollte stattdessen 'for (int i = len; i >
- pos; i--)' lauten, um die Zeichen ab der Stelle 'pos' nach rechts zu
- verschieben.
-
- Da das Programm so implementiert ist, werden alle Zeichen ab der Stelle 5 mit
- dem Wert 'h' überschrieben. Da der Inhalt der Zeichenkette nach der Stelle 5
- nicht verschoben wird, wird das Zeichen 'c' an der Stelle 5 eingefügt, während
- der Rest der Zeichenkette unverändert bleibt. Deshalb lautet die Ausgabe
- "Hochschhhhhhhhhhh".
-
---> Viel Geschwafel, aber korrekt. Volle Punktzahl.
-
-(b) void insert_into_string (char src, char *target, int pos) {
- // Bestimme die Länge des Strings target
- int len = strlen(target);
-
- // Verschiebe alle Zeichen des Strings ab der Stelle pos um eine Stelle nach rechts
- for (int i = len; i > pos; i--) {
- target[i] = target[i-1];
- }
-
- // Füge das Zeichen src an der Stelle pos ein
- target[pos] = src;
- }
-
---> Funktioniert, aber Null-Symbol am Ende nicht berücksichtigt. 1 Punkt Abzug.
-
-(c) Wenn man char test[] = "Hochshule Bochum"; anstelle von char test[100] =
- "Hochshule Bochum"; schreibt, wird der Compiler den Array test automatisch
- auf die notwendige Größe anpassen, um den String "Hochshule Bochum"
- aufnehmen zu können. Wenn man die Funktion insert_into_string aufruft und
- versucht, ein Zeichen an eine Stelle jenseits des Endes des Strings
- einzufügen, könnte dies zu einem Speicherzugriffsfehler führen, da der
- Array test nicht ausreichend groß ist, um das Zeichen aufzunehmen
-
---> Richtig. Volle Punktzahl.
-
-(d) Wenn man char *test = "Hochshule Bochum"; anstelle von char test[100] =
- "Hochshule Bochum"; schreibt, deklariert man test als Zeiger auf einen
- char, der auf den ersten Buchstaben des Strings "Hochshule Bochum" zeigt.
- In diesem Fall kann man nicht mehr auf die einzelnen Zeichen des Strings
- test zugreifen, da der String "Hochshule Bochum" im ROM-Speicher
- gespeichert ist und nicht verändert werden darf. Wenn man versucht, in der
- Funktion insert_into_string das Zeichen an einer bestimmten Stelle im
- String test zu ändern, wird dies zu einem Fehler führen
-
---> Richtig, auch wenn die Formulierung eher in Richtung "ändern" als "einfügen" geht.
- Volle Punktzahl.
-
-(e) void insert_into_string_sorted (char src, char *target) {
- // Bestimme die Länge des Strings target
- int len = strlen(target);
-
- // Iteriere über alle Zeichen des Strings target
- for (int i = 0; i < len; i++) { // Wenn das aktuelle Zeichen alphabetisch hinter src liegt, füge src an dieser Stelle ein
- if (target[i] > src) {
- insert_into_string(src, target, i);
- return;
- }
- }
-
- // Wenn src das letzte Zeichen im String ist, füge es am Ende des Strings ein
- insert_into_string(src, target, len);
- }
-
---> Scheint zu funktionieren. Könnte volle Punktzahl geben.
-
-(f) Die Funktion void insert_into_string_sorted (char src, char *target)
- arbeitet in O(n)-Zeit, da sie die Länge des Strings target durchläuft
- und in jedem Durchlauf das Zeichen src in den String einfügt.
-
---> Korrekt.
-
-(g) void insert_into_string_sorted (char src, char *target) {
- // Bestimme die Länge des Strings target
- int len = strlen(target);
-
- // Setze die Grenzen für die binäre Suche auf das erste und letzte Zeichen des Strings
- int left = 0;
- int right = len - 1;
-
- // Führe die binäre Suche durch, bis left und right auf dasselbe Zeichen zeigen
- while (left < right) { // Bestimme die Mitte des aktuellen Suchbereichs
- int mid = (left + right) / 2;
-
- // Wenn src alphabetisch vor dem aktuellen Zeichen liegt, suche im linken Teilbereich weiter
- if (src < target[mid]) {
- right = mid;
- }
- // Wenn src alphabetisch hinter dem aktuellen Zeichen liegt, suche im rechten Teilbereich weiter
- else {
- left = mid + 1;
- }
- }
-
- // Füge src an der Stelle left in den String ein
- insert_into_string(src, target, left);
- }
-
---> Nicht ganz ausgereift, aber i.w. korrekt. Spontan 2 von 3 Punkten.
-
-Aufgabe 2
-
-(a) Die beim Compilieren auftretende Warnung wird angezeigt, weil in der
- printf-Anweisung in Zeile 14 der Typ des zweiten Arguments ("&xyz") als
- "three_numbers * {aka struct *}" angegeben ist, aber der Format-String "%s"
- erwartet, dass das zweite Argument ein Zeiger auf einen char-Wert (also
- einen String) ist. Die Formatierungsanweisung "%s" gibt an, dass das
- Argument, auf das der Zeiger verweist, als String interpretiert werden
- soll. Da das zweite Argument aber ein Zeiger auf ein three_numbers-Struct
- ist, kann es nicht als String interpretiert werden und es wird daher eine
- Warnung angezeigt.
-
---> Sehr lang formuliert, trotzdem volle Punktzahl.
-
-(a) Die beim Compilieren auftretende Warnung wird angezeigt, weil in der
- printf-Anweisung der Typ des zweiten Arguments ("&xyz", ein Zeiger auf
- ein three_numbers-Struct) und der Format-String "%s" (erwartet einen
- String) inkonsistent sind. Das bedeutet, dass das Programm versucht,
- ein three_numbers-Struct als String auszugeben, was nicht möglich ist
- und daher eine Warnung ausgelöst wird.
-
---> Besser formuliert. Volle Punktzahl. (Ein Komma fehlt.;-)
-
-(b) Das Programm enthält einen Fehler in der Verwendung von printf auf Zeile
- 14. Der "%s" Formatstring erwartet einen "char *" als Argument, aber &xyz
- wurde übergeben, was ein "three_numbers *" (also ein Zeiger auf eine
- Struktur) ist. Dies führt zu unerwartetem Verhalten und einer Warnung bei
- der Compilierung.
-
---> Bis hierin: Geschwafel.
-
- In diesem Fall gibt printf jedoch "Hallo, Welt!" aus, da es den Inhalt
- der Speicheradresse als Zeichenkette interpretiert.
-
---> Das ist sogar richtig.
-
- Es ist jedoch unwahrscheinlich, dass dieser Speicherbereich tatsächlich
- eine gültige Zeichenkette enthält, daher sollte dieser Code vermieden
- werden.
-
---> Daraus kann ich entnehmen, daß ChatGPT die Aufgabe nicht wirklich verstanden hat.
- Es felht eine Analyse, weshalb die Ausgabe genau "Hallo, Welt!" sein muß.
-
---> Großzügig: 2 von 4 Punkten.
-
---> Richtige Lösung: Zahlen nach Hexadezimal umwandeln.
- In der ersten Zahl steht dann ganz rechts "48" für "H",
- links davon "61" für "a", danach zweimal "6c" für "l".
- --> Der Rechner ist Little-Endian (schon mal für (c)).
-
- Was liegt im Speicher?
-
- l l a H ! t l e W _ , o \0
- 6c6c6148 21746c6557202C6f 00
- `------' `--------------' `'
- a b c <-- direkt hintereinander, weil gemeinsam im Struct
- (Dies dazuzuschreiben, könnte einen Extra-Punkt bringen.)
- (Achtung: auch hier kann Alignment eine Rolle spielen!)
-
- Reihenfolge im Speicher: für jede Zahl andersherum, da Little Endian
-
- H a l l o , _ W e l t ! \0
- 48 61 6c 6c 6f 2C 20 57 65 6c 74 21 00 <-- String im Speicher
- `---------' `----------------------' `'
- a b c
-
- Wenn man die Inhalte der Speicherzellen visualisiert, aus denen das Struct
- xyz besteht, erkennt man, daß bei Little Endian die Speicherzellen gemäß
- ASCII-Zeichensatz den String "Hallo, Welt!" einschließlich Null-Symbol am
- Ende ergeben.
-
-(c) Es ist nicht möglich, die Endianness des verwendeten Rechners anhand des
- obigen Programms zu bestimmen. Die Endianness beschreibt die Reihenfolge,
- in der Bytes in einem Wort gespeichert werden, und hat keine Auswirkungen
- auf die Ausgabe von printf.
-
---> Leider falsch.
-
- Die Ausgabe des Programms hängt davon ab, welche Daten sich in dem
- Speicherbereich befinden, der an printf übergeben wird. In diesem Fall
- wurde &xyz, also die Adresse der Struktur "three_numbers", übergeben. Wenn
- der Speicherbereich an dieser Adresse tatsächlich eine gültige Zeichenkette
- enthält, würde die Ausgabe auf jedem Rechner gleich sein, unabhängig von
- der Endianness. Wenn der Speicherbereich jedoch zufällige Daten enthält,
- würde die Ausgabe auf jedem Rechner unterschiedlich sein.
-
---> Das klingt erstaunlich überzeugend, ist aber eigentlich ziemlich falsch.
-
- Es ist wichtig zu beachten, dass der Code in der obigen Frage fehlerhaft
- ist und nicht wie erwartet funktionieren wird. Es wird empfohlen, diesen
- Code zu überarbeiten, um korrektes Verhalten zu gewährleisten.
-
---> Daß man so nicht programmieren sollte, ist klar. Leider hat dies nichts
- mit der Aufgabenstellung zu tun.
-
---> 0 Punkte.
-
---> Richtige Lösung: Little Endian (Begründung: siehe oben)
-
- Rechner nit entgegengesetzter Endianness:
- Wir behalten die Reihenfolge von a, b und c bei und drehen nur innerhalb
- jeder Variable die Reihenfolge der Speicherzellen um:
-
- l l a H ! t l e W _ , o \0
- 6c 6c 61 48 21 74 6c 65 57 20 2C 6f 00 <-- String im Speicher
- `---------' `----------------------' `'
- a b c
-
- Aufgabe auf einem Big-Endian-Rechner: "llaH!tleW ,o"
-
-(d) Die Ausgabe des Programms hängt davon ab, welche Daten sich in dem
- Speicherbereich befinden, der an printf übergeben wird. In diesem Fall
- wurde &xyz, also die Adresse der Struktur "three_numbers", übergeben. Wenn
- der Speicherbereich an dieser Adresse tatsächlich eine gültige Zeichenkette
- enthält, würde die Ausgabe auf jedem Rechner gleich sein, unabhängig von
- der Architektur des Rechners. Wenn der Speicherbereich jedoch zufällige
- Daten enthält, würde die Ausgabe auf jedem Rechner unterschiedlich sein.
-
---> Geschwafel. Wiederholung von (a).
-
- Es ist wichtig zu beachten, dass der Code in der obigen Frage fehlerhaft
- ist und nicht wie erwartet funktionieren wird. Es wird empfohlen, diesen
- Code zu überarbeiten, um korrektes Verhalten zu gewährleisten. Die
- Tatsache, dass die Ausgabe des Programms auf einem 64-Bit-Rechner anders
- aussieht als auf einem 32-Bit-Rechner, ist wahrscheinlich auf die
- unterschiedliche Speicherstruktur zurückzuführen und hat nichts mit der
- Endianness zu tun.
-
---> Geschwafel, aber enthält auch etwas Korrektes: Es hat tatsächlich nicht
- mit der Endianness zu tun, sondern mit dem Alignment.
-
- Möchten Sie noch etwas wissen oder haben Sie weitere Fragen zum obigen
- Programm?
-
---> *in die Tischkante beiß*
-
---> 0 Punkte.
-
---> Richtige Lösung: 64-Bit-Rechner
-
- Ausgabe: Hall5V
-
- typedef struct
- {
- uint32_t a;
- uint64_t b;
- uint8_t c;
- } three_numbers;
-
- l l a H 5 V \0 \? ! t l e W _ , o \0
- 6c 6c 61 48 35 56 00 ?? 21 74 6c 65 57 20 2C 6f 00 <-- String im Speicher
- `---------' `---------' `----------------------' `'
- a dummy b c
- wegen 64-Bit-Alignment
-
-
-==> Korrektur, 16.3.2023: ?? 00 56 35 statt 35 56 00 ??
-
-
- Um das 64-Bit-Alignment der Variablen b einzuhalten, hat der Compiler zwischen
- a und b 32 Bits, also 4 Speicherzellen, freigelassen und mit zufälligen Werten
- gefüllt. Gemäß der Ausgabe sind diese zufälligen Werte die Ziffer 5, Der Buchstabe V,
- ein Null-Symbol und ein für uns unbekannter Wert.
-
- $ gcc -Wall -m64 -O aufgabe-2.c -o aufgabe-2
- aufgabe-2.c: In function ‘main’:
- aufgabe-2.c:14:13: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘three_numbers *’ {aka ‘struct <anonymous> *’} [-Wformat=]
- printf ("%s\n", &xyz);
- ~^ ~~~~
- $ ./aufgabe-2
- Vall
- $ ./aufgabe-2
- Hall V
- $ ./aufgabe-2
- HallfU
- $ ./aufgabe-2
- Hall\U
- $ ./aufgabe-2
- HallV
- $
-
- Das "Vall" ist in Wirklichkeit: "Hall\rV"
- ("\r" bedeutet: zurückgehen an den Zeilenanfang)
-
- $ echo -e "Hall\rV"
- Vall
-
-Aufgabe 3
-
-(a) void (*fun)(int x) bedeutet, dass "fun" ein Zeiger auf eine Funktion ist,
- die einen int-Wert als Argument nimmt und keinen Rückgabewert hat.
-
---> Korrekt. Schon mal 1 Punkt.
-
- Die Verwendung von fun in der Funktion foreach() ermöglicht es, jedes
- Element im Array "a" der Funktion "fun" zu übergeben, sodass diese auf
- jedes Element angewendet werden kann.
-
---> Etwas merkwürdig, aber trotzdem korrekt beantwortet.
- Noch ein Punkt. Volle Punktzahl. 8-)
-
- (Ich vermisse das Stichwort "Callback-Funktion" oder von mir aus auch
- "virtuelle Methode". Aber die Beschreibung dessen, was foreach() mit
- der übergebenen Funktion macht, ist korrekt.)
-
-(b) #include <stdio.h>
-
- int sum; // globale Variable für die Summe
-
- void add_to_sum (int x)
- {
- if (x > 0)
- {
- sum += x;
- }
- }
-
- void foreach (int *a, void (*fun) (int x))
- {
- for (int *p = a; *p >= 0; p++)
- {
- fun (*p);
- }
- }
-
- int main (void)
- {
- int numbers[] = { 12, 17, 32, 1, 3, 16, 19, 18, -1 };
- foreach (numbers, add_to_sum);
- printf ("Summe der positiven Zahlen: %d\n", sum);
- return 0;
- }
-
---> Ich vermisse ein explizites "sum = 0"; ansonsten ist alles korrekt. Volle Punktzahl.
- (Die Initialisierung auf 0 erfolgt bei globalen Variablen automatisch. Das ist für
- ChatGPT anscheinend so selbstverständlich, daß es das nicht erwähnt.)
-
-Aufgabe 4
-
- Es scheint, dass du eine Aufgabe aus einem Computer Science Kurs hast, bei
- der du ein Programm schreiben sollst, das eine XBM-Grafikdatei liest und
- in eine PBM-Grafikdatei umwandelt. XBM-Grafikdateien sind als C-Quelltext
- abgespeicherte Arrays, die Bildinformationen enthalten. PBM-Grafikdateien sind
- binär abgespeicherte C-Arrays von Bytes, die auch Bildinformationen enthalten.
-
- Um diese Aufgabe zu lösen, musst du das XBM-Array lesen und die Bilddaten
- in das PBM-Format umwandeln. Du musst die Breite und Höhe des Bildes aus den
- Konstantendefinitionen in der XBM-Datei extrahieren und diese Informationen in
- der PBM-Datei speichern. Du musst auch sicherstellen, dass du die Bilddaten im
- PBM-Format speicherst, indem du jedes Bit des XBM-Arrays liest und es im MSB
- first Format in das PBM-Array schreibst.
-
- Eine Möglichkeit, dies zu erreichen, wäre die Verwendung von
- Bit-Shift-Operationen, um die Bits des XBM-Arrays zu lesen und sie im
- PBM-Format zu speichern. Du könntest auch Funktionen wie fprintf verwenden, um
- die Breite und Höhe des Bildes und die Bilddaten in die PBM-Datei zu schreiben
-
- Hier ist ein Beispiel für ein Programm, das die Aufgabe löst, eine
- XBM-Grafikdatei in eine PBM-Grafikdatei umzuwandeln. Beachte, dass dieses
- Beispiel nur als Anregung dient und dass es möglicherweise Anpassungen oder
- Erweiterungen benötigt, um es für deine spezifischen Bedürfnisse zu optimieren:
-
- #include <stdio.h>
- #include <stdint.h>
-
- #define XBM_WIDTH 14
- #define XBM_HEIGHT 14
-
- static unsigned char xbm_bits[] = {
- 0x00, 0x00, 0xf0, 0x03, 0x08, 0x04, 0x04, 0x08, 0x02, 0x10, 0x32, 0x13,
- 0x22, 0x12, 0x02, 0x10, 0x0a, 0x14, 0x12, 0x12, 0xe4, 0x09, 0x08, 0x04,
- 0xf0, 0x03, 0x00, 0x00
- };
-
- int main(int argc, char **argv)
- {
- // Öffne die Ausgabedatei
- FILE *output_file = fopen("test.pbm", "w");
- if (output_file == NULL) {
- printf("Fehler beim Öffnen der Ausgabedatei\n");
- return 1;
- }
-
- // Schreibe die PBM-Dateikennung, Breite und Höhe in die Ausgabedatei
- fprintf(output_file, "P4\n%d %d\n", XBM_WIDTH, XBM_HEIGHT);
-
- // Iteriere über jedes Byte im XBM-Array
- for (int i = 0; i < XBM_HEIGHT * XBM_WIDTH / 8; i++) { // Iteriere über jedes Bit im aktuellen Byte
- for (int j = 7; j >= 0; j--) {
- // Lies das aktuelle Bit des XBM-Arrays und schreibe es in die Ausgabedatei
- uint8_t xbm_bit = (xbm_bits[i] >> j) & 1;
- fprintf(output_file, "%c", xbm_bit ? '1' : '0');
- }
- }
-
- // Schließe die Ausgabedatei
- fclose(output_file);
-
- return 0;
- }
-
---> Mehrere Fehler, aber durchaus sinnvolle Ansätze.
- Großzügig: 4 von 8 Punkten (möglicherweise weniger)
-
-Zusammenfassung:
-
-Aufgabe 1 (a) 3 / 3
- (b) 1 / 2
- (c) 2 / 2
- (d) 2 / 2
- (e) 4 / 4
- (f) 1 / 1
- (g) 2 / 3
-Aufgabe 2 (a) 2 / 2
- (b) 2 / 4
- (c) 0 / 2
- (d) 0 / 3
-Aufgabe 3 (a) 2 / 2
- (b) 4 / 4
-Aufgabe 4 4 / 8
- -- ---
- 29 / 42 --> 2.7. Immerhin.
diff --git a/20230109/hp-musterloesung-20230109.pdf b/20230109/hp-musterloesung-20230109.pdf
deleted file mode 100644
index fecb1322d2d38ae43542bdc5fe222115f6503eba..0000000000000000000000000000000000000000
Binary files a/20230109/hp-musterloesung-20230109.pdf and /dev/null differ
diff --git a/20230109/hp-musterloesung-20230109.tex b/20230109/hp-musterloesung-20230109.tex
deleted file mode 100644
index a10d64ce3bff36aae2a0a9c59bc18a3beacd64c3..0000000000000000000000000000000000000000
--- a/20230109/hp-musterloesung-20230109.tex
+++ /dev/null
@@ -1,636 +0,0 @@
-% hp-musterloesung-20230109.pdf - Solutions to the Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Einfach und doppelt verkettete Listen, ternärer Baum, hüpfender Ball, Hexdumps
-
-% ! Hüpfender Ball (20211206-3)
-% ! Hexdumps (20220110-3)
-% ! einfach und doppelt verkettete Listen (20220117-2)
-% ! ternärer Baum (20220117-3)
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-\usepackage{tikz}
-
-\begin{document}
-
- \section*{Hardwarenahe Programmierung\\
- Musterlösung zu den Übungsaufgaben -- 9.\ Januar 2023}
-
- \exercise{Einfach und doppelt verkettete Listen}
-
- Das Beispiel-Programm \gitfile{hp}{2022ws/20230109}{aufgabe-1.c}
- demonstriert zwei Funktionen zur Verwaltung einfach verketteter Listen:
- \lstinline{output_list()} zum Ausgeben der Liste auf den Bildschirm und
- \lstinline{insert_into_list()} zum Einfügen in die Liste.
-
- \begin{enumerate}[\quad(a)]
- \item
- Ergänzen Sie eine Funktion \lstinline{delete_from_list()}
- zum Löschen eines Elements aus der Liste
- mit Freigabe des Speicherplatzes.
- \points{5}
- \item
- Ergänzen Sie eine Funktion \lstinline{reverse_list()}
- die die Reihenfolge der Elemente in der Liste umdreht.\\
- \points{3}
- \end{enumerate}
-
- Eine doppelt verkettete Liste hat in jedem Knotenpunkt (\lstinline{node})
- \emph{zwei\/} Zeiger -- einen auf das nächste Element (\lstinline{next})
- und einen auf das vorherige Element (z.\,B.\ \lstinline{prev} für "`previous"').
- Dadurch ist es leichter als bei einer einfach verketteten Liste,
- die Liste in umgekehrter Reihenfolge durchzugehen.
-
- \begin{quote}
- \begin{tikzpicture}
- \color{blendedblue}
- \node(first) at (0,3.5) {first};
- \node(NULL1) at (-1,1.25) {NULL};
- \node[shape=rectangle,draw,line width=1pt](3) at (1,2) {3};
- \node[shape=rectangle,draw,line width=1pt](7) at (3,2) {7};
- \node[shape=rectangle,draw,line width=1pt](137) at (5,2) {137};
- \node(NULL2) at (7,2.75) {NULL};
- \draw[-latex](first)--(3);
- \draw[-latex](3) to[out=45,in=135] (7);
- \draw[-latex](3) to[out=-135,in=0] (NULL1);
- \draw[-latex](7) to[out=-135,in=-45] (3);
- \draw[-latex](7) to[out=45,in=135] (137);
- \draw[-latex](137) to[out=-135,in=-45] (7);
- \draw[-latex](137) to[out=45,in=180] (NULL2);
- \end{tikzpicture}
- \end{quote}
-
- Der Rückwärts-Zeiger (\lstinline{prev}) des ersten Elements zeigt,
- genau wie der Vorwärts-Zeiger (\lstinline{next}) des letzten Elements,
- auf \emph{nichts}, hat also den Wert \lstinline{NULL}.
-
- \begin{enumerate}[\quad(a)]\setcounter{enumi}{2}
- \item
- Schreiben Sie das Programm um für doppelt verkettete Listen.
- \points{5}
- \end{enumerate}
-
- \solution
-
- \begin{enumerate}[\quad(a)]
- \item
- \textbf{Ergänzen Sie eine Funktion \lstinline{delete_from_list()}
- zum Löschen eines Elements aus der Liste
- mit Freigabe des Speicherplatzes.}
-
- Siehe: \gitfile{hp}{2022ws/20230109}{loesung-1a.c}
-
- Um ein Element aus einer verketteten Liste zu löschen,
- müssen zuerst die Zeiger umgestellt werden,
- um das Element von der Liste auszuschließen.
- Erst danach darf der Speicherplatz für das Element freigegeben werden.
-
-% Da das Beispielprogramm (\gitfile{hp}{2021ws/20220117}{lists-5.c})
-% nicht mit dynamischem Speicher arbeitet,
-% stellen wir dieses zunächst auf dynamischen Speicher um, z.\,B.:
-% \begin{lstlisting}[gobble=8]
-% node *element5 = malloc (sizeof (node));
-% \end{lstlisting}
-% Danach bezeichnet \lstinline{element5}
-% die Adresse der \lstinline{struct}-Variablen;
-% es wird also \lstinline{element5} an die Funktionen übergeben
-% und nicht \lstinline{&element5} (die Adresse des Zeigers).
-
-% Um nun ein Element aus der Liste zu entfernen,
-% benötigt man
- Man benötigt also
- \emph{das vorherige Element},
- dessen \lstinline{next}-Zeiger man dann auf
- das übernächste Element \lstinline{next->next} weitersetzt.
-
- Bei jedem Zeiger muß man vor dem Zugriff prüfen,
- daß dieser nicht auf \lstinline{NULL} zeigt.
- (Die Musterlösung ist in dieser Hinsicht nicht konsequent.
- Für den Produktiveinsatz müßte z.\,B.\ \lstinline{delete_from_list()}
- auch den übergebenen Zeiger \lstinline{what} auf \lstinline{NULL} prüfen.)
-
- Ein Spezialfall tritt ein, wenn das erste Element einer Liste
- entfernt werden soll. In diesem Fall tritt \lstinline{first}
- an die Stelle des \lstinline{next}-Zeigers
- des (nicht vorhandenen) vorherigen Elements.
- Da \lstinline{delete_from_list()} \emph{schreibend\/} auf \lstinline{first}
- zugreift, muß \lstinline{first} \emph{als Zeiger\/} übergeben werden
- (\lstinline{node **first}).
-
- Um alle Spezialfälle zu testen (am Anfang, am Ende und in der Mitte der Liste),
- wurden die Testfälle im Hauptprogramm erweitert.
-
- \item
- \textbf{Schreiben Sie das Programm um für doppelt verkettete Listen.}
-
- Siehe: \gitfile{hp}{2022ws/20230109}{loesung-1b.c}
-
- Bei allen Einfüge- und Löschaktionen müssen \emph{jeweils zwei\/}
- \lstinline{next}- und \lstinline{prev}-Zeiger neu gesetzt werden.
-
- Zum Debuggen empfiehlt es sich sehr,
- eine Funktion zu schreiben, die die Liste auf Konsistenz prüft
- (hier: \lstinline{check_list()}).
-
- Das Testprogramm macht von der Eigenschaft der doppelt verketteten Liste,
- daß man sie auch rückwärts effizient durchgehen kann, keinen Gebrauch.
- Um diese Eigenschaft als Vorteil nutzen zu können, empfiehlt es sich,
- zusätzlich zu \lstinline{first}
- auch einen Zeiger auf das letzte Element (z.\,B.\ \lstinline{last})
- einzuführen. Dieser muß dann natürlich bei allen Operationen
- (Einfügen, Löschen, \dots) auf dem aktuellen Stand gehalten werden.
-
- \end{enumerate}
-
- \exercise{Ternärer Baum}
-
- Der in der Vorlesung vorgestellte \newterm{binäre Baum\/}
- ist nur ein Spezialfall;
- im allgemeinen können Bäume auch mehr als zwei Verzweigungen
- pro Knotenpunkt haben.
- Dies ist nützlich bei der Konstruktion \emph{balancierter Bäume},
- also solcher, die auch im \emph{Worst Case\/}
- nicht zu einer linearen Liste entarten,
- sondern stets eine -- möglichst flache -- Baumstruktur behalten.
-
- Wir betrachten einen Baum mit bis zu drei Verzweigungen pro Knotenpunkt,
- einen sog.\ \newterm{ternären Baum}.
- Jeder Knoten enthält dann nicht nur einen,
- sondern \emph{zwei\/} Werte als Inhalt:
- \begin{lstlisting}
- typedef struct node
- {
- int content_left, content_right;
- struct node *left, *middle, *right;
- } node;
- \end{lstlisting}
-
- Wir konstruieren nun einen Baum nach folgenden Regeln:
- \vspace{-\medskipamount}
- \begin{itemize}\itemsep0pt
- \item
- Innerhalb eines Knotens sind die Werte sortiert:
- \lstinline{content_left} muß stets kleiner sein als \lstinline{content_right}.
- \item
- Der Zeiger \lstinline{left} zeigt auf Knoten,
- deren enthaltene Werte durchweg kleiner sind als \lstinline{content_left}.
- \item
- Der Zeiger \lstinline{right} zeigt auf Knoten,
- deren enthaltene Werte durchweg größer sind als \lstinline{content_right}.
- \item
- Der Zeiger \lstinline{middle} zeigt auf Knoten,
- deren enthaltene Werte durchweg größer sind als \lstinline{content_left},
- aber kleiner als \lstinline{content_right}.
- \item
- Ein Knoten muß nicht immer mit zwei Werten voll besetzt sein;
- er darf auch \emph{nur einen\/} gültigen Wert enthalten.
-
- Der Einfachheit halber lassen wir in diesem Beispiel
- nur positive Zahlen als Werte zu.
- Wenn ein Knoten nur einen Wert enthält,
- setzen wir \lstinline{content_right = -1},
- und der Zeiger \lstinline{middle} wird nicht verwendet.
- \item
- Wenn wir neue Werte in den Baum einfügen,
- werden \emph{zuerst\/} die nicht voll besetzten Knoten aufgefüllt
- und \emph{danach erst\/} neue Knoten angelegt und Zeiger gesetzt.
- \item
- Beim Auffüllen eines Knotens darf nötigenfalls \lstinline{content_left}
- nach \lstinline{content_right} verschoben werden.
- Ansonsten werden einmal angelegte Knoten nicht mehr verändert.
- \end{itemize}
- \vspace*{-\medskipamount}
- (In der Praxis dürfen Knoten gemäß speziellen Regeln
- nachträglich verändert werden,
- um Entartungen gar nicht erst entstehen zu lassen --
- siehe z.\,B.\ \url{https://en.wikipedia.org/wiki/2-3_tree}.)
- \begin{enumerate}[\quad(a)]
- \item
- Zeichnen Sie ein Schaubild, das veranschaulicht,
- wie die Zahlen 7, 137, 3, 5, 6, 42, 1, 2 und 12
- nacheinander und in dieser Reihenfolge
- in den oben beschriebenen Baum eingefügt werden
- -- analog zu den Vortragsfolien (\gitfile{hp}{2022ws/20221219}{hp-20221219.pdf}),
- Seite 33.
- \points{3}
- %
- % Lösung:
- %
- % 7 137
- % / |
- % 3 5 12 42
- % / \
- % 1 2 6
- %
- % (NULL-Zeiger sind hier nicht dargestellt,
- % gehören aber dazu.)
- %
- \item
- Dasselbe, aber in der Reihenfolge
- 2, 7, 42, 12, 1, 137, 5, 6, 3.
- \points{3}
- %
- % Lösung:
- %
- % 2 7
- % / | \
- % 1 5 6 12 42
- % / \
- % 3 137
- %
- % (NULL-Zeiger sind hier wieder nicht dargestellt,
- % gehören aber dazu.)
- %
- \item
- Beschreiben Sie in Worten und/oder als C-Quelltext-Fragment,
- wie eine Funktion aussehen müßte, um den auf diese Weise entstandenen Baum
- sortiert auszugeben.
- \points{4}
- \end{enumerate}
-
- \solution
-
- \begin{enumerate}[\quad(a)]
- \item
- \textbf{Zeichnen Sie ein Schaubild, das veranschaulicht,
- wie die Zahlen 7, 137, 3, 5, 6, 42, 1, 2 und 12
- nacheinander und in dieser Reihenfolge
- in den oben beschriebenen Baum eingefügt werden
- -- analog zu den Vortragsfolien (\gitfile{hp}{2022ws/20221219}{hp-20221219.pdf}),
- Seite 21.}
- %
- % Lösung:
- %
- % 7 137
- % / |
- % 3 5 12 42
- % / \
- % 1 2 6
- %
- % (NULL-Zeiger sind hier nicht dargestellt,
- % gehören aber dazu.)
- %
- \begin{center}
- \newcommand{\x}{~\makebox(0,0){\raisebox{0.7em}{\rule{1pt}{1.4em}}}~}
- \begin{tikzpicture}
- \color{blendedblue}
- \node(root) at (0,0) {\lstinline{node *root;}};
- \node[shape=rectangle,draw,line width=1pt](7-137) at (0,-1.5) {7\x 137};
- \draw[-latex](root)--(7-137);
- \node[shape=rectangle,draw,line width=1pt](3-5) at (-2,-3) {3\x 5};
- \draw[-latex](7-137)--(3-5);
- \node[shape=rectangle,draw,line width=1pt](12-42) at (0,-3) {12\x 42};
- \draw[-latex](7-137)--(12-42);
- \node[shape=rectangle,draw,line width=1pt](1-2) at (-4,-4.5) {1\x 2};
- \draw[-latex](3-5)--(1-2);
- \node[shape=rectangle,draw,line width=1pt](6) at (0,-4.5) {6};
- \draw[-latex](3-5)--(6);
- \end{tikzpicture}
- \end{center}
- Bemerkungen:
- \begin{itemize}
- \item
- Zeiger mit dem Wert \lstinline{NULL} sind nicht dargestellt:
- \lstinline{right}-Zeiger von 7/137,
- \lstinline{middle}-Zeiger von 3/5,
- sämtliche Zeiger von 1/2, 12/42 und 6.
- \item
- Beim Einfügen der 12 wird die sich bereits vorher in diesem
- \lstinline{node} befindliche 42 zu \lstinline{content_right},
- und die 12 wird das neue \lstinline{content_left}.
- \item
- Dieser Baum hat sehr einfache Regeln und ist daher \emph{nicht\/}
- balanciert. Insbesondere unsere Regel, daß einmal angelegte Knoten
- nicht mehr verändert werden dürfen, steht dem im Wege.
- Ein einfaches Beispiel für einen \emph{balancierten\/} ternären
- Baum ist der 2-3-Baum -- siehe z.\,B.\ \url{https://en.wikipedia.org/wiki/2-3_tree}.
- \end{itemize}
- \goodbreak
- \item
- \textbf{Dasselbe, aber in der Reihenfolge
- 2, 7, 42, 12, 1, 137, 5, 6, 3.}
- %
- % Lösung:
- %
- % 2 7
- % / | \
- % 1 5 6 12 42
- % / \
- % 3 137
- %
- % (NULL-Zeiger sind hier wieder nicht dargestellt,
- % gehören aber dazu.)
- %
- \begin{center}
- \newcommand{\x}{~\makebox(0,0){\raisebox{0.7em}{\rule{1pt}{1.4em}}}~}
- \begin{tikzpicture}
- \color{blendedblue}
- \node(root) at (0,0) {\lstinline{node *root;}};
- \node[shape=rectangle,draw,line width=1pt](2-7) at (0,-1.5) {2\x 7};
- \draw[-latex](root)--(7-137);
- \node[shape=rectangle,draw,line width=1pt](1) at (-2,-3) {1};
- \draw[-latex](2-7)--(1);
- \node[shape=rectangle,draw,line width=1pt](5-6) at (0,-3) {5\x 6};
- \draw[-latex](2-7)--(5-6);
- \node[shape=rectangle,draw,line width=1pt](3) at (-2,-4.5) {3};
- \draw[-latex](5-6)--(3);
- \node[shape=rectangle,draw,line width=1pt](12-42) at (2,-3) {12\x 42};
- \draw[-latex](2-7)--(12-42);
- \node[shape=rectangle,draw,line width=1pt](137) at (4,-4.5) {137};
- \draw[-latex](12-42)--(137);
- \end{tikzpicture}
- \end{center}
- Bemerkungen:
- \begin{itemize}
- \item
- Wieder sind Zeiger mit dem Wert \lstinline{NULL} nicht dargestellt:
- \lstinline{middle}- und \lstinline{right}-Zeiger von 5/6,
- \lstinline{left}- und \lstinline{middle}-Zeiger von 12/42,
- sämtliche Zeiger von 1, 3 und 137.
- \item
- Beim Einfügen der 12 wird wieder die sich bereits vorher in diesem
- \lstinline{node} befindliche 42 zu \lstinline{content_right},
- und die 12 wird das neue \lstinline{content_left}.
- \end{itemize}
- \item
- \textbf{Beschreiben Sie in Worten und/oder als C-Quelltext-Fragment,
- wie eine Funktion aussehen müßte, um den auf diese Weise entstandenen Baum
- sortiert auszugeben.}
-
- Die entscheidende Idee ist \textbf{Rekursion}.
-
- Eine Funktion, die den gesamten Baum ausgibt,
- müßte einmalig für den Zeiger \lstinline{root} aufgerufen werden
- und folgendes tun:
- \begin{enumerate}[\quad 1.]
- \item
- falls der übergebene Zeiger den Wert \lstinline{NULL} hat,
- nichts ausgeben, sondern die Funktion direkt beenden,
- \item
- sich selbst für den \lstinline{left}-Zeiger aufrufen,
- \item
- den Wert von \lstinline{content_left} ausgeben,
- \item
- sich selbst für den \lstinline{middle}-Zeiger aufrufen,
- \item
- sofern vorhanden (also ungleich \lstinline{-1}),
- den Wert von \lstinline{content_right} ausgeben,
- \item
- sich selbst für den \lstinline{right}-Zeiger aufrufen.
- \end{enumerate}
- Als C-Fragment:
- \begin{lstlisting}[gobble=8]
- void output_tree (node *root)
- {
- if (root)
- {
- output_tree (root->left);
- printf ("%d\n", root->content_left);
- output_tree (root->middle);
- if (root->content_right >= 0)
- printf ("%d\n", root->content_right);
- output_tree (root->right);
- }
- }
- \end{lstlisting}
- Die Datei \gitfile{hp}{2022ws/20230109}{loesung-2c.c} erweitert dieses Fragment
- zu einem vollständigen C-Programm zum Erstellen und sortierten Ausgeben
- eines ternären Baums mit den Zahlenwerten von Aufgabenteil (a).
- \end{enumerate}
-
- \exercise{Fehlerhaftes Programm: Hüpfender Ball}
-
- Das auf der nächsten Seite abgedruckte GTK+-Programm
- (Datei: \gitfile{hp}{2022ws/20230109}{aufgabe-3.c}) soll einen
- hüpfenden Ball darstellen, ist jedoch fehlerhaft.
-
- \begin{enumerate}[\quad(a)]
- \item
- Warum sieht man lediglich ein leeres Fenster?
- Welchen Befehl muß man ergänzen, um diesen Fehler zu beheben?
- \points{3}
- \item
- Nach der Fehlerbehebung in Aufgabenteil (a)
- zeigt das Programm einen unbeweglichen Ball.
- Welchen Befehl muß man ergänzen, um diesen Fehler zu beheben, und warum?
- \points{2}
- \item
- Erklären Sie das merkwürdige Hüpfverhalten des Balls.
- Wie kommt es zustande?
- Was an diesem Verhalten ist korrekt, und was ist fehlerhaft? \points{5}
- \item
- Welche Befehle muß man in welcher Weise ändern,
- um ein realistischeres Hüpf-Verhalten zu bekommen? \points{2}
- \end{enumerate}
-
- Hinweis: Das Hinzuziehen von Beispiel-Programmen aus der Vorlesung
- ist ausdrücklich erlaubt -- auch in der Klausur.
-
- Allgemeiner Hinweis:
- Wenn Sie die Übungsaufgaben zu dieser Lehrveranstaltung
- als PDF-Datei betrachten und darin auf die Dateinamen klicken,
- können Sie die Beispiel-Programme direkt herunterladen.
- Dadurch vermeiden Sie Übertragungsfehler.
-
- \solution
-
- \begin{enumerate}[\quad(a)]
- \item
- \textbf{Warum sieht man lediglich ein leeres Fenster?
- Welchen Befehl muß man ergänzen, um diesen Fehler zu beheben?}
-
- Die für das Zeichnen zuständige Callback-Funktion wurde zwar geschrieben,
- aber nicht installiert.
- Um dies zu beheben, ergänze man den folgenden Befehl im Hauptprogramm:
-
- \lstinline{g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);}
-
- Dies erkennt man sehr schnell durch Vergleich mit dem Beispiel-Programm
- \gitfile{hp}{2022ws/20221114}{gtk-13.c}.
-
- \item
- \textbf{Nach der Fehlerbehebung in Aufgabenteil (a)
- zeigt das Programm einen unbeweglichen Ball.
- Welchen Befehl muß man ergänzen, um diesen Fehler zu beheben, und warum?}
-
- Die Timer-Callback-Funktion wurde zwar geschrieben, aber nicht installiert.
- Um dies zu beheben, ergänze man den folgenden Befehl im Hauptprogramm:
-
- \lstinline{g_timeout_add (50, (GSourceFunc) timer, drawing_area);}
-
- Auch dies erkennt man sehr schnell durch Vergleich mit dem Beispiel-Programm
- \gitfile{hp}{2022ws/20221114}{gtk-13.c}.
-
- \item
- \textbf{Erklären Sie das merkwürdige Hüpfverhalten des Balls.
- Wie kommt es zustande?
- Was an diesem Verhalten ist korrekt, und was ist fehlerhaft?}
-
- Die Geschwindigkeit in $y$-Richtung wächst immer weiter.
- Der Grund dafür ist, daß die $y$-Komponente der Geschwindigkeit
- nicht auf physikalisch sinnvolle Weise berechnet wird.
- In der dafür zuständigen Zeile
- \lstinline{vy = 0.5 * g * (t * t);}
- wird stattdessen der Weg in $y$-Richtung bei einer gleichmäßig
- beschleunigten Bewegung berechnet und als Geschwindigkeit verwendet.
-
- \item
- \textbf{Welche Befehle muß man in welcher Weise ändern,
- um ein realistischeres Hüpf-Verhalten zu bekommen?}
-
- Da der Ball am Boden abprallen soll, ist es \emph{nicht\/} sinnvoll,
- die $y$-Komponente der Geschwindigkeit über die bekannte physikalische
- Formel $v_y = -g\cdot t$ für die Geschwindigkeit in einer
- gleichmäßig beschleunigten Bewegung zu berechnen.
-
- Stattdessen ist es sinnvoll, die \emph{Geschwindigkeitsänderung\/}
- innerhalb des Zeitintervalls \lstinline{dt}
- zur Geschwindigkeitskomponente zu addieren:
- \lstinline{vy += g * dt;}
-
- Auch dies erkennt man sehr schnell durch Vergleich mit dem Beispiel-Programm
- \gitfile{hp}{2022ws/20221114}{gtk-13.c}.
- \end{enumerate}
-
- \clearpage
-
- \vbox to \textheight{\vspace*{-0.5cm}\begin{lstlisting}
- #include <gtk/gtk.h>
-
- #define WIDTH 320
- #define HEIGHT 240
-
- double t = 0.0;
- double dt = 0.2;
-
- int r = 5;
-
- double x = 10;
- double y = 200;
- double vx = 20;
- double vy = -60;
- double g = 9.81;
-
- gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
- {
- GdkRGBA blue = { 0.0, 0.5, 1.0, 1.0 };
-
- gdk_cairo_set_source_rgba (c, &blue);
- cairo_arc (c, x, y, r, 0, 2 * G_PI);
- cairo_fill (c);
-
- return FALSE;
- }
-
- gboolean timer (GtkWidget *widget)
- {
- t += dt;
- x += vx * dt;
- y += vy * dt;
- vx = vx;
- vy = 0.5 * g * (t * t);
- if (y + r >= HEIGHT)
- vy = -vy * 0.9;
- if (x + r >= WIDTH)
- vx = -vx * 0.9;
- if (x - r <= 0)
- vx = -vx * 0.9;
- gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
- }
-
- int main (int argc, char **argv)
- {
- gtk_init (&argc, &argv);
-
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_widget_show (window);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_widget_show (drawing_area);
- gtk_container_add (GTK_CONTAINER (window), drawing_area);
- gtk_widget_set_size_request (drawing_area, WIDTH, HEIGHT);
-
- gtk_main ();
- return 0;
- }
- \end{lstlisting}\vss}
-
- \clearpage
-
- \exercise{Hexdumps}
-
- Das folgende Programm (\gitfile{hp}{2022ws/20230109}{aufgabe-4.c}) liest
- einen String ein und gibt die ASCII-Werte der Buchstaben hexadezimal aus.
- (Anders als z.\,B.\ \lstinline{scanf()}
- akzeptiert die Funktion \lstinline{fgets()} zum Lesen von Strings auch Leerzeichen,
- und sie vermeidet Pufferüberläufe.)
- \begin{lstlisting}[style=numbered]
- #include <stdio.h>
-
- int main (void)
- {
- char buffer[100];
- fgets (buffer, 100, stdin);
- for (char *p = buffer; *p; p++)
- printf ("%02x", *p);
- printf ("\n");
- }
- \end{lstlisting}
- Beispiel: Bei der Eingabe von \lstinline[style=cmd]{Dies ist ein Test.}
- erscheint die Ausgabe\\
- \lstinline[style=terminal]{44696573206973742065696e20546573742e0a}.
-
- Schreiben Sie ein Programm, das diese Umwandlung in umgekehrter Richtung vornimmt,
- also z.\,B.\ bei Eingabe von \lstinline[style=cmd]{44696573206973742065696e20546573742e0a}
- wieder \lstinline[style=terminal]{Dies ist ein Test.} ausgibt.
-
- \points{6}
-
- Hinweis für die Klausur:
- Abgabe in digitaler Form ist erwünscht, aber nicht zwingend.
-
- \solution
-
- Siehe \gitfile{hp}{2022ws/20230109}{loesung-4.c}.
-
- Das Programm macht mehrfach davon Gebrauch,
- daß in C Zeichen und Zahlen äquivalent sind.
- Wenn z.\,B.\ die \lstinline{char}-Variable \lstinline{c}
- den Wert \lstinline{'3'} (Ziffer 3) enthält,
- dann hat der Ausdruck \lstinline{c - '0'} den Wert \lstinline{3} (Zahlenwert 3).
- Hierfür ist es insbesondere nicht nötig, vorauszusetzen,
- daß wir den ASCII-Zeichensatz verwenden und \lstinline{'0'}
- den Wert \lstinline{48} hat.
-
- Bei Eingabe von \lstinline[style=cmd]{44696573206973742065696e20546573742e0a}
- gibt das Programm zusätzlich eine Leerzeile aus.
- Die liegt daran, daß das \lstinline[style=cmd]{0a} am Ende
- bereits eine Zeilenschaltung enthält und das Programm mit
- \lstinline{printf ("\n")} eine zusätzliche Zeilenschaltung ausgibt.
-
-\end{document}
diff --git a/20230109/hp-uebung-20230109.pdf b/20230109/hp-uebung-20230109.pdf
deleted file mode 100644
index fa3d56e5adb15c9eca45f503587d85415b4cd073..0000000000000000000000000000000000000000
Binary files a/20230109/hp-uebung-20230109.pdf and /dev/null differ
diff --git a/20230109/hp-uebung-20230109.tex b/20230109/hp-uebung-20230109.tex
deleted file mode 100644
index e74dbe9a04de7ba9eb0de465392b0d840323d5cd..0000000000000000000000000000000000000000
--- a/20230109/hp-uebung-20230109.tex
+++ /dev/null
@@ -1,350 +0,0 @@
-% hp-uebung-20230109.pdf - Exercises on Low-Level Programming / Applied Computer Sciences
-% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Peter Gerwinski
-%
-% This document is free software: you can redistribute it and/or
-% modify it either under the terms of the Creative Commons
-% Attribution-ShareAlike 3.0 License, or under the terms of the
-% GNU General Public License as published by the Free Software
-% Foundation, either version 3 of the License, or (at your option)
-% any later version.
-%
-% This document is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% You should have received a copy of the GNU General Public License
-% along with this document. If not, see <http://www.gnu.org/licenses/>.
-%
-% You should have received a copy of the Creative Commons
-% Attribution-ShareAlike 3.0 Unported License along with this
-% document. If not, see <http://creativecommons.org/licenses/>.
-
-% README: Einfach und doppelt verkettete Listen, ternärer Baum, hüpfender Ball, Hexdumps
-
-% ! Hüpfender Ball (20211206-3)
-% ! Hexdumps (20220110-3)
-% ! einfach und doppelt verkettete Listen (20220117-2)
-% ! ternärer Baum (20220117-3)
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-\usepackage{tikz}
-
-\begin{document}
-
- \section*{Hardwarenahe Programmierung\\
- Übungsaufgaben -- 9.\ Januar 2023}
-
- Diese Übung enthält Punkteangaben wie in einer Klausur.
- Um zu "`bestehen"', müssen Sie innerhalb von 120 Minuten
- unter Verwendung ausschließlich zugelassener Hilfsmittel
- 20 Punkte (von insgesamt \totalpoints) erreichen.
-
- \exercise{Einfach und doppelt verkettete Listen}
-
- Das Beispiel-Programm \gitfile{hp}{2022ws/20230109}{aufgabe-1.c}
- demonstriert zwei Funktionen zur Verwaltung einfach verketteter Listen:
- \lstinline{output_list()} zum Ausgeben der Liste auf den Bildschirm und
- \lstinline{insert_into_list()} zum Einfügen in die Liste.
-
- \begin{enumerate}[\quad(a)]
- \item
- Ergänzen Sie eine Funktion \lstinline{delete_from_list()}
- zum Löschen eines Elements aus der Liste
- mit Freigabe des Speicherplatzes.
- \points{5}
- \item
- Ergänzen Sie eine Funktion \lstinline{reverse_list()}
- die die Reihenfolge der Elemente in der Liste umdreht.\\
- \points{3}
- \end{enumerate}
-
- Eine doppelt verkettete Liste hat in jedem Knotenpunkt (\lstinline{node})
- \emph{zwei\/} Zeiger -- einen auf das nächste Element (\lstinline{next})
- und einen auf das vorherige Element (z.\,B.\ \lstinline{prev} für "`previous"').
- Dadurch ist es leichter als bei einer einfach verketteten Liste,
- die Liste in umgekehrter Reihenfolge durchzugehen.
-
- \begin{quote}
- \begin{tikzpicture}
- \color{blendedblue}
- \node(first) at (0,3.5) {first};
- \node(NULL1) at (-1,1.25) {NULL};
- \node[shape=rectangle,draw,line width=1pt](3) at (1,2) {3};
- \node[shape=rectangle,draw,line width=1pt](7) at (3,2) {7};
- \node[shape=rectangle,draw,line width=1pt](137) at (5,2) {137};
- \node(NULL2) at (7,2.75) {NULL};
- \draw[-latex](first)--(3);
- \draw[-latex](3) to[out=45,in=135] (7);
- \draw[-latex](3) to[out=-135,in=0] (NULL1);
- \draw[-latex](7) to[out=-135,in=-45] (3);
- \draw[-latex](7) to[out=45,in=135] (137);
- \draw[-latex](137) to[out=-135,in=-45] (7);
- \draw[-latex](137) to[out=45,in=180] (NULL2);
- \end{tikzpicture}
- \end{quote}
-
- Der Rückwärts-Zeiger (\lstinline{prev}) des ersten Elements zeigt,
- genau wie der Vorwärts-Zeiger (\lstinline{next}) des letzten Elements,
- auf \emph{nichts}, hat also den Wert \lstinline{NULL}.
-
- \begin{enumerate}[\quad(a)]\setcounter{enumi}{2}
- \item
- Schreiben Sie das Programm um für doppelt verkettete Listen.
- \points{5}
- \end{enumerate}
-
- \vspace{3cm}
-
- \exercise{Ternärer Baum}
-
- Der in der Vorlesung vorgestellte \newterm{binäre Baum\/}
- ist nur ein Spezialfall;
- im allgemeinen können Bäume auch mehr als zwei Verzweigungen
- pro Knotenpunkt haben.
- Dies ist nützlich bei der Konstruktion \emph{balancierter Bäume},
- also solcher, die auch im \emph{Worst Case\/}
- nicht zu einer linearen Liste entarten,
- sondern stets eine -- möglichst flache -- Baumstruktur behalten.
-
- Wir betrachten einen Baum mit bis zu drei Verzweigungen pro Knotenpunkt,
- einen sog.\ \newterm{ternären Baum}.
- Jeder Knoten enthält dann nicht nur einen,
- sondern \emph{zwei\/} Werte als Inhalt:
- \begin{lstlisting}
- typedef struct node
- {
- int content_left, content_right;
- struct node *left, *middle, *right;
- } node;
- \end{lstlisting}
-
- Wir konstruieren nun einen Baum nach folgenden Regeln:
- \vspace{-\medskipamount}
- \begin{itemize}\itemsep0pt
- \item
- Innerhalb eines Knotens sind die Werte sortiert:
- \lstinline{content_left} muß stets kleiner sein als \lstinline{content_right}.
- \item
- Der Zeiger \lstinline{left} zeigt auf Knoten,
- deren enthaltene Werte durchweg kleiner sind als \lstinline{content_left}.
- \item
- Der Zeiger \lstinline{right} zeigt auf Knoten,
- deren enthaltene Werte durchweg größer sind als \lstinline{content_right}.
- \item
- Der Zeiger \lstinline{middle} zeigt auf Knoten,
- deren enthaltene Werte durchweg größer sind als \lstinline{content_left},
- aber kleiner als \lstinline{content_right}.
- \item
- Ein Knoten muß nicht immer mit zwei Werten voll besetzt sein;
- er darf auch \emph{nur einen\/} gültigen Wert enthalten.
-
- Der Einfachheit halber lassen wir in diesem Beispiel
- nur positive Zahlen als Werte zu.
- Wenn ein Knoten nur einen Wert enthält,
- setzen wir \lstinline{content_right = -1},
- und der Zeiger \lstinline{middle} wird nicht verwendet.
- \item
- Wenn wir neue Werte in den Baum einfügen,
- werden \emph{zuerst\/} die nicht voll besetzten Knoten aufgefüllt
- und \emph{danach erst\/} neue Knoten angelegt und Zeiger gesetzt.
- \item
- Beim Auffüllen eines Knotens darf nötigenfalls \lstinline{content_left}
- nach \lstinline{content_right} verschoben werden.
- Ansonsten werden einmal angelegte Knoten nicht mehr verändert.
- \end{itemize}
- \vspace*{-\medskipamount}
- (In der Praxis dürfen Knoten gemäß speziellen Regeln
- nachträglich verändert werden,
- um Entartungen gar nicht erst entstehen zu lassen --
- siehe z.\,B.\ \url{https://en.wikipedia.org/wiki/2-3_tree}.)
- \begin{enumerate}[\quad(a)]
- \item
- Zeichnen Sie ein Schaubild, das veranschaulicht,
- wie die Zahlen 7, 137, 3, 5, 6, 42, 1, 2 und 12
- nacheinander und in dieser Reihenfolge
- in den oben beschriebenen Baum eingefügt werden
- -- analog zu den Vortragsfolien (\gitfile{hp}{2022ws/20221219}{hp-20221219.pdf}),
- Seite 33.
- \points{3}
- %
- % Lösung:
- %
- % 7 137
- % / |
- % 3 5 12 42
- % / \
- % 1 2 6
- %
- % (NULL-Zeiger sind hier nicht dargestellt,
- % gehören aber dazu.)
- %
- \item
- Dasselbe, aber in der Reihenfolge
- 2, 7, 42, 12, 1, 137, 5, 6, 3.
- \points{3}
- %
- % Lösung:
- %
- % 2 7
- % / | \
- % 1 5 6 12 42
- % / \
- % 3 137
- %
- % (NULL-Zeiger sind hier wieder nicht dargestellt,
- % gehören aber dazu.)
- %
- \item
- Beschreiben Sie in Worten und/oder als C-Quelltext-Fragment,
- wie eine Funktion aussehen müßte, um den auf diese Weise entstandenen Baum
- sortiert auszugeben.
- \points{4}
- \end{enumerate}
-
- \vspace{3cm}
-
- \exercise{Fehlerhaftes Programm: Hüpfender Ball}
-
- Das auf der nächsten Seite abgedruckte GTK+-Programm
- (Datei: \gitfile{hp}{2022ws/20230109}{aufgabe-3.c}) soll einen
- hüpfenden Ball darstellen, ist jedoch fehlerhaft.
-
- \begin{enumerate}[\quad(a)]
- \item
- Warum sieht man lediglich ein leeres Fenster?
- Welchen Befehl muß man ergänzen, um diesen Fehler zu beheben?
- \points{3}
- \item
- Nach der Fehlerbehebung in Aufgabenteil (a)
- zeigt das Programm einen unbeweglichen Ball.
- Welchen Befehl muß man ergänzen, um diesen Fehler zu beheben, und warum?
- \points{2}
- \item
- Erklären Sie das merkwürdige Hüpfverhalten des Balls.
- Wie kommt es zustande?
- Was an diesem Verhalten ist korrekt, und was ist fehlerhaft? \points{5}
- \item
- Welche Befehle muß man in welcher Weise ändern,
- um ein realistischeres Hüpf-Verhalten zu bekommen? \points{2}
- \end{enumerate}
-
- Hinweis: Das Hinzuziehen von Beispiel-Programmen aus der Vorlesung
- ist ausdrücklich erlaubt -- auch in der Klausur.
-
- Allgemeiner Hinweis:
- Wenn Sie die Übungsaufgaben zu dieser Lehrveranstaltung
- als PDF-Datei betrachten und darin auf die Dateinamen klicken,
- können Sie die Beispiel-Programme direkt herunterladen.
- Dadurch vermeiden Sie Übertragungsfehler.
-
- \clearpage
-
- \vbox to \textheight{\vspace*{-0.5cm}\begin{lstlisting}
- #include <gtk/gtk.h>
-
- #define WIDTH 320
- #define HEIGHT 240
-
- double t = 0.0;
- double dt = 0.2;
-
- int r = 5;
-
- double x = 10;
- double y = 200;
- double vx = 20;
- double vy = -60;
- double g = 9.81;
-
- gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
- {
- GdkRGBA blue = { 0.0, 0.5, 1.0, 1.0 };
-
- gdk_cairo_set_source_rgba (c, &blue);
- cairo_arc (c, x, y, r, 0, 2 * G_PI);
- cairo_fill (c);
-
- return FALSE;
- }
-
- gboolean timer (GtkWidget *widget)
- {
- t += dt;
- x += vx * dt;
- y += vy * dt;
- vx = vx;
- vy = 0.5 * g * (t * t);
- if (y + r >= HEIGHT)
- vy = -vy * 0.9;
- if (x + r >= WIDTH)
- vx = -vx * 0.9;
- if (x - r <= 0)
- vx = -vx * 0.9;
- gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
- g_timeout_add (50, (GSourceFunc) timer, widget);
- return FALSE;
- }
-
- int main (int argc, char **argv)
- {
- gtk_init (&argc, &argv);
-
- GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_widget_show (window);
- gtk_window_set_title (GTK_WINDOW (window), "Hello");
- g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
- GtkWidget *drawing_area = gtk_drawing_area_new ();
- gtk_widget_show (drawing_area);
- gtk_container_add (GTK_CONTAINER (window), drawing_area);
- gtk_widget_set_size_request (drawing_area, WIDTH, HEIGHT);
-
- gtk_main ();
- return 0;
- }
- \end{lstlisting}\vss}
-
- \exercise{Hexdumps}
-
- Das folgende Programm (\gitfile{hp}{2022ws/20230109}{aufgabe-4.c}) liest
- einen String ein und gibt die ASCII-Werte der Buchstaben hexadezimal aus.
- (Anders als z.\,B.\ \lstinline{scanf()}
- akzeptiert die Funktion \lstinline{fgets()} zum Lesen von Strings auch Leerzeichen,
- und sie vermeidet Pufferüberläufe.)
- \begin{lstlisting}[style=numbered]
- #include <stdio.h>
-
- int main (void)
- {
- char buffer[100];
- fgets (buffer, 100, stdin);
- for (char *p = buffer; *p; p++)
- printf ("%02x", *p);
- printf ("\n");
- }
- \end{lstlisting}
- Beispiel: Bei der Eingabe von \lstinline[style=cmd]{Dies ist ein Test.}
- erscheint die Ausgabe\\
- \lstinline[style=terminal]{44696573206973742065696e20546573742e0a}.
-
- Schreiben Sie ein Programm, das diese Umwandlung in umgekehrter Richtung vornimmt,
- also z.\,B.\ bei Eingabe von \lstinline[style=cmd]{44696573206973742065696e20546573742e0a}
- wieder \lstinline[style=terminal]{Dies ist ein Test.} ausgibt.
-
- \points{6}
-
- Hinweis für die Klausur:
- Abgabe in digitaler Form ist erwünscht, aber nicht zwingend.
-
- \begin{flushright}
- \textit{Viel Erfolg -- auch in den Prüfungen!}
- \end{flushright}
-
- \makeatletter
- \immediate\write\@mainaux{\string\gdef\string\totalpoints{\arabic{points}}}
- \makeatother
-
-\end{document}
diff --git a/20230109/loesung-1a.c b/20230109/loesung-1a.c
deleted file mode 100644
index 93f5e5629a98d13d6292c56d1a3f855b4f5bd8fd..0000000000000000000000000000000000000000
--- a/20230109/loesung-1a.c
+++ /dev/null
@@ -1,69 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *next;
-} node;
-
-void output_list (node *first)
-{
- for (node *p = first; p; p = p->next)
- printf ("%d ", p->content);
- printf ("\n");
-}
-
-void insert_into_list (node *what, node *where)
-{
- what->next = where->next;
- where->next = what;
-}
-
-void delete_from_list (node *what, node **first)
-{
- if (what == *first)
- *first = what->next;
- else
- {
- node *p = *first;
- while (p && p->next != what)
- p = p->next;
- if (p)
- p->next = what->next;
- }
- free (what);
-}
-
-int main (void)
-{
- node *element3 = malloc (sizeof (node));
- node *element7 = malloc (sizeof (node));
- node *element137 = malloc (sizeof (node));
-
- element3->content = 3;
- element7->content = 7;
- element137->content = 137;
-
- node *first = element3;
- element3->next = element7;
- element7->next = element137;
- element137->next = NULL;
-
- output_list (first);
-
- node *element5 = malloc (sizeof (node));
- element5->content = 5;
- insert_into_list (element5, element3);
-
- output_list (first);
-
- delete_from_list (element5, &first);
- output_list (first);
- delete_from_list (element3, &first);
- output_list (first);
- delete_from_list (element137, &first);
- output_list (first);
-
- return 0;
-}
diff --git a/20230109/loesung-1b.c b/20230109/loesung-1b.c
deleted file mode 100644
index 811b99b1fc9697ca0302eea8950c9bc6e7ab6042..0000000000000000000000000000000000000000
--- a/20230109/loesung-1b.c
+++ /dev/null
@@ -1,97 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content;
- struct node *next, *prev;
-} node;
-
-void check_list (node *first)
-{
- for (node *p = first; p; p = p->next)
- {
- if (p->next && p->next->prev != p)
- fprintf (stderr, "List inconsistency!\n");
- if (p->prev && p->prev->next != p)
- fprintf (stderr, "List inconsistency!\n");
- }
-}
-
-void output_list (node *first)
-{
- for (node *p = first; p; p = p->next)
- printf ("%d ", p->content);
- printf ("\n");
-}
-
-void insert_into_list (node *what, node *where)
-{
- what->next = where->next;
- if (where->next)
- where->next->prev = what;
- what->prev = where;
- where->next = what;
-}
-
-void delete_from_list (node *what, node **first)
-{
- if (what == *first)
- {
- *first = what->next;
- if (*first)
- (*first)->prev = NULL;
- }
- else
- {
- node *p = *first;
- while (p && p->next != what)
- p = p->next;
- if (p)
- p->next = what->next;
- if (what->next)
- what->next->prev = p;
- }
- free (what);
-}
-
-int main (void)
-{
- node *element3 = malloc (sizeof (node));
- node *element7 = malloc (sizeof (node));
- node *element137 = malloc (sizeof (node));
-
- element3->content = 3;
- element7->content = 7;
- element137->content = 137;
-
- node *first = element3;
- element3->prev = NULL;
- element3->next = element7;
- element7->prev = element3;
- element7->next = element137;
- element137->prev = element7;
- element137->next = NULL;
-
- output_list (first);
- check_list (first);
-
- node *element5 = malloc (sizeof (node));
- element5->content = 5;
- insert_into_list (element5, element3);
-
- output_list (first);
- check_list (first);
-
- delete_from_list (element5, &first);
- output_list (first);
- check_list (first);
- delete_from_list (element3, &first);
- output_list (first);
- check_list (first);
- delete_from_list (element137, &first);
- output_list (first);
- check_list (first);
-
- return 0;
-}
diff --git a/20230109/loesung-2c.c b/20230109/loesung-2c.c
deleted file mode 100644
index a6dea990b25895475e343f07895c6a946426d2d8..0000000000000000000000000000000000000000
--- a/20230109/loesung-2c.c
+++ /dev/null
@@ -1,68 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct node
-{
- int content_left, content_right;
- struct node *left, *middle, *right;
-} node;
-
-void insert_into_tree (node **root, int value)
-{
- if (*root)
- {
- if ((*root)->content_right >= 0)
- if (value < (*root)->content_left)
- insert_into_tree (&(*root)->left, value);
- else if (value < (*root)->content_right)
- insert_into_tree (&(*root)->middle, value);
- else
- insert_into_tree (&(*root)->right, value);
- else
- if (value < (*root)->content_left)
- {
- (*root)->content_right = (*root)->content_left;
- (*root)->content_left = value;
- }
- else
- (*root)->content_right = value;
- }
- else
- {
- *root = malloc (sizeof (node));
- (*root)->left = NULL;
- (*root)->content_left = value;
- (*root)->middle = NULL;
- (*root)->content_right = -1;
- (*root)->right = NULL;
- }
-}
-
-void output_tree (node *root)
-{
- if (root)
- {
- output_tree (root->left);
- printf ("%d\n", root->content_left);
- output_tree (root->middle);
- if (root->content_right >= 0)
- printf ("%d\n", root->content_right);
- output_tree (root->right);
- }
-}
-
-int main (void)
-{
- node *root = NULL;
- insert_into_tree (&root, 7);
- insert_into_tree (&root, 137);
- insert_into_tree (&root, 3);
- insert_into_tree (&root, 5);
- insert_into_tree (&root, 6);
- insert_into_tree (&root, 42);
- insert_into_tree (&root, 1);
- insert_into_tree (&root, 2);
- insert_into_tree (&root, 12);
- output_tree (root);
- return 0;
-}
diff --git a/20230109/loesung-3b-gpt.c b/20230109/loesung-3b-gpt.c
deleted file mode 100644
index 467813bbaf0bb0ca60e6e983769bfbb98e74b96a..0000000000000000000000000000000000000000
--- a/20230109/loesung-3b-gpt.c
+++ /dev/null
@@ -1,27 +0,0 @@
-#include <stdio.h>
-
-int sum; // globale Variable für die Summe
-
-void add_to_sum (int x)
-{
- if (x > 0)
- {
- sum += x;
- }
-}
-
-void foreach (int *a, void (*fun) (int x))
-{
- for (int *p = a; *p >= 0; p++)
- {
- fun (*p);
- }
-}
-
-int main (void)
-{
- int numbers[] = { 12, 17, 32, 1, 3, 16, 19, 18, -1 };
- foreach (numbers, add_to_sum);
- printf ("Summe der positiven Zahlen: %d\n", sum);
- return 0;
-}
diff --git a/20230109/loesung-4-gpt-pg.c b/20230109/loesung-4-gpt-pg.c
deleted file mode 100644
index 50270f858e7de49ea99cb6e125b4775b652ada81..0000000000000000000000000000000000000000
--- a/20230109/loesung-4-gpt-pg.c
+++ /dev/null
@@ -1,42 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-/* eigentlich: #include "aufgabe-4.xbm" */
-
-#define XBM_WIDTH 14
-#define XBM_HEIGHT 14
-
-static unsigned char xbm_bits[] = {
- 0x00, 0x00, 0xf0, 0x03, 0x08, 0x04, 0x04, 0x08, 0x02, 0x10, 0x32, 0x13,
- 0x22, 0x12, 0x02, 0x10, 0x0a, 0x14, 0x12, 0x12, 0xe4, 0x09, 0x08, 0x04,
- 0xf0, 0x03, 0x00, 0x00
-};
-
-int main(int argc, char **argv)
-{
- // Öffne die Ausgabedatei
- FILE *output_file = fopen("test.pbm", "w");
- if (output_file == NULL) {
- printf("Fehler beim Öffnen der Ausgabedatei\n");
- return 1;
- }
-
- // Schreibe die PBM-Dateikennung, Breite und Höhe in die Ausgabedatei
- fprintf(output_file, "P4\n%d %d\n", XBM_WIDTH, XBM_HEIGHT);
-
- // Iteriere über jedes Byte im XBM-Array
- for (int i = 0; i < XBM_HEIGHT * XBM_WIDTH / 8; i++) { // Iteriere über jedes Bit im aktuellen Byte
- for (int j = 7; j >= 0; j--) {
- // Lies das aktuelle Bit des XBM-Arrays und schreibe es in die Ausgabedatei
- // PG: nicht berücksichtigt: umgekehrte Bit-Reihenfolge (MSB/LSB first)
- uint8_t xbm_bit = (xbm_bits[i] >> j) & 1;
- fprintf(output_file, "%c", xbm_bit ? '1' : '0');
- }
- }
-
- // Schließe die Ausgabedatei
- fclose(output_file);
-
- return 0;
-}
-
diff --git a/20230109/loesung-4-gpt.c b/20230109/loesung-4-gpt.c
deleted file mode 100644
index 8a47e33344c510eb059c7e876ae5300aca3c35ed..0000000000000000000000000000000000000000
--- a/20230109/loesung-4-gpt.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-
-#define XBM_WIDTH 14
-#define XBM_HEIGHT 14
-
-static unsigned char xbm_bits[] = {
- 0x00, 0x00, 0xf0, 0x03, 0x08, 0x04, 0x04, 0x08, 0x02, 0x10, 0x32, 0x13,
- 0x22, 0x12, 0x02, 0x10, 0x0a, 0x14, 0x12, 0x12, 0xe4, 0x09, 0x08, 0x04,
- 0xf0, 0x03, 0x00, 0x00
-};
-
-int main(int argc, char **argv)
-{
- // Öffne die Ausgabedatei
- FILE *output_file = fopen("test.pbm", "w");
- if (output_file == NULL) {
- printf("Fehler beim Öffnen der Ausgabedatei\n");
- return 1;
- }
-
- // Schreibe die PBM-Dateikennung, Breite und Höhe in die Ausgabedatei
- fprintf(output_file, "P4\n%d %d\n", XBM_WIDTH, XBM_HEIGHT);
-
- // Iteriere über jedes Byte im XBM-Array
- for (int i = 0; i < XBM_HEIGHT * XBM_WIDTH / 8; i++) { // Iteriere über jedes Bit im aktuellen Byte
- for (int j = 7; j >= 0; j--) {
- // Lies das aktuelle Bit des XBM-Arrays und schreibe es in die Ausgabedatei
- uint8_t xbm_bit = (xbm_bits[i] >> j) & 1;
- fprintf(output_file, "%c", xbm_bit ? '1' : '0');
- }
- }
-
- // Schließe die Ausgabedatei
- fclose(output_file);
-
- return 0;
-}
-
diff --git a/20230109/loesung-4.c b/20230109/loesung-4.c
deleted file mode 100644
index 872058ac9fecdcb59ac1104ca67841cb3dc974a9..0000000000000000000000000000000000000000
--- a/20230109/loesung-4.c
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <stdio.h>
-
-int read_hex (char c)
-{
- if (c >= '0' && c <= '9')
- return c - '0';
- else if (c >= 'A' && c <= 'F')
- return c - 'A' + 10;
- else if (c >= 'a' && c <= 'f')
- return c - 'a' + 10;
- else
- {
- fprintf (stderr, "invalid hex digit '%c'\n", c);
- return 0;
- }
-}
-
-int main (void)
-{
- char buffer[100];
- fgets (buffer, 100, stdin);
- for (char *p = buffer; p[0] && p[1]; p += 2)
- {
- char c = 16 * read_hex (p[0]) + read_hex (p[1]);
- printf ("%c", c);
- }
- printf ("\n");
-}
diff --git a/20230109/logo-hochschule-bochum-cvh-text-v2.pdf b/20230109/logo-hochschule-bochum-cvh-text-v2.pdf
deleted file mode 120000
index 4aa99b8f81061aca6dcaf43eed2d9efef40555f8..0000000000000000000000000000000000000000
--- a/20230109/logo-hochschule-bochum-cvh-text-v2.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
diff --git a/20230109/logo-hochschule-bochum.pdf b/20230109/logo-hochschule-bochum.pdf
deleted file mode 120000
index b6b9491e370e499c9276918182cdb82cb311bcd1..0000000000000000000000000000000000000000
--- a/20230109/logo-hochschule-bochum.pdf
+++ /dev/null
@@ -1 +0,0 @@
-../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20230109/output-01.c b/20230109/output-01.c
deleted file mode 100644
index d4f8b191d6d4491df2661046ce99c21ec2045a60..0000000000000000000000000000000000000000
--- a/20230109/output-01.c
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- printf (42);
- return 0;
-}
diff --git a/20230109/pgscript.sty b/20230109/pgscript.sty
deleted file mode 120000
index 95c888478c99ea7fda0fd11ccf669ae91be7178b..0000000000000000000000000000000000000000
--- a/20230109/pgscript.sty
+++ /dev/null
@@ -1 +0,0 @@
-../common/pgscript.sty
\ No newline at end of file
diff --git a/20230109/test-gpt-pg.pbm b/20230109/test-gpt-pg.pbm
deleted file mode 100644
index f0e9e7e193831ff0a079359d6808c7bcaad78670..0000000000000000000000000000000000000000
--- a/20230109/test-gpt-pg.pbm
+++ /dev/null
@@ -1,3 +0,0 @@
-P1
-16 14
-000000000000000011110000000000110000100000000100000001000000100000000010000100000011001000010011001000100001001000000010000100000000101000010100000100100001001011100100000010010000100000000100
diff --git a/20230109/test-gpt.pbm b/20230109/test-gpt.pbm
deleted file mode 100644
index 485ad2684c82d10da9d600467ddd1e89f7682080..0000000000000000000000000000000000000000
--- a/20230109/test-gpt.pbm
+++ /dev/null
@@ -1,3 +0,0 @@
-P4
-14 14
-000000000000000011110000000000110000100000000100000001000000100000000010000100000011001000010011001000100001001000000010000100000000101000010100000100100001001011100100000010010000100000000100
\ No newline at end of file
diff --git a/20230116/func-pointers-01.c b/20230116/func-pointers-01.c
deleted file mode 100644
index b2db5145e720b39de50d37e98365b02f1bb25ca2..0000000000000000000000000000000000000000
--- a/20230116/func-pointers-01.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-
-void hello (void)
-{
- printf ("Hello, world!\n");
-}
-
-int main (void)
-{
- hello ();
- return 0;
-}
diff --git a/20230116/func-pointers-02.c b/20230116/func-pointers-02.c
deleted file mode 100644
index 7c9d60ea9da2416b2f27b944dc500479825dd363..0000000000000000000000000000000000000000
--- a/20230116/func-pointers-02.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdio.h>
-
-void hello (void)
-{
- printf ("Hello, world!\n");
-}
-
-int main (void)
-{
- /* h ist ein Zeiger auf eine Funktion;
- h soll auf die Funktion hello() zeigen; */
- /* Merken: "*h ist eine Funktion." */
- /* void *h (void) wäre eine Funktion, die keine Parameter bekommt
- und einen Zeiger auf void zurückgibt. */
- void (*h) (void) = hello;
- h ();
- return 0;
-}
diff --git a/20230116/func-pointers-03.c b/20230116/func-pointers-03.c
deleted file mode 100644
index 003591a933eb6123e6b92ac20c14454de17c2ac3..0000000000000000000000000000000000000000
--- a/20230116/func-pointers-03.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-
-void hello (void)
-{
- printf ("Hello, world!\n");
-}
-
-int main (void)
-{
- typedef void (*funcptr) (void);
- funcptr h = hello;
- h ();
- return 0;
-}
diff --git a/20230116/func-pointers-04.c b/20230116/func-pointers-04.c
deleted file mode 100644
index 403cb68fa3490e93301ad6ffe574a273ff39bc88..0000000000000000000000000000000000000000
--- a/20230116/func-pointers-04.c
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- void (*greeting) (void); // Zeiger auf Funktion, nicht initialisiert
-}
-object;
-
-void hello (void)
-{
- printf ("Hello, world!\n");
-}
-
-int main (void)
-{
- object o;
-
- o.greeting = hello; // "Konstruktor" - Initiallisieren des Funktions-Zeigers
- //Ohne Klammerpaar: Adresse der Funktion
- o.greeting (); // mit Klammerpaar: Funktion aufrufen
-
- return 0;
-}
diff --git a/20230116/func-pointers-05.c b/20230116/func-pointers-05.c
deleted file mode 100644
index 8870230b80a2d0e78017133ab339590d1ed33e4b..0000000000000000000000000000000000000000
--- a/20230116/func-pointers-05.c
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- void (*greeting) (void); // Zeiger auf Funktion, nicht initialisiert
-}
-object;
-
-void hello (void)
-{
- printf ("Hello, world!\n");
-}
-
-int main (void)
-{
- object *o;
- // FEHLER: Verwendung von "o" ohne daß "o" auf etwas Sinnvolles zeigt!
- o->greeting = hello; // "Konstruktor" - Initiallisieren des Funktions-Zeigers
- // Ohne Klammerpaar: Adresse der Funktion
- o->greeting (); // mit Klammerpaar: Funktion aufrufen
-
- return 0;
-}
diff --git a/20230116/func-pointers-06.c b/20230116/func-pointers-06.c
deleted file mode 100644
index 995bc6ea0b673144b57f0e2a587a60df6b676228..0000000000000000000000000000000000000000
--- a/20230116/func-pointers-06.c
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct
-{
- void (*greeting) (void); // Zeiger auf Funktion, nicht initialisiert
-}
-object;
-
-void hello (void)
-{
- printf ("Hello, world!\n");
-}
-
-int main (void)
-{
- object *o;
-
- o = malloc (sizeof (object)); // Speicherplatz dynamisch erzeugen
-
- o->greeting = hello; // "Konstruktor" - Initiallisieren des Funktions-Zeigers
- // Ohne Klammerpaar: Adresse der Funktion
- o->greeting (); // mit Klammerpaar: Funktion aufrufen
-
- return 0;
-}
diff --git a/20230116/func-pointers-07.c b/20230116/func-pointers-07.c
deleted file mode 100644
index a47689d0c3bd5c8d23594e90c31415df8c221c47..0000000000000000000000000000000000000000
--- a/20230116/func-pointers-07.c
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- void (*greeting) (void); // Zeiger auf Funktion, nicht initialisiert
-}
-object;
-
-void hello (void)
-{
- printf ("Hello, world!\n");
-}
-
-int main (void)
-{
- object *o;
-
- object apfel; // Speicherplatz innerhalb von main() reservieren
- o = &apfel; // Zeiger darauf zeigen lassen
-
- o->greeting = hello; // "Konstruktor" - Initiallisieren des Funktions-Zeigers
- // Ohne Klammerpaar: Adresse der Funktion
- o->greeting (); // mit Klammerpaar: Funktion aufrufen
-
- return 0;
-}
diff --git a/20230116/func-pointers-08.c b/20230116/func-pointers-08.c
deleted file mode 100644
index 0b28bed135607997794ef02d3ddc3c823cbe3515..0000000000000000000000000000000000000000
--- a/20230116/func-pointers-08.c
+++ /dev/null
@@ -1,36 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- void (*greeting) (void); // Zeiger auf Funktion, nicht initialisiert
-}
-object;
-
-void hello_apple (void)
-{
- printf ("Hello, apple!\n");
-}
-
-void hello_pear (void)
-{
- printf ("Hello, pear!\n");
-}
-
-int main (void)
-{
- object *a;
- object *b;
-
- object apfel; // Speicherplatz innerhalb von main() reservieren
- a = &apfel; // Zeiger darauf zeigen lassen
- a->greeting = hello_apple; // "Konstruktor": virtuelle Methode initialisieren
-
- object birne; // Speicherplatz innerhalb von main() reservieren
- b = &birne; // Zeiger darauf zeigen lassen
- b->greeting = hello_pear; // "Konstruktor": virtuelle Methode initialisieren
-
- a->greeting ();
- b->greeting ();
-
- return 0;
-}
diff --git a/20230116/func-pointers-09.c b/20230116/func-pointers-09.c
deleted file mode 100644
index 25ca1bba9b9d775134383d0078611ed5dd890911..0000000000000000000000000000000000000000
--- a/20230116/func-pointers-09.c
+++ /dev/null
@@ -1,35 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- void (*greeting) (void); // Zeiger auf Funktion, nicht initialisiert
-}
-object;
-
-void hello_apple (void)
-{
- printf ("Hello, apple!\n");
-}
-
-void hello_pear (void)
-{
- printf ("Hello, pear!\n");
-}
-
-int main (void)
-{
- object *o[2]; // Array mit 2 Zeigern auf Objekte
-
- object apfel; // Speicherplatz innerhalb von main() reservieren
- o[0] = &apfel; // Zeiger darauf zeigen lassen
- o[0]->greeting = hello_apple; // "Konstruktor": virtuelle Methode initialisieren
-
- object birne; // Speicherplatz innerhalb von main() reservieren
- o[1] = &birne; // Zeiger darauf zeigen lassen
- o[1]->greeting = hello_pear; // "Konstruktor": virtuelle Methode initialisieren
-
- for (int i = 0; i < 2; i++)
- o[i]->greeting ();
-
- return 0;
-}
diff --git a/20230116/func-pointers-10.c b/20230116/func-pointers-10.c
deleted file mode 100644
index 10ad166342d4cf47c9df9e06e8f78211e5776be9..0000000000000000000000000000000000000000
--- a/20230116/func-pointers-10.c
+++ /dev/null
@@ -1,34 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct
-{
- void (*greeting) (void); // Zeiger auf Funktion, nicht initialisiert
-}
-object;
-
-void hello_apple (void)
-{
- printf ("Hello, apple!\n");
-}
-
-void hello_pear (void)
-{
- printf ("Hello, pear!\n");
-}
-
-int main (void)
-{
- object *o[2]; // Array mit 2 Zeigern auf Objekte
-
- o[0] = malloc (sizeof (object)); // "Konstrutor": Speicherplatz dynamisch reservieren
- o[0]->greeting = hello_apple; // "Konstruktor": virtuelle Methode initialisieren
-
- o[1] = malloc (sizeof (object)); // "Konstrutor": Speicherplatz dynamisch reservieren
- o[1]->greeting = hello_pear; // "Konstruktor": virtuelle Methode initialisieren
-
- for (int i = 0; i < 2; i++)
- o[i]->greeting ();
-
- return 0;
-}
diff --git a/20230116/hp-20230116.txt b/20230116/hp-20230116.txt
deleted file mode 100644
index d53358e95adc81494c9b3d1a4291614c119008a9..0000000000000000000000000000000000000000
--- a/20230116/hp-20230116.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-Klausur-Themen, 16.01.2023, 13:57:20
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- - Seiteneffekte
- - Arrays, Zeiger, Strings
- - Speicherzellen
- - Bit-Manipulation
- - Endianness
- - Alignment
- - Algorithmen, Landau-Symbol
- - Objekte, Zeiger auf Funktionen
-
---> Es ist mal wieder Zeit für:
- - Seiteneffekte
- - Mikrocontroller
-
-Zeiger, 16.01.2023, 11:30:23
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- - auf Funktionen
- - auf Structs und Unions
diff --git a/20230116/pointers-01.c b/20230116/pointers-01.c
deleted file mode 100644
index 230e8ed7d6dc91e2104c08028e2c58d8f654afa3..0000000000000000000000000000000000000000
--- a/20230116/pointers-01.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 7;
- int b = 13;
- int *p = &a;
- printf ("*p = %d\n", *p);
- p = &b;
- printf ("*p = %d\n", *p);
- return 0;
-}
diff --git a/20230116/pointers-01.pas b/20230116/pointers-01.pas
deleted file mode 100644
index 1fe7afcbee05de4cd407d232b019e0906931fe2e..0000000000000000000000000000000000000000
--- a/20230116/pointers-01.pas
+++ /dev/null
@@ -1,12 +0,0 @@
-program Pointers;
-
-var
- a: Integer = 7;
- b: Integer = 13;
- p: ^Integer = @a;
-
-begin
- WriteLn ('p^ = ', p^);
- p := @b;
- WriteLn ('p^ = ', p^)
-end.
diff --git a/20230116/pointers-02.c b/20230116/pointers-02.c
deleted file mode 100644
index b551c9c9911df26b7076ab833306b9715ea985b6..0000000000000000000000000000000000000000
--- a/20230116/pointers-02.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 7;
- int b = 13;
- int *p = &a;
- printf ("*p = %d\n", *p);
- *p = &b; /* falsch */
- printf ("*p = %d\n", *p);
- return 0;
-}
diff --git a/20230116/pointers-03.c b/20230116/pointers-03.c
deleted file mode 100644
index b330a5f6f3eafaed6cbdc608f98aee7652ecc13d..0000000000000000000000000000000000000000
--- a/20230116/pointers-03.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdio.h>
-
-int main (void)
-{
- int a = 7;
- int b = 13;
- int *p;
- p = &a;
- printf ("*p = %d\n", *p);
- *p = &b; /* falsch: Zuweisung der Speicheradresse von b an die Zahl a,
- weil p zu diesem Zeitpunkt auf a zeigt */
- printf ("*p = %d\n", *p);
- printf ("a = %d\n", a);
- return 0;
-}
diff --git a/20230116/struct-pointers-01.c b/20230116/struct-pointers-01.c
deleted file mode 100644
index 9837cbfbaa89bbab67cc31948927e637d6c3d84b..0000000000000000000000000000000000000000
--- a/20230116/struct-pointers-01.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- int a;
- int b;
-}
-data;
-
-int main (void)
-{
- data d;
- d.a = 7;
- d.b = 13;
- data *p = &d;
- printf ("*p = { %d, %d }\n", *p.a, *p.b);
- return 0;
-}
diff --git a/20230116/struct-pointers-02.c b/20230116/struct-pointers-02.c
deleted file mode 100644
index d6527ad8983e8db8f3b2a0f86416d577fd8dd85a..0000000000000000000000000000000000000000
--- a/20230116/struct-pointers-02.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- int a;
- int b;
-}
-data;
-
-int main (void)
-{
- data d;
- d.a = 7;
- d.b = 13;
- data *p = &d;
- printf ("*p = { %d, %d }\n", (*p).a, (*p).b);
- return 0;
-}
diff --git a/20230116/struct-pointers-03.c b/20230116/struct-pointers-03.c
deleted file mode 100644
index 2aebb0624adead6acfb2d0017587239faeee343d..0000000000000000000000000000000000000000
--- a/20230116/struct-pointers-03.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- int a;
- int b;
-}
-data;
-
-int main (void)
-{
- data d;
- d.a = 7;
- d.b = 13;
- data *p = &d;
- printf ("*p = { %d, %d }\n", p->a, p->b);
- return 0;
-}
diff --git a/20230116/struct-pointers-03.pas b/20230116/struct-pointers-03.pas
deleted file mode 100644
index 2c998ff1410a786ab03eaa39757971d4f5b14e05..0000000000000000000000000000000000000000
--- a/20230116/struct-pointers-03.pas
+++ /dev/null
@@ -1,17 +0,0 @@
-program StructPointers;
-
-type
- data = record
- a, b: Integer
- end;
-
-var
- d: data;
- p: ^data;
-
-begin
- d.a := 7;
- d.b := 13;
- p := @d;
- WriteLn ('p^ = { ', p^.a, ', ', p^.b, ' }')
-end.
diff --git a/20230116/struct-pointers-04.c b/20230116/struct-pointers-04.c
deleted file mode 100644
index ca2c30cffd0bac3a004d74d0cbf46ffe8e152674..0000000000000000000000000000000000000000
--- a/20230116/struct-pointers-04.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- int a;
- int b;
-}
-data;
-
-int main (void)
-{
- data d;
- d.a = 7;
- d.b = 13;
- printf ("d = { %d, %d }\n", d->a, d->b);
- return 0;
-}
diff --git a/20230116/struct-pointers-05.c b/20230116/struct-pointers-05.c
deleted file mode 100644
index d98b8f23fc7b88fc1570c32f336e6377d08f0340..0000000000000000000000000000000000000000
--- a/20230116/struct-pointers-05.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
- int a;
- int b;
-}
-data;
-
-int main (void)
-{
- data d;
- d.a = 7;
- d.b = 13;
- printf ("d = { %d, %d }\n", d.a, d.b);
- return 0;
-}
diff --git a/20220926/gitlab.png b/20231005/gitlab.png
similarity index 100%
rename from 20220926/gitlab.png
rename to 20231005/gitlab.png
diff --git a/20220926/hp-20220926-fig1.pdf b/20231005/hp-20231005-fig1.pdf
similarity index 100%
rename from 20220926/hp-20220926-fig1.pdf
rename to 20231005/hp-20231005-fig1.pdf
diff --git a/20220926/hp-20220926-fig1.tex b/20231005/hp-20231005-fig1.tex
similarity index 100%
rename from 20220926/hp-20220926-fig1.tex
rename to 20231005/hp-20231005-fig1.tex
diff --git a/20220926/hp-20220926.pdf b/20231005/hp-20231005.pdf
similarity index 97%
rename from 20220926/hp-20220926.pdf
rename to 20231005/hp-20231005.pdf
index 32fdcc7a48089797b5e787a4ce85c04f7127b265..bed537dad3781150e86ba681a4326a4d77eaba40 100644
Binary files a/20220926/hp-20220926.pdf and b/20231005/hp-20231005.pdf differ
diff --git a/20220926/hp-20220926.tex b/20231005/hp-20231005.tex
similarity index 97%
rename from 20220926/hp-20220926.tex
rename to 20231005/hp-20231005.tex
index a45414e946e0f83a58d9ad68cf20626a4c35a64e..bb6663dcc01b228d3261d87ee54c23a3b22c81d0 100644
--- a/20220926/hp-20220926.tex
+++ b/20231005/hp-20231005.tex
@@ -1,5 +1,5 @@
-% hp-20220926.pdf - Lecture Slides on Low-Level Programming
-% Copyright (C) 2012, 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
+% hp-20231005.pdf - Lecture Slides on Low-Level Programming
+% Copyright (C) 2012, 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Peter Gerwinski
%
% This document is free software: you can redistribute it and/or
% modify it either under the terms of the Creative Commons
@@ -41,7 +41,7 @@
\title{Hardwarenahe Programmierung}
\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
-\date{26.\ September 2022}
+\date{5.\ Oktober 2023}
\begin{document}
@@ -49,11 +49,11 @@
\date{\begin{picture}(0,0)
\color{red}
- \put(0.87,1.05){\makebox(0,0)[t]{$\underbrace{\rule{1.45cm}{0pt}}_{%
+ \put(0.55,1.05){\makebox(0,0)[t]{$\underbrace{\rule{1.45cm}{0pt}}_{%
\mbox{\emph{rerum naturalium\/} = der natürlichen Dinge (lat.)}}$}}
- \put(1.8,-3){\makebox(0,0)[bl]{\redurl{https://www.peter.gerwinski.de/physik/}}}
+ \put(1.55,-3){\makebox(0,0)[bl]{\redurl{https://www.peter.gerwinski.de/physik/}}}
\end{picture}%
- 26.\ September 2022}
+ 5.\ Oktober 2023}
\maketitleframe
@@ -86,13 +86,13 @@
\item
Notfall-Schnellzugang: \url{https://www.cvh-server.de/virtuelle-raeume/}\\
Seminarraum 2, VNC-Passwort: \lstinline[style=cmd]{testcvh}
- \smallskip
- \item
- Bei Problemen: bitte notieren:\\
- Art des Problems, genaue Uhrzeit, eigener Internet-Zugang
+% \smallskip
+% \item
+% Bei Problemen: bitte notieren:\\
+% Art des Problems, genaue Uhrzeit, eigener Internet-Zugang
\bigskip
\item
- GitLab: \url{https://gitlab.cvh-server.de/pgerwinski/hp}
+ \textbf{Lehrmaterialien:} \url{https://gitlab.cvh-server.de/pgerwinski/hp}
\end{itemize}
\end{frame}
@@ -319,7 +319,7 @@
\item
\textbf{Klausur:}
- Zeit: 150 Minuten
+ Zeit: 120 Minuten
Zulässige Hilfsmittel:
\begin{itemize}
@@ -330,12 +330,13 @@
\end{itemize}
\item
\textbf{Übungen}\\
- sind mit der Vorlesung integriert.
+ sind mit der Vorlesung und dem Praktikum integriert.
\item
Das \textbf{Praktikum}\\
findet jede Woche statt.\\
Diese Woche: vorbereitende Maßnahmen,\\
- Kennenlernen der verwendeten Werkzeuge
+ Kennenlernen der verwendeten Werkzeuge.\\
+ Im Laufe des Semesters: \textbf{4 Praktikumsversuche}
\end{itemize}
\end{frame}
diff --git a/20220926/logo-hochschule-bochum-cvh-text-v2.pdf b/20231005/logo-hochschule-bochum-cvh-text-v2.pdf
similarity index 100%
rename from 20220926/logo-hochschule-bochum-cvh-text-v2.pdf
rename to 20231005/logo-hochschule-bochum-cvh-text-v2.pdf
diff --git a/20220926/logo-hochschule-bochum.pdf b/20231005/logo-hochschule-bochum.pdf
similarity index 100%
rename from 20220926/logo-hochschule-bochum.pdf
rename to 20231005/logo-hochschule-bochum.pdf
diff --git a/20220926/pgscript.sty b/20231005/pgscript.sty
similarity index 100%
rename from 20220926/pgscript.sty
rename to 20231005/pgscript.sty
diff --git a/20220926/pgslides.sty b/20231005/pgslides.sty
similarity index 100%
rename from 20220926/pgslides.sty
rename to 20231005/pgslides.sty
diff --git a/README.md b/README.md
index 583ac081047ac170412f57d62da3988669520b2c..b1eee3dbc2a731dea96f2a312c6e91912b9d32e1 100644
--- a/README.md
+++ b/README.md
@@ -1,108 +1,74 @@
Hardwarenahe Programmierung
===========================
-Lehrveranstaltung im Wintersemester 2022/23
+Lehrveranstaltung im Wintersemester 2023/24
Hochschule Bochum, Campus Velbert/Heiligenhaus
Prof. Dr. rer. nat. Peter Gerwinski
-Copyright © 2012–2022 Peter Gerwinski
+Copyright © 2012–2023 Peter Gerwinski
**Diese Lehrmaterialien sind freie Software.**
Sie dürfen diese gemäß den jeweils angegebenen Lizenzen
-([CC-BY-SA 3.0](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/common/CC-BY-SA-3.0),
-[GNU GPL 3+](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/common/GNU-GPL-3),
-[modified BSD License](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/common/BSD-MODIFIED))
+([CC-BY-SA 3.0](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/common/CC-BY-SA-3.0),
+[GNU GPL 3+](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/common/GNU-GPL-3),
+[modified BSD License](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/common/BSD-MODIFIED))
studieren, kopieren, modifizieren und/oder weitergeben.
-Für Details siehe [common/README](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/common/README).
+Für Details siehe [common/README](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/common/README).
Vortragsfolien und Beispiele:
-----------------------------
- * [26.09.2022: Einführung, Einführung in C (bis Seiteneffekte)](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20220926/hp-20220926.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/20220926/)
- * [10.10.2022: Funktionen, Zeiger, Arrays und Strings](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221010/hp-20221010.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/20221010/)
- * [17.10.2022: Strukturen, Dateien und Fehlerbehandlung, Parameter des Hauptprogramms, String-Operationen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221017/hp-20221017.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/20221017/)
- * [24.10.2022: Bibliotheken](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221024/hp-20221024.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/20221024/)
- * [31.10.2022: Callback-Funktionen, make, Bit-Operationen, I/O-Ports](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221031/hp-20221031.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/20221031/)
- * [07.11.2022: Interrupts, volatile-Variable, Endianness](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221107/hp-20221107.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/20221107/)
- * [14.11.2022: Binärdarstellung negativer Zahlen, Alignment, Differentialgleichungen, Rekursion](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221114/hp-20221114.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/20221114/)
- * [21.11.2022: Aufwandsabschätzungen, Objektorientierte Programmierung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221121/hp-20221121.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/20221121/)
- * [28.11.2022: Objektorientierte Programmierung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221128/hp-20221128.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/20221128/)
- * [05.12.2022: Objektorientierte Programmierung, Datenstrukturen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221205/hp-20221205.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/20221205/)
- * [19.12.2022: Objektorientierte Programmierung, Datenstrukturen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221219/hp-20221219.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/20221219/)
- * [alle in 1 Datei](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/hp-slides-2022ws.pdf)
+ * [05.10.2023: Einführung, Einführung in C (bis Seiteneffekte)](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231005/hp-20231005.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws/20231005/)
+ * [alle in 1 Datei](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/hp-slides-2023ws.pdf)
Übungsaufgaben:
---------------
- * [26.09.2022: Hello-World-Programme, Schaltjahr ermitteln, Maximum berechnen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20220926/hp-uebung-20220926.pdf)
- * [10.10.2022: Schaltjahr ermitteln, Multiplikationstabelle, Fibonacci-Zahlen, fehlerhaftes Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221010/hp-uebung-20221010.pdf)
- * [17.10.2022: Seltsame Programme, Kalender-Berechnung, Strings, Programm analysieren](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221017/hp-uebung-20221017.pdf)
- * [24.10.2022: Arrays mit Zahlen, Datum-Bibliothek, fehlerhaftes Primzahl-Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221024/hp-uebung-20221024.pdf)
- * [31.10.2022: Zahlensysteme, Mikrocontroller, Einfügen in Strings](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221031/hp-uebung-20221031.pdf)
- * [07.11.2022: Ausgabe von Hexadezimalzahlen, Länge von Strings, LED-Blinkmuster](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221107/hp-uebung-20221107.pdf)
- * [14.11.2022: Trickprogrammierung, Thermometer-Baustein an I²C-Bus, Speicherformate von Zahlen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221114/hp-uebung-20221114.pdf)
- * [21.11.2022: Kondensator, Personen-Datenbank, Fakultät](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221121/hp-uebung-20221121.pdf)
- * [28.11.2022: Einfügen in Strings (Ergänzung), dynamisches Bit-Array, objektorientierte Tier-Datenbank](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221128/hp-uebung-20221128.pdf)
- * [05.12.2022: Objektorientierte Tier-Datenbank (Ergänzung), Iterationsfunktionen, Stack-Operationen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221205/hp-uebung-20221205.pdf)
- * [12.12.2022: Länge von Strings (Neuauflage), Text-Grafik-Bibliothek, PBM-Grafik](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221212/hp-uebung-20221212.pdf)
- * [09.01.2023: Einfach und doppelt verkettete Listen, ternärer Baum, hüpfender Ball, Hexdumps](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20230109/hp-uebung-20230109.pdf)
+(kommen noch)
Musterlösungen:
---------------
- * [10.10.2022: Schaltjahr ermitteln, Multiplikationstabelle, Fibonacci-Zahlen, fehlerhaftes Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221010/hp-musterloesung-20221010.pdf)
- * [17.10.2022: Seltsame Programme, Kalender-Berechnung, Strings, Programm analysieren](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221017/hp-musterloesung-20221017.pdf)
- * [24.10.2022: Arrays mit Zahlen, Datum-Bibliothek, fehlerhaftes Primzahl-Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221024/hp-musterloesung-20221024.pdf)
- * [31.10.2022: Zahlensysteme, Mikrocontroller, Einfügen in Strings](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221031/hp-musterloesung-20221031.pdf)
- * [07.11.2022: Ausgabe von Hexadezimalzahlen, Länge von Strings, LED-Blinkmuster](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221107/hp-musterloesung-20221107.pdf)
- * [14.11.2022: Trickprogrammierung, Thermometer-Baustein an I²C-Bus, Speicherformate von Zahlen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221114/hp-musterloesung-20221114.pdf)
- * [21.11.2022: Kondensator, Personen-Datenbank, Fakultät](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221121/hp-musterloesung-20221121.pdf)
- * [28.11.2022: Einfügen in Strings (Ergänzung), dynamisches Bit-Array, objektorientierte Tier-Datenbank](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221128/hp-musterloesung-20221128.pdf)
- * [05.12.2022: Objektorientierte Tier-Datenbank (Ergänzung), Iterationsfunktionen, Stack-Operationen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221205/hp-musterloesung-20221205.pdf)
- * [12.12.2022: Länge von Strings (Neuauflage), Text-Grafik-Bibliothek, PBM-Grafik](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221212/hp-musterloesung-20221212.pdf)
- * [09.01.2023: Einfach und doppelt verkettete Listen, ternärer Baum, hüpfender Ball, Hexdumps](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20230109/hp-musterloesung-20230109.pdf)
+(kommen noch)
Praktikumsunterlagen:
---------------------
- * [Versuch 1: RSA-Verschlüsselung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221006/hp-2022ws-p1.pdf)
- * [Versuch 2: Druckknopfampel](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221031/hp-2022ws-p2.pdf)
- * [Versuch 3: Weltraum-Simulation](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221114/hp-2022ws-p3.pdf)
- * [Versuch 4: Objektorientiertes Grafik-Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/20221205/hp-2022ws-p4.pdf)
+(kommen noch)
Alte Klausuren:
---------------
- * [Wintersemester 2015/16](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/exams/20160129/ainf-klausur-20160129.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/exams/20160129/)
- * [Wintersemester 2016/17](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/exams/20170206/hp-klausur-20170206.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/exams/20170206/)
- * [Wintersemester 2017/18](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/exams/20180213/hp-klausur-20180213.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/exams/20180213/)
+ * [Wintersemester 2015/16](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/exams/20160129/ainf-klausur-20160129.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws/exams/20160129/)
+ * [Wintersemester 2016/17](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/exams/20170206/hp-klausur-20170206.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws/exams/20170206/)
+ * [Wintersemester 2017/18](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/exams/20180213/hp-klausur-20180213.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws/exams/20180213/)
Skript:
-------
- * [Hardwarenahe Programmierung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/script/hp-2022ws.pdf)
+ * [Hardwarenahe Programmierung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/script/hp-2023ws.pdf)
Original-Materialien einschließlich Beispiel-Programme und LaTeX-Quelltexte:
----------------------------------------------------------------------------
- * [common – gemeinsame Dateien für Skript und Vortragsfolien](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/common)
- * [script – Skript zur Lehrveranstaltung](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/script)
- * [202????? – Vortragsfolien und Beispiele](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws)
- * [branch 2021ws – vollständige Lehrmaterialien vom Wintersemester 2021/22](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2021ws)
+ * [common – gemeinsame Dateien für Skript und Vortragsfolien](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws/common)
+ * [script – Skript zur Lehrveranstaltung](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws/script)
+ * [202????? – Vortragsfolien und Beispiele](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws)
+ * [branch 2022ws – vollständige Lehrmaterialien vom Wintersemester 2022/23](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws)
Low-Level Programming
=====================
-Course in winter semester 2022-23
+Course in winter semester 2023-24
Bochum University of Applied Sciences, Campus Velbert/Heiligenhaus
Prof. Dr. rer. nat. Peter Gerwinski
-Copyright © 2012–2022 Peter Gerwinski
+Copyright © 2012–2023 Peter Gerwinski
**These teaching materials are Free Software.**
You may study, copy, modify, and/or distribute them
according to their respective licences
-([CC-BY-SA 3.0](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/common/CC-BY-SA-3.0),
-[GNU GPL 3+](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/common/GNU-GPL-3),
-[modified BSD License](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/common/BSD-MODIFIED)).
-See the file [common/README](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/common/README) for details.
-
- * [common – common files for lecture notes and slides](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/common)
- * [script – lecture notes](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/script)
- * [202????? – slides and examples](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws)
- * [hp-slides-2022ws.pdf – all slides in 1 file](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2022ws/hp-slides-2022ws.pdf)
- * [branch 2021ws – complete teaching materials from winter semester 2021-22](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2021ws)
+([CC-BY-SA 3.0](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/common/CC-BY-SA-3.0),
+[GNU GPL 3+](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/common/GNU-GPL-3),
+[modified BSD License](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/common/BSD-MODIFIED)).
+See the file [common/README](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/common/README) for details.
+
+ * [common – common files for lecture notes and slides](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws/common)
+ * [script – lecture notes](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws/script)
+ * [202????? – slides and examples](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws)
+ * [hp-slides-2023ws.pdf – all slides in 1 file](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/hp-slides-2023ws.pdf)
+ * [branch 2022ws – complete teaching materials from winter semester 2022-23](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws)
diff --git a/hp-slides-2022ws.pdf b/hp-slides-2022ws.pdf
deleted file mode 100644
index 0cb2dca473c2d72ab105466ba6de05d0a9ff66d0..0000000000000000000000000000000000000000
Binary files a/hp-slides-2022ws.pdf and /dev/null differ
diff --git a/hp-slides-2022ws.tex b/hp-slides-2022ws.tex
deleted file mode 100644
index 75e83d9d1c5254640c356c866c1f9ce0a78aa303..0000000000000000000000000000000000000000
--- a/hp-slides-2022ws.tex
+++ /dev/null
@@ -1,36 +0,0 @@
-\documentclass{article}
-
-\usepackage[final]{pdfpages}
-\usepackage[paperwidth=363pt,paperheight=272pt]{geometry}
-\usepackage{hyperref}
-\usepackage[utf8]{luainputenc} % Without this, umlauts are broken. Weird.
-
-\pagestyle{empty}
-
-\begin{document}
- \includepdf[pages=1]{script/hp-slides-title-2022ws.pdf}
- \pdfbookmark[1]{Wichtiger Hinweis}{Hinweis}
- \includepdf[pages=2-]{script/hp-slides-title-2022ws.pdf}
- \pdfbookmark[1]{26.09.2022: Einführung, Einführung in C (bis Seiteneffekte)}{20220926}
- \includepdf[pages=-]{20220926/hp-20220926.pdf}
- \pdfbookmark[1]{10.10.2022: Funktionen, Zeiger, Arrays und Strings}{20221010}
- \includepdf[pages=-]{20221010/hp-20221010.pdf}
- \pdfbookmark[1]{17.10.2022: Strukturen, Dateien und Fehlerbehandlung, Parameter des Hauptprogramms, String-Operationen}{20221017}
- \includepdf[pages=-]{20221017/hp-20221017.pdf}
- \pdfbookmark[1]{24.10.2022: Bibliotheken}{20221024}
- \includepdf[pages=-]{20221024/hp-20221024.pdf}
- \pdfbookmark[1]{31.10.2022: Callback-Funktionen, make, Bit-Operationen, I/O-Ports}{20221031}
- \includepdf[pages=-]{20221031/hp-20221031.pdf}
- \pdfbookmark[1]{07.11.2022: Interrupts, volatile-Variable, Endianness}{20221107}
- \includepdf[pages=-]{20221107/hp-20221107.pdf}
- \pdfbookmark[1]{14.11.2022: Binärdarstellung negativer Zahlen, Alignment, Differentialgleichungen, Rekursion}{20221114}
- \includepdf[pages=-]{20221114/hp-20221114.pdf}
- \pdfbookmark[1]{21.11.2022: Aufwandsabschätzungen, Objektorientierte Programmierung}{20221121}
- \includepdf[pages=-]{20221121/hp-20221121.pdf}
- \pdfbookmark[1]{28.11.2022: Objektorientierte Programmierung}{20221128}
- \includepdf[pages=-]{20221128/hp-20221128.pdf}
- \pdfbookmark[1]{05.12.2022: Objektorientierte Programmierung, Datenstrukturen}{20221205}
- \includepdf[pages=-]{20221205/hp-20221205.pdf}
- \pdfbookmark[1]{12.12.2022: Objektorientierte Programmierung, Datenstrukturen}{20221212}
- \includepdf[pages=-]{20221212/hp-20221212.pdf}
-\end{document}
diff --git a/hp-slides-2023ws.pdf b/hp-slides-2023ws.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..8f8a0d808345b3f03d9fe6505e28bde6ec3eb42c
Binary files /dev/null and b/hp-slides-2023ws.pdf differ
diff --git a/hp-slides-2023ws.tex b/hp-slides-2023ws.tex
new file mode 100644
index 0000000000000000000000000000000000000000..bb92eb9cc664dbbfdf1fb0bf85789c086062882e
--- /dev/null
+++ b/hp-slides-2023ws.tex
@@ -0,0 +1,16 @@
+\documentclass{article}
+
+\usepackage[final]{pdfpages}
+\usepackage[paperwidth=363pt,paperheight=272pt]{geometry}
+\usepackage{hyperref}
+\usepackage[utf8]{luainputenc} % Without this, umlauts are broken. Weird.
+
+\pagestyle{empty}
+
+\begin{document}
+ \includepdf[pages=1]{script/hp-slides-title-2023ws.pdf}
+ \pdfbookmark[1]{Wichtiger Hinweis}{Hinweis}
+ \includepdf[pages=2-]{script/hp-slides-title-2023ws.pdf}
+ \pdfbookmark[1]{05.10.2023: Einführung, Einführung in C (bis Seiteneffekte)}{20231005}
+ \includepdf[pages=-]{20231005/hp-20231005.pdf}
+\end{document}
diff --git a/script/hp-2022ws.pdf b/script/hp-2023ws.pdf
similarity index 100%
rename from script/hp-2022ws.pdf
rename to script/hp-2023ws.pdf
diff --git a/script/hp-2022ws.tex b/script/hp-2023ws.tex
similarity index 100%
rename from script/hp-2022ws.tex
rename to script/hp-2023ws.tex
diff --git a/script/hp-slides-title-2022ws.pdf b/script/hp-slides-title-2023ws.pdf
similarity index 79%
rename from script/hp-slides-title-2022ws.pdf
rename to script/hp-slides-title-2023ws.pdf
index fd5eb1d8f940986e7f3260f63ebe5e9fa8f47e36..ad596dbac825aad38baca39f0b0355b2fe841eb9 100644
Binary files a/script/hp-slides-title-2022ws.pdf and b/script/hp-slides-title-2023ws.pdf differ
diff --git a/script/hp-slides-title-2022ws.tex b/script/hp-slides-title-2023ws.tex
similarity index 89%
rename from script/hp-slides-title-2022ws.tex
rename to script/hp-slides-title-2023ws.tex
index 73b501a12ae87034e70b5a30eb4d2ec646c7e769..a74a2acca28e52b0e2834f34442c6601c0a58ef4 100644
--- a/script/hp-slides-title-2022ws.tex
+++ b/script/hp-slides-title-2023ws.tex
@@ -1,5 +1,5 @@
-% hp-slides-title-2022ws.pdf - Title Page for Lecture Slides on Low-Level Programming
-% Copyright (C) 2018, 2019, 2020, 2021, 2022 Peter Gerwinski
+% hp-slides-title-2023ws.pdf - Title Page for Lecture Slides on Low-Level Programming
+% Copyright (C) 2018, 2019, 2020, 2021, 2022, 2023 Peter Gerwinski
%
% This document is free software: you can redistribute it and/or
% modify it either under the terms of the Creative Commons
@@ -28,7 +28,7 @@
\title{Hardwarenahe Programmierung}
\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
-\date{Wintersemester 2022/23}
+\date{Wintersemester 2023/24}
\begin{document}
@@ -59,8 +59,8 @@
(\url{https://gitlab.cvh-server.de/pgerwinski/hp.git})
mit allen Zwischenschritten enthalten und befinden sich
in den zu den jeweiligen Kalenderdaten gehörenden Verzeichnissen
- (z.\,B.\ für den 4.\,10.\,2021 unter
- \url{https://gitlab.cvh-server.de/pgerwinski/hp/tree/2021ws/20211004/}\kern1pt).
+ (z.\,B.\ für den 5.\,10.\,2023 unter
+ \url{https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws/20231005/}\kern1pt).
Wenn Sie die Übungsaufgaben bearbeiten, nutzen Sie die Gelegenheit,
Ihre Lösungen in den Übungen überprüfen zu lassen.
diff --git a/update b/update
index 1aee5f72410e13a8c1d5e573a138bc7e1978fdc7..18e0bcf58df13248d230af6c54a519745b1dc371 100755
--- a/update
+++ b/update
@@ -1,6 +1,6 @@
#!/bin/bash
-sem=2022ws
+sem=2023ws
course=hp
date_mask="20[12][0-9][01][0-9][0-3][0-9]"
@@ -52,7 +52,7 @@ EOF
exit 1
}
- rm -f hp-slides-2022ws.{aux,log,out}
+ rm -f hp-slides-2023ws.{aux,log,out}
echo
fi
@@ -118,11 +118,11 @@ cat > $readme << EOF
Hardwarenahe Programmierung
===========================
-Lehrveranstaltung im Wintersemester 2022/23
+Lehrveranstaltung im Wintersemester 2023/24
Hochschule Bochum, Campus Velbert/Heiligenhaus
Prof. Dr. rer. nat. Peter Gerwinski
-Copyright © 2012–2022 Peter Gerwinski
+Copyright © 2012–2023 Peter Gerwinski
**Diese Lehrmaterialien sind freie Software.**
Sie dürfen diese gemäß den jeweils angegebenen Lizenzen
@@ -156,17 +156,17 @@ Original-Materialien einschließlich Beispiel-Programme und LaTeX-Quelltexte:
* [common – gemeinsame Dateien für Skript und Vortragsfolien](https://gitlab.cvh-server.de/pgerwinski/hp/tree/$sem/common)
* [script – Skript zur Lehrveranstaltung](https://gitlab.cvh-server.de/pgerwinski/hp/tree/$sem/script)
* [202????? – Vortragsfolien und Beispiele](https://gitlab.cvh-server.de/pgerwinski/hp/tree/$sem)
- * [branch 2021ws – vollständige Lehrmaterialien vom Wintersemester 2021/22](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2021ws)
+ * [branch 2022ws – vollständige Lehrmaterialien vom Wintersemester 2022/23](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws)
Low-Level Programming
=====================
-Course in winter semester 2022-23
+Course in winter semester 2023-24
Bochum University of Applied Sciences, Campus Velbert/Heiligenhaus
Prof. Dr. rer. nat. Peter Gerwinski
-Copyright © 2012–2022 Peter Gerwinski
+Copyright © 2012–2023 Peter Gerwinski
**These teaching materials are Free Software.**
You may study, copy, modify, and/or distribute them
@@ -179,8 +179,8 @@ See the file [common/README](https://gitlab.cvh-server.de/pgerwinski/hp/raw/$sem
* [common – common files for lecture notes and slides](https://gitlab.cvh-server.de/pgerwinski/hp/tree/$sem/common)
* [script – lecture notes](https://gitlab.cvh-server.de/pgerwinski/hp/tree/$sem/script)
* [202????? – slides and examples](https://gitlab.cvh-server.de/pgerwinski/hp/tree/$sem)
- * [hp-slides-2022ws.pdf – all slides in 1 file](https://gitlab.cvh-server.de/pgerwinski/hp/raw/$sem/hp-slides-2022ws.pdf)
- * [branch 2021ws – complete teaching materials from winter semester 2021-22](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2021ws)
+ * [hp-slides-2023ws.pdf – all slides in 1 file](https://gitlab.cvh-server.de/pgerwinski/hp/raw/$sem/hp-slides-2023ws.pdf)
+ * [branch 2022ws – complete teaching materials from winter semester 2022-23](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws)
EOF
if diff -wu $readme_old $readme; then