Programmierkurs für das modularisierte Lehramt

Programmierkurs für das modularisierte Lehramt
September 2011, 4. Vorlesung
Stuttgart, den 16. September 2011
Dr. Heiko Schulz
Universität Stuttgart, Fachbereich Mathematik
Hauptquellen:
L
Programmierkurs C für Bachelor (H. Schulz, H. Harbrecht, F.
Eenberger, B. Wohlmuth...),
L
Vorlesung Mathematik am Computer 2008/09 (H. Schulz, J.
Mayer),
L
Sonderheft ct Programmieren.
Rückschau
Matlab...
L
Grundlegendes, Erzeugen von Vektoren und Matrizen,
L
elementweise Operationen, Matrixoperatoren,
L
Lösen linearer Gleichungssysteme,
L
eigene Scripte,
L
Scripte und Funktionen,
L
Schleifen, bedingte Anweisungen,
L
Beispiel: game of life,
L
Grak: Veranschaulichung von Daten, Plotten von Funktionen.
2
Plotten von Funktionen zweier Veränderlicher
Aufgabe: Plotte
f ˆx, y 
x > 0, 1
x2 y,
y > 0, 1.
2
z
z
1
0
1
1
0.5
y
0.5
0
0
x
3
Funktionen zweier Veränderlichen Plotten
Es werden Matrizen
Auswertung von
X
und
Y
Y
4
benötigt, so dass die elementweise
X
und
’
–
”
0 0.5 1
0 0.5 1
0 0.5 1
eine Matrix
Z
mit den Funktionswerten liefert,
z.B.
X
ergibt für
z
f ˆx, y 
“
—
•
Y
’
–
”
0
0
0
0.5 0.5 0.5
1
1
1
x2 y
Z
’
–
”
0 0.25 1
0.5 0.75 1.5
1 1.25 2
“
—
•
“
—
•
Funktionen zweier Veränderlichen Plotten
5
Vorgehensweise
L
X und Y , z.B.
[X,Y] = meshgrid(0:0.1:1, 0:0.1:1);
Erzeuge Matrizen
Genauer: sind
Funktion
f
x
und
y
Vektoren der
x-
bzw.
y -Werte
X und Y erzeugt durch:
[X,Y] = meshgrid(x,y);
L Erzeuge Matrizen Z der Funktionswerte,
Z = X.2+Y;
Matrizen
L
bei denen die
ausgewertet werden soll, so werden die benötigten
Plotte Funktion
surf(X,Y,Z);
z.B.
Plotoptionen und Modizierung von Graphen
L
Modizierung der Schattierung:
shading faceted
shading interp
L
shading flat
Modizierung der Axen:
axis([xmin xmax ymin ymax])
axis equal und viele mehr
L
Beschriftung:
title('Überschrift')
xlabel('x-Achse')
L
Weitere Modizierungen direkt am Graphen möglich!
6
Funktionen zweier Veränderlichen Plotten
Weitere Möglichkeiten:
L
Fläche ohne Gitter:
surf(X,Y,Z, 'EdgeColor', 'none');
L
beleuchtete Fläche:
surfl(X,Y,Z);
L
Nur Gitter:
mesh(X,Y,Z);
L
Höhenlinien:
contour(X,Y,Z);
L
Schattierte Karte:
pcolor(X,Y,Z);
7
Weitere Plotmöglichkeiten
L
8
Plotten von (parametrisierten) Kurven im Raum
plot3(X,Y,Z);
L
Plotten von 2D-Vektorfeldern, d.h.
von Funktionen
D b R2
Ð
R2
mit
ˆx, y 
( ˆu, v 
quiver(x,y,u,v)
L
Plotten von 3D-Vektorfeldern, d.h.
von Funktionen
D b R3
Ð
R3
mit
quiver3(x,y,z,u,v,w)
ˆx, y , z 
( ˆu, v , w 
Globale Variablen
L
Variablen, die direkt im Command Window oder durch eine
Befehlsabfolge in einem Skript deniert werden, sind global.
Auf diese Variablen kann vom Command Window und von jedem
Skript zugegrien werden.
Die Variablen und ihre Werte existieren so lange, bis diese gelöscht
oder geändert werden.
9
Lokale Variablen
L
Variablen in Funktionen sind lokal.
Sie sind nur innerhalb dieser Funktion bekannt.
Sobald die der Funktionsaufruf endet, werden die Variablen und
ihre Werte gelöscht.
L
Funktionen kennen keine globalen Variablen, deswegen:
L
L
L
können Funktionen, keine globalen Variablen modizieren,
müssen alle benötigten Werte als Parameter übergeben werden,
müssen alle nach Ende des Funktionsaufruf weiter benötigten Werte
als Rückgabewerte zurückgegeben werden.
10
Funktionen als Parameter
11
Ein Verfahren hängt oft von einer Funktion
f
ab, die variiert, z.B.
L
Verfahren zur Bestimmung einer Nullstelle
L
Verfahren zur Berechnung eines Integrals
S
L
x‡
mit
f ˆx ‡ 
0,
b
a
f ˆx  dx,
Spezielle graphische Methoden zur Visualisierung von
f.
Problem: Es können nur Variablen an Funktionen übergeben werden,
nicht Funktionen selbst!
Funktionen als Parameter
12
Lösung: Mache aus der Funktion eine Variable:
Ist
f
eine Matlab-Funktion, so ist
heiÿt Handle (Gri ) der Funktion
@f,
f
der Zahlenwert der Funktion. Er
Das Handle kann in einer Variablen abgespeichert werden und/oder als
Wert an eine weitere Funktion übergeben werden.
function S = p_summe(f,n,N)
function y=g(x)
y = 1./(x.2);
S=0;
for i = n:N
S = S + f(i);
end
Funktionen als Parameter
Der Aufruf
p_summe(@g,1,100)
13
berechnet
Q i1 .
100
i 1
2
Weitere Möglichkeiten:
L
Handles können in Variablen abgespeichert werden:
s = @sin
L
oder
handle_g = @g
Es können auch Handles direkt deniert und abgespeichert werden:
s = @(x) 2*x+1;
speichert die Funktion x ( 2x 1
s(3) ergibt 7.
in der Variablen
s
ab. Der Aufruf
Speicherverwaltung in Matlab
14
Speicherverwaltung
L
Um z.B. auf einen Matrixeintrag
A(2,3:6)
zuzugreifen, muss die
Matrix mindestens die Gröÿe 26 besitzen und entsprechend
vorher deniert werden, z.B. als A = zeros(2,10).
L
Wenn man auf
A(2,3:6)
zugreift, ohne die Matrix vorher zu
denieren oder falls sie zu klein ist, wird sie automatisch als
Nullmatrix der notwendigen Gröÿe angelegt oder entsprechend
vergröÿert. Trotzdem sollte man die Matrix vorher selbst
denieren, weil:
L
L
L
die Gröÿenanpassung sehr viel Laufzeit kostet,
die Denition der Matrixgröÿe am Anfang besserer Programmierstil
ist.
Der Speicher nicht mehr benötigter Variablen wird durch
clear
freigegeben.
oder
clear
Variablename
Vektorisierung
15
Es gibt (mindestens) zwei Möglichkeiten, den Vektor
v
‰
1
2 3
4
999
1000
Ž
zu erzeugen:
v = 1:1000;
for i = 1:500
v(2*i) = -v(2*i);
end
v = 1:1000;
v(2:2:1000) = -v(2:2:1000);
Die
zweite
verwendet
Möglichkeit
statt
Schlei-
fen die vektorielle Rechnung
oder
Vektorisie-
rung. Das ist viel schneller!
Beispiel: Das Bisektionsverfahren
16
Der Zwischenwertsatz für Nullstellenbestimmung
Sei
f
a, b
Ð
R
stetig mit
f ˆaf ˆb @ 0,
d.h.
f ˆa 
und
f ˆb 
haben
unterschiedliche Vorzeichen. Dann existiert nach dem Zwischenwertsatz
(mindestens) eine Nullstelle
ξ > ˆa, b
a
von
f,
d.h. es gilt
b
f ˆξ 
0.
Beispiel: Das Bisektionsverfahren
17
Idee des Verfahrens
Sei
f
a, b
Ð
R
stetig mit
f ˆaf ˆb @ 0.
Das Bisektionsverfahren berechnet zu vorgebenen
Länge höchstens
ε,
welches eine Nullstelle von
ab mit einer (exakten) Nullstelle von
f
εA0
ein Intervall mit
enthält oder es bricht
f.
Idee: Halbiere a, b, schaue in welcher Hälfte eine Nullstelle von f
liegt
muss. Halbiere sukzessive weiter bis die Intervalllänge hinreichend klein
ist.
Beispiel: Das Bisektionsverfahren
a
b
18
a
c
b
Das Bisektionsverfahren
Falls
f ˆaf ˆb C 0:
Wiederhole solange
Falls
Abbruch.
b a C ε:
ab
2
f ˆc  0: c
Setze:
c
ist Lösung. Abbruch.
Falls Vorzeichen von
Falls Vorzeichen von
Ende
19
f ˆc 
f ˆc 
und
und
f ˆa 
f ˆb 
gleich: setze
gleich: setze
a c
b c
Das Bisektionsverfahren: bisektionsverfahren.m
bisektionsverfahren.m:
function [ a , b ] = b i s e k t i o n s v e r f a h r e n ( f , a , b , e p s i l o n ) ;
i f f ( a ) * f ( b ) >= 0 | b<=a
end
d i s p l a y ( [ ' V o r a u s s e t z u n g e n n i c h t e r f u e l l t ! Abbruch .
' ]) ;
;
return
20
Das Bisektionsverfahren: bisektionsverfahren.m
while b a >= e p s i l o n
c = ( a+b ) / 2 ;
i f f ( c ) == 0
a=c ;
b=c ;
end
return
e l s e i f f ( c ) * f ( a ) >0
a=c ;
e l s e i f f ( c ) * f ( b ) >0
b=c ;
end
21
Zusatzmodule: Toolboxen in Matlab
Anzeigen der Matlabversion und aller verfügbaren Toolboxen mit dem
Befehl
ver.
L
Simulink
L
Bioinformatics Toolbox
L
Communications Blockset
L
Communications Toolbox
L
Control System Toolbox
L
Curve Fitting Toolbox
L
Database Toolbox
L
EDA Simulator Link IN
L
Filter Design Toolbox
L
Fixed-Point Toolbox
L
Fuzzy Logic Toolbox
L
Genetic Algorithm and Direct Search Toolbox
22
Zusatzmodule: Toolboxen in Matlab
L
Image Processing Toolbox
L
Instrument Control Toolbox
L
MATLAB Compiler
L
Neural Network Toolbox
L
Optimization Toolbox
L
Parallel Computing Toolbox
L
Partial Dierential Equation Toolbox
L
Real-Time Workshop
L
Robust Control Toolbox
L
Signal Processing Blockset
L
Signal Processing Toolbox
L
SimDriveline
L
SimElectronics
L
imMechanics
L
SimPowerSystems
23
Zusatzmodule: Toolboxen in Matlab
L
Simscape
L
Simulink 3D Animation
L
Simulink Control Design
L
Simulink Design Optimization
L
Simulink Fixed Point
L
Simulink HDL Coder
L
Simulink Verication and Validation
L
Spline Toolbox
L
Stateow
L
Stateow Coder
L
Statistics Toolbox
L
Symbolic Math Toolbox
L
System Identication Toolbox
L
Wavelet Toolbox
24
Abschlieÿende Bemerkungen zu Matlab
L
25
Für Ingenieure ist Matlab ohne Toolboxen wie ein Auto ohne
Räder.
L
Aber: Jede Toolbox kostet (extra) Geld.
L
Objektorientiertes Programmieren ist möglich.
L
Hier am Studpool: oating license.
L
An der Uni Stuttgart gibt es für jeden Studierenden eine kostenlose
Studentenversion (Studiengebühren...).
Die Programmiersprache C
L
C ist eine imperative Hochsprache, weit verbreitet.
L
C wurde 1972 von Dennis M. Ritchie in den Bell-Laboratorien bei
26
AT&T entwickelt.
L
Vorgänger: B (1969), BCPL (Basic Combined Programming
Language, 1966).
L
Unix/Linux wurde beinahe vollständig in C geschrieben.
L
Weiterentwicklung durch Brian W. Kernighan in den 1970er Jahren.
L
1978: The C Programming Language von B. W. Kernighan und
D. M. Ritchie, diente lange Zeit als Denition von C.
L
1989: ANSI-Standard C89 (ANSI = American National Standards
Institute).
L
1999: ISO-Standard C99 (ISO = International Organization for
Standardization).
Vom Quelltext zum ausführbaren Programm
L
Übersetzung durch Compiler: Quelltext (für Menschen lesbar,
kommentiert)
Ô
Maschinencode (Instruktionen für den
Hauptprozessor, nicht ohne weiteres für Menschen lesbar).
L
Vor der Übersetzung ruft der Compiler automatisch den
Präprozessor auf. Direktiven des Präprozessors:
#ifdef: Bedingtes Compilieren
#include: Einlesen von Dateien vor dem eigentlichen Compilieren.
#dene: Denition von symbolischen Konstanten und Makros.
L
Der Compiler kann Bibliotheken einbinden, in denen andere
(Teil-)Algorithmen bereits implementiert sind.
27
C-Programme I
L
28
C-Programme werden von oben nach unten und von links nach
rechts gelesen, bestehen aus Blöcken, welche durch {. . . }
abgegrenzt werden. Blöcke bestehen aus Anweisungen, welche
durch ein Semikolon abgetrennt werden. Leerzeichen und
Zeilenumbrüche werden ignoriert (dienen aber der Lesbarkeit).
L
Ein C-Programm wird mit einem beliebigen Texteditor geschrieben
und der Quelltext dann mithilfe eines Compilers in eine dem
Computer verständliche Form (Maschinencode) übersetzt.
L
Quelltext kann Kommentare enthalten, welche der Computer
ignoriert.
//
/
*
der
alles
ist
L
Rest
dieser
innerhalb
ein
Zeile
dieses
Kommentar
ist
ein
Kommentar
Blocks
*/
Die Sprache beinhaltet Schlüsselwörter, welchen eine bestimmte
Bedeutung zukommt.
C-Programme II
L
Es können Variablen und Funktionen deniert werden.
L
Variable = Speicherbereich, a-priori also Binärzahl.
L
Wichtig ist die Typisierung (ganze Zahlen, Zeichenketten, etc.).
L
Viele C-Programme beginnen mit den Zeilen: #include <. . . >
L
Anweisung an Präprozessor / Compiler, gewisse Bibliotheken
einzubinden.
L
Bibliothek = Sammlung von vorgefertigten Funktionen, z.B. für
Mathematik, Grak, etc.
L
Funktion = Funktionseinheit eines Programms, welche einen
Namen und einen (zumindestens formalen) Rückgabewert hat und
immer wieder verwendet werden kann.
L
Beispiel: Ausgabe einer Zeichenkette auf dem Bildschirm,
Berechnung der Quadratwurzel einer Zahl, . . .
29
Ein- und Ausgabe von Daten
L
Problem: wie kommen die Daten in und aus dem Programm?
L
Lösung: Ein- und Ausgabe über Tastatur, Dateien, etc. pp.
L
Oft benötigt: Ausgabe von Nachrichten auf dem Bildschirm.
Funktion hierzu:
p r i n t f ( " H a l l o Welt ! " ) ;
Diese wird von der Bibliothek stdio (Standard Input/Output) zur
Verfügung gestellt.
30
Ein erstes C-Programm
L
31
Ein lauähiges Programm:
/
*
hello . c
/
*
hier
*/
#include < s t d i o . h>
int main ( ) {
p r i n t f ( " H a l l o Welt ! \ n" ) ;
return 0 ;
}
ist
Schluss
*/
L
Bibliothek stdio.h für Ein-/Ausgabe.
L
int main() ist der Anfangspunkt des Programms (als Funktion).
L
return beendet das Programm.
L
int Datentyp für ganze Zahl (Integer).
L
Fett gedruckt: Schlüsselwörter.
L
\n: neue Zeile innerhalb einer Zeichenkette.
Compilieren von C-Programmen
L
Der Quelltext kann in einem beliebigen Editor geschrieben werden.
L
Übliche Dateiendung .c.
L
Compilieren aus der Konsole mit dem GNU C Compiler:
$ gcc -std=c99 -Wall -o hello hello.c
L
Programmstart aus der Konsole:
$ ./hello
Hello, world!
L
Komfortabler: Integrated Development Environment (IDE), enthält
Editor mitzusätzlichen Werkzeugen, Dokumentation, etc.
L
Hier eingesetzt: Eclipse (Java-basiert, quelloen) mit den C
Development Tools (CDT).
32
Der Debugger
L
Ein Debugger (engl. bug = Wanze, Fehler) dient zum Aufspüren
von Fehlern im Programm.
L
Das Programm kann schrittweise ausgeführt werden, wobei nach
jedem Schritt der Wert von Variablen kontrolliert / modiziert
werden kann.
L
Es können Unterbrechungspunkte (break points) deniert werden,
bei denen das Programm unterbrochen wird.
L
Hier verwendet: GNU Debugger gdb. Grundversion Textinterface,
aber auch komfortablere, grasche Varianten.
33
Die Entwicklungsumgebung Eclipse
L
Ein Projekt erstellen.
L
Dateien hinzufügen und Quelltext editieren.
L
Quelltext übersetzen und ausführen.
L
Fehlersuche, Schrittweises ausführen (debugging) mit Hilfe des
GNU Debugger.
34
Schlüsselwörter von C
auto, bool, break, case, char, const, continue, default, do,
double, else, enum, extern, false, oat, for, goto, if, inline,
int, long, register, restrict, return, short, signed, sizeof,
static, struct, switch, true, typedef, union, unsigned, void,
volatile, while.
35
Variablen I - Prinzip
L
Eine Variable ist eine Benennung eines bestimmten
Speicherbereichs, der Variablen können neue Werte zugewiesen
werden und diese kann in Ausdrücken verwendet werden.
L
Variablentypen in C: ganze Zahlen (int), Zeichen (char),
Wahrheitswerte (bool), leerer Datentyp (void), . . .
L
Eine Variable muss vor der Benutzung deklariert (vereinbart)
werden.
L
Syntax für das Deklarieren einer Variable: DATENTYP NAME;,
beispielsweise:
int i ;
float j = 1 . 0 ;
L
Die Wahl des Namens der Variablen obliegt dem Programmierer,
aber mit Einschränkungen:
36
Variablen II - Benennung
Regeln für Variablennamen in C:
L
Variablennamen können aus Buchstaben (ohne Umlaute und ÿ),
Ziern und dem Unterstrich bestehen.
L
Das erste Zeichen eines Variablennamens muss ein Buchstabe sein.
L
Die Länge eines Variablennamens ist beliebig.
L
Der Variablenname darf nicht mit einem vordenierten
Schlüsselwörter übereinstimmen.
L
Zwischen Groÿ- und Kleinschreibung wird unterschieden
(case-sensitive).
37
Elementare Datentypen - char
L
Der Datentyp char repräsentiert ein Zeichen.
L
Ein Zeichen benötigt 1 Byte (8 Bit) Speicherplatz.
L
char ist ein Ganzzahl-Datentyp; es wird der (numerische)
38
ASCII-Wert (American Standard Code for Information Interchange)
des Zeichens gespeichert.
L
Es gibt vorzeichenbehaftete und vorzeichenlose Varianten
(Datentypen: signed char/unsigned char). Im Falle von signed ist
das erste Bit Vorzeichenbit, bei unsigned nicht.
L
Wertebereich:
signed char: -128..127,
unsigned char: 0..255
Elementare Datentypen - int
39
L
Der Datentyp int repräsentiert die ganzen Zahlen (integer).
L
Der Speicherbedarf ist 4 Bytes (32-Bit) oder 8 Bytes (64-Bit).
L
Es gibt vorzeichenbehaftete und vorzeichenlose Varianten
(Datentypen: signed int/unsigned int). Im Falle von signed ist das
erste Bit Vorzeichenbit, bei unsigned nicht.
L
Wertebereich:
unsigned int: 0 .. 4 294 967 295 (=
232 1).
signed int: -2 147 483 647 .. 2 147 483 647,
L
Integer-Zahlen werden exakt dargestellt.
Elementare Datentypen - oat und double
L
40
Der Datentyp oat repräsentiert Gleitkommazahlen einfacher
Genauigkeit, double repräsentiert Gleitkommazahlen doppelter
Genauigkeit. Für ernsthafte Berechnungen sollte stets double
verwendet werden.
L
Der Speicherbedarf sind 4 Bytes (oat) bzw. 8 Bytes (double).
L
Allgemeine Darstellung einer Gleitkommazahl:
Mantisse
M,
(fester) Basis
B
und Exponent
z
M BE
L
Die Genauigkeit ist durch die Anzahl der Ziern von
L
Wertebereich (
oat
double
L
mit
E.
M
begrenzt.
B 10):
38
38
: 3.4 10
... 3.4 10 ,
308
308
: 1.797 10
... 1.79 10
Die eigentliche Beschränkung ist die Anzahl der Mantissenstellen!
Elementare Datentypen - Beispiel
#i n c l u d e < s t d i o . h>
int main ( int a r g c , char
int n , m;
double x , y ;
{
** a r g v )
n =2147483647;
m=2147483648;
x =1.797 e308 ;
y =1.798 e308 ;
p r i n t f ( "%d
p r i n t f ( "%g
}
return
0;
%d\n " , n , m) ;
%g\n " , x , y ) ;
41
Elementare Datentypen - Konstanten und Variablen
L
Konstanten = sich nicht ändernde Daten, z.B. ist in
int main ( ) {
p r i nt f (" Hallo
return 0 ;
Leute ! " ) ;
}
Hallo Leute! eine Zeichenketten-Konstante.
L
Im Gegensatz dazu: Variablen als benannte Speicherbereiche,
welche geändert werden können.
Weitere Beispiele:
L
Integer: int i=-12;
L
Zeichen: char c='x';
L
Zeichenkette: Eine Zeichenkette\n, Steuerzeichen: beginnen mit
\, z.B. \n für neue Zeile, \t für Tabulator, etc.
L
Flieÿkomma: oat a=1.205; oat b=2.83e-10;
42
Ausgabe von Werten mit printf
L
Mit printf( . . . ); können Zeichenketten ausgegeben werden.
L
Allgemeiner können auch Werte von Variablen ausgegeben werden,
dafür wird in die Zeichenkette ein Platzhalter eingefügt:
int
int
a =1;
b =2;
p r i n t f ( " Der Wert von a i s t : %i , d e r von b i s t %i "
,a , b) ;
L
Platzhalter: %i, %u Integer (signed, unsigned), %f, %g
Flieÿkomma, %c Zeichen, %s Zeichenkette.
L
Länge, Vor- und Nachkommastellen bei Flieÿkommazahlen:
%02i Integer mit mindestens zwei Ziern.
%.2f Fliekommazahl mit zwei Nachkommastellen ausgeben.
43
Ausdrücke und Operatoren
L
Ein Ausdruck besteht aus Operanden, welche durch Operatoren
verknüpft sind, z.B. oat zahl = 13.57;
L
Es gibt verschiedene Gruppen von Operatoren, z.B.: Arithmetische
Operatoren, Vergleichsoperatoren, Logische Operatoren,
Zuweisungsoperatoren, Inkrement- und Dekrementoperatoren.
L
Zuweisungsoperator = weist Variablen konstante Werte oder den
Wert anderer Variablen des gleichen Typs zu:
int a ;
float b , c ;
a =100;
b =1.1;
c =2 * b ;
44
Arithmetische Operatoren
L
Deniert für int, oat, double, . . .
L
Operatoren: +, -, *, /, % für Addition, Subtraktion Multiplikation,
45
Division, Teilungsrest (Modulo).
L
Die Regel Punkt vor Strich ist gültig, d.h. die Operatoren + und haben eine geringere Priorität als *, / und %.
L
Bei gleicher Priorität werden die Operatoren von links nach rechts
abgearbeitet.
L
Beispiel:
int
a, b, c;
a =10;
b = 2;
c =( a+b ) * 3+4;
Ausblick
Ausblick auf die nächste Vorlesung:
L
Compilieren mit make,
L
Funktionen,
L
Variablen und ihre Gültigkeit,
L
Umwandlung von Datentypen,
L
Bedingte Anweisung, Schleifen,
L
...
46
Vielen Dank...
... für Ihre Aufmerksamkeit
und bis morgen...
47