Bauinformatik Teil 1 - Baustatik-Info-Server

Bauinformatik Teil 1 

Übungsskript 

2011 

Universität Duisburg-Essen 

Fakultät für Ingenieurwissenschaften 

Abteilung Bauwissenschaften 

Institut für Baustatik 

Dr. E. Baeck 

19.10.2011

INHALTSVERZEICHNIS 

Seite iii 

Inhaltsverzeichnis 

1 Arbeiten mit EXCEL 2 

1.1 Bezüge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 

1.2 Fehlermeldungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 

1.3 EXCEL-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 

1.3.1 SUMME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 

1.3.2 ABS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 

1.3.3 MAX, MIN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 

1.3.4 WENN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 

1.3.5 SVERWEIS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 

1.4 Aufgabe 1: Summe, Extremwerte und Absolutbetrag . . . . . . . . . . . . . . . 4 

1.5 Aufgabe 2: Nachweis eines statisch unbestimmten Trägers . . . . . . . . . . . . 5 

2 Zahlensysteme 7 

2.1 Motivation und Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 

2.2 Beispiele zur Konvertierung zwischen Zahlensystemen . . . . . . . . . . . . . . . 8 

2.3 Darstellung negativer Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 

3 Die VBA-IDE 11 

3.1 Oberfläche und Projektbrowser . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 

3.2 Testen eines Programms, Debugger . . . . . . . . . . . . . . . . . . . . . . . . . . 12 

4 VBA-Interface 14 

4.1 Beispiel 1 in 6 Schritten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 

4.1.1 Schritt 1: Gestaltung der Oberfläche . . . . . . . . . . . . . . . . . . . . . 14 

4.1.2 Schritt 2: Gestaltung der Steuerelemente . . . . . . . . . . . . . . . . . . . 15 

4.1.3 Schritt 3: Generieren eines Moduls für Funktion Summe . . . . . . . . . . 16 

4.1.4 Schritt 4: Das Programm Summe . . . . . . . . . . . . . . . . . . . . . . . 16 

4.1.5 Schritt 5: Programmtests . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 

4.1.6 Schritt 6: Das Ziel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 

5 Elementare Algorithmen 19 

5.1 Fakultät . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 

5.2 Binomialkoeffizient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 

5.3 Winkel zwischen 2 Vektoren des R n . . . . . . . . . . . . . . . . . . . . . . . . . 20 

5.3.1 Pseudocode für Hauptprogramm . . . . . . . . . . . . . . . . . . . . . . . 20 

5.3.2 Pseudocode für Funktion SP rod . . . . . . . . . . . . . . . . . . . . . . . 20 

5.4 Reihenentwicklungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 

5.4.1 Entwicklung der Funktion sinus . . . . . . . . . . . . . . . . . . . . . . . 21 

5.4.2 Reihenentwicklung weiterer Funktionen . . . . . . . . . . . . . . . . . . . 22 

5.5 Newton-Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 

5.5.1 Der Algorithmus des 1-dimensionalen Falls . . . . . . . . . . . . . . . . . 22 

5.5.2 Pseudo-Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 

19.10.2011

Seite iv Bauinformatik - Teil 1 - Übungsskript / 2011 

5.5.3 Programmablaufplan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 

5.5.4 Nassi-Schneidermann-Diagramm . . . . . . . . . . . . . . . . . . . . . . . 24 

5.5.5 Die Oberfläche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 

5.5.6 Animation des Verfahrens . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 

6 Elementare Sortiert-Algorithmen 26 

6.1 Select-Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 

6.2 Bubble-Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 

7 Arbeiten mit Dateien 28 

7.1 Dateioperationen für sequentiellen Zugriff . . . . . . . . . . . . . . . . . . . . . . 28 

7.2 Torsionsträgeheitsmoments nach 2. Brendt’scher Formel . . . . . . . . . . . . . . 29 

8 Das Clapeyron-Problem 30 

8.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 

8.2 Oberflächenlayout und Eingabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 

8.2.1 Feldbeschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 

8.2.2 Lastbeschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 

8.3 ER-Modell der Datenstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 

8.3.1 ER-Modell der Struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 

8.3.2 ER-Modell der Belastung . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 

8.4 Aufbau der Datenstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 

8.4.1 Die Datenstruktur des Systems . . . . . . . . . . . . . . . . . . . . . . . . 34 

8.4.2 Die Datenstruktur der Belastungen . . . . . . . . . . . . . . . . . . . . . . 35 

8.5 Aufbau des Linearen Gleichungssystems . . . . . . . . . . . . . . . . . . . . . . . 37 

8.5.1 Aufbau der Koeffizientenmatrix . . . . . . . . . . . . . . . . . . . . . . . . 37 

8.5.2 Aufbau der Lastvektoren . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 

9 VBA-Objekte 40 

9.1 Konstruktor und Destruktor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 

9.2 Vektoren und Matrizen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 

9.2.1 Methoden des Klassenmoduls Vektor . . . . . . . . . . . . . . . . . . . . . 41 

9.2.2 Methoden des Klassenmoduls Matrix . . . . . . . . . . . . . . . . . . . . . 41 

9.3 Die Containerklasse Collection . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 

9.4 Datenstruktur eines Stabwerks . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 

9.4.1 Die Oberfläche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 

9.4.2 Methoden des Punktes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 

9.4.3 Methoden des Stabes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 

9.5 2-fach verkettete lineare Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 

9.5.1 Beispiel einer 2-fach verketten Liste . . . . . . . . . . . . . . . . . . . . . 47 

9.5.2 Einfügen eines Datenknotens . . . . . . . . . . . . . . . . . . . . . . . . . 47 

9.5.3 Entfernen eines Datenknotens . . . . . . . . . . . . . . . . . . . . . . . . . 47 

9.5.4 Iteratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 

10 Rekursive Algorithmen 49 

10.1 Quick-Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 

E. Baeck

INHALTSVERZEICHNIS 

Seite v 

A Dreimomentengleichung, Clapeyron 51 

A.1 Das Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 

A.2 Herleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 

B Das ER-Modell 54 

C UML-Aspekte 55 

D Gauß’scher Algorithmus und Cholesky-Zerlegung 56 

D.1 Der Gauß’sche Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 

D.2 Interpretation des Gauß’schen Algorithmuses als Dreieckszerlegung . . . . . . . . 58 

D.3 Die Cholesky-Zerlegung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 

D.4 Pseudocode für Cholesky-Zerlegung . . . . . . . . . . . . . . . . . . . . . . . . . . 62 

D.4.1 Pseudocode der Zerlegung . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 

D.4.2 Pseudocode des Vorwärtseinsetzens . . . . . . . . . . . . . . . . . . . . . . 62 

D.4.3 Pseudocode des Rückwärtseinsetzens . . . . . . . . . . . . . . . . . . . . . 62 

D.5 VBA-Code des Gleichungslösers nach Cholesky . . . . . . . . . . . . . . . . . . . 63 

D.5.1 VBA-Code der Cholesky-Zerlegung . . . . . . . . . . . . . . . . . . . . . . 63 

D.5.2 VBA-Code des Vorwärtseinsetzens . . . . . . . . . . . . . . . . . . . . . . 64 

D.5.3 VBA-Code des Rückwärtseinsetzens . . . . . . . . . . . . . . . . . . . . . 64 

E Lösungen zum Abschnitt Elementare Algorithmen 65 

E.1 Summe aller Zahlen aus vorgegebenem Intervall . . . . . . . . . . . . . . . . . . . 65 

E.2 Berechnung der Fakultät . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 

E.3 Berechnung des Binomialkoeffizienten . . . . . . . . . . . . . . . . . . . . . . . . 67 

E.4 Beispiel 4: Winkel zwischen 2 Vektoren im R n . . . . . . . . . . . . . . . . . . . . 68 

E.5 Lösung der sinus-Entwicklung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 

E.6 Implementierung des Newton-Verfahrens . . . . . . . . . . . . . . . . . . . . . . . 72 

F Lösungen zum Clapeyron-Problem 74 

F.1 Aufgabe 8.3.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 

F.2 Aufgabe 8.3.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 

F.3 Einlesen der Systemdaten und Aufbau des Datenmodell . . . . . . . . . . . . . . 76 

F.4 Einlesen der Belastungsdaten und Aufbau des Datenmodell . . . . . . . . . . . . 77 

F.4.1 Aufbau des Lastfall-Indexvektors . . . . . . . . . . . . . . . . . . . . . . . 77 

F.4.2 Aufbau des Lastfall-Containers . . . . . . . . . . . . . . . . . . . . . . . . 79 

F.4.3 Aufbau der Koeffizientenmatrix . . . . . . . . . . . . . . . . . . . . . . . . 81 

F.4.4 Lesen einer kompakt gespeicherten Bandmatrix . . . . . . . . . . . . . . . 82 

F.4.5 Das Hauptprogramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 

G Lösungen zum Abschnitt Vektor- und Matrixobjekte 84 

G.1 Deklaration eines Vektor-Klassenmoduls . . . . . . . . . . . . . . . . . . . . . . . 84 

G.2 Deklaration eines Matrix-Klassenmoduls . . . . . . . . . . . . . . . . . . . . . . . 86 

G.3 Programm Vektor 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 

G.4 Programm Vektor Drehen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 

H Lösungen zum Abschnitt Rahmen und Collection 90 

19.10.2011

INHALTSVERZEICHNIS Seite 1 

H.1 Deklaration des Stab-Klassenmoduls . . . . . . . . . . . . . . . . . . . . . . . . . 90 

H.2 Deklaration des Knoten-Klassenmoduls . . . . . . . . . . . . . . . . . . . . . . . 90 

H.3 Implementierung des Anwendungsprogramms . . . . . . . . . . . . . . . . . . . . 91 

H.3.1 Die Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 

H.3.2 Die Funktion Einlesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 

H.3.3 Die Funktion Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 

H.3.4 Die Funktion Verschieben . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 

H.3.5 Die Funktion StabAnzahl . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 

H.3.6 Die Ereignisfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 

I Lösungen zum Abschnitt 2-fach verkettete Listen 96 

I.1 Deklaration des VNode-Klassenmoduls . . . . . . . . . . . . . . . . . . . . . . . . 96 

I.2 Deklaration des VListe-Klassenmoduls . . . . . . . . . . . . . . . . . . . . . . . . 96 

I.2.1 Daten am Listenkopf einfügen . . . . . . . . . . . . . . . . . . . . . . . . . 97 

I.2.2 Daten am Listenende einfügen . . . . . . . . . . . . . . . . . . . . . . . . 97 

I.2.3 Vorwärtsiterator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 

I.2.4 Einfügen eines Knotens . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 

J Lösungen zu Sortieralgorithmen 100 

J.1 Die Ereignisfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 

J.2 Generierung der Zufallszahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 

J.3 Sortieralgorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 

J.3.1 Implementierung von SelectSort . . . . . . . . . . . . . . . . . . . . . . . 103 

J.3.2 Implementierung von BubbleSort . . . . . . . . . . . . . . . . . . . . . . . 104 

J.3.3 Implementierung von QuickSort . . . . . . . . . . . . . . . . . . . . . . . 105 

K Lösung zur Brendt’schen Formel 107 

K.1 Die Ereignisfunktion zur Festlegung des Dateinamens . . . . . . . . . . . . . . . . 107 

K.2 Die Ereignisfunktion zu Datenimport und Berechnung . . . . . . . . . . . . . . . 107 

K.3 Die Datenstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 

K.4 Einlesen der Daten aus der Profil-Textdatei . . . . . . . . . . . . . . . . . . . . . 108 

K.5 Hilfsfunktionen der Berechnung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 

K.5.1 Berechnung der mittlerern Blechdicke . . . . . . . . . . . . . . . . . . . . 110 

K.5.2 Berechnung des Knotenabstandes . . . . . . . . . . . . . . . . . . . . . . . 110 

K.5.3 Berechnung der Polygonfläche . . . . . . . . . . . . . . . . . . . . . . . . . 111 

19.10.2011

Seite 2 Bauinformatik - Teil 1 - Übungsskript / 2011 

1 Arbeiten mit EXCEL 

1.1 Bezüge 

Die Adressierung der EXCEL-Tabellenfelder (Bezüge) erfolgt über relative und absolute Bezüge 

bzw. über Namen (Bezeichnung eines Bezuges). 

• Indizierung 

B3 

Z3S2 

Standardindizierung von Spalte und Zeile 

B:⇒ Spalte 2 

3:⇒ Zeile 3 

Z1S1 -Indizierung von Spalte und Zeile 

S2:⇒ Spalte 2 

Z3:⇒ Zeile 3 

• Relative Bezüge 

Beim Kopieren wird auf relative Bezüge die Verschiebung aufaddiert. 

Verschiebung 4 Spalten und 3 Zeilen: B3 

Z3S2 

⇒ F6 

⇒ Z(-3)S(-4) 

• Absolute Bezüge 

$B3 Beim Kopieren wird der Spaltenbezug erhalten. 

$B$3 

Beim Kopieren wird der Spalten- und Zeilenbezug erhalten. 

• Namen 

Ein Name ist gleichbedeutende mit einem absoluten Bezug auf ein oder mehrere Tabellenfelder. 

1.2 Fehlermeldungen 

Fehler Beispiel Beschreibung 

### Die Zelle ist für die vorgegebene Ausgabe zu schmal. 

#WERT! =Abs(A3:A5) Unzulässiger Funktionswert. 

#DIV! 

=A2/A3, bei A3=0 Nulldivision. 

#NAME =NoName Bezeichnung eines Bezugs oder einer Funktion ist unbekannt. 

#ZAHL! =Exp(1000) Zahlendarstellung nicht möglich. Überlauf. 

#NV! =SVerweis(...) Gesuchter Wert nicht verfügbar. Verweisfehler. 

#BEZUG! =Z(-3)S(-4) 

Der Bezug liegt außerhalb des zulässigen Bereichs, d.h. außerhalb der 

Tabelle. 

E. Baeck

1. ARBEITEN MIT EXCEL Seite 3 

1.3 EXCEL-Funktionen 

Nachfolgend werden die EXCEL-Funktionen zusammengestellt, die zur Bearbeitung der Übungsbeispiele 

herangezogen werden sollten. 

1.3.1 SUMME 

Summe berechnet die Summe der Zellenwerte eines Bezugs. 

Beispiel: 

=Summe(A3:G3) 

1.3.2 ABS 

ABS berechnet den Absolutbetrag eines Zellenwerts. 

Beispiel: 

=Abs(A3) 

1.3.3 MAX, MIN 

MAX bzw. MIN ermittelt den maximalen bzw. minimalen Wert innerhalb eines Bezugs. 

Beispiel: 

=Max(A3:G3) 

=Min(A3:G3) 

1.3.4 WENN 

Mit der Funktion WENN wird in 

Abhängigkeit eines boolschen Ausdrucks 

ein DANN -Wert oder ein 

SONST -Wert zugewiesen. 

Beispiel: 

=WENN(D13


1.3.5 SVERWEIS 

Mit der Matrix-Suchfunktion SVER- 

WEIS lassen sich Daten aus Datenbanken, 

d.h. aus Bezügen in beliebigen 

Tabellen, unter Vorgabe eines Suchbegriffs 

extrahieren. 

Beispiel: 

=SVerweis(E3;A3:C5;2;FALSCH) 

Abbildung 2: SVERWEIS-Funktion 

Parameter Beschreibung 

S T 

M D 

N S 

Suchwert: Text, Zahl oder Wahrheitswert. 

Datenmatrix. Ein Bezug in einer beliebigen Tabelle. 

Spaltenindex der gewünschten Datenspalte. 

(Spalte 1 ist Suchspalte). 

K S 

Sortierkenner: Wahr ⇒ sortiert, Falsch ⇒ unsortiert. 

1.4 Aufgabe 1: Summe, Extremwerte und Absolutbetrag 

In einem Bezug A1:D5 werden beliebige Zahlen eingetragen. Es sind die folgenden Größen zu 

ermitteln (siehe Abbildung 3): 

• Die Spalten- und Zeilensummen sowie die Gesamtsumme. 

• Maximaler und Minimaler Wert. 

• Maximaler Absolutwert. 

• Mit einer WENN-Funktion soll ausgegeben werden ob nur negative, nur positive oder 

negative und positive Werte gefunden wurden. 

Abbildung 3: Auswertung eines Bereichs 

E. Baeck

1. ARBEITEN MIT EXCEL Seite 5 

1.5 Aufgabe 2: Nachweis eines statisch unbestimmten Trägers 

Die Datenfelder sind in Formeln jeweils mit Namen anzusprechen 1 

Ein statisch unbestimmter Träger (siehe Abbildung 4) ist für vorgegebene Trägerlänge l und 

Steckenlast q für vorgegebenes Material (Stahltabelle) und Profil (Profiltabelle) nachzuweisen. 

Der E-Modul E der Stahlsorte sowie das Widerstandsmoment W sind aus einer Tabelle mittels 

der Suchfunktion SVERWEIS zu ermitteln (siehe Abbildung 5). 

Es ist zunächst zu berechnen, die Gesamtlast P , die beidseitigen Auflagerkräfte A = 3/8 ∗ P 

bzw. B = 5/8 ∗ P , das Einspannmoment M B = −1/8 ∗ P ∗ l und die Biegespannung am Lager B 

σ = M B /W . Die Eingabefelder der Tabelle sind als solche entsprechend zu kennzeichnen (siehe 

Abbildung 4). 

Achten Sie auch auf die Anpassung der unterschiedlichen Dimensionen. 

Abbildung 4: Nachweis eines statisch unbestimmten Trägers 

1 Namen können im Untermenü Einfügen/Namen eingefügt und bearbeitet werden. 

19.10.2011


Die Datenbanken für Material und Profile sollten in einer zweiten EXCEL-Tabelle der Mappe 

angelegt werden. 

Abbildung 5: Material- und Querschnittswerte in einer Datenbank 

In einem weiteren Schritt ist die Durchbiegung des Trägers y = P ∗x∗(l3 −3∗l∗x 2 +2∗x 3 ) 

48∗E∗I∗l 

in Abhängigkeit 

der Längskoordinate x zu ermitteln und mit dem Diagrammassistenten darzustellen. Als 

Diagrammtyp ist der Typ Punkt(XY) auszuwählen. Die Balkenlängsrichtung liegt in X-Richtung, 

die Durchbiegung in negative Y-Richtung (Faktor -1). 

E. Baeck

2. ZAHLENSYSTEME Seite 7 

2 Zahlensysteme 

Ein Zahlensystem wird zur Darstellung von Zahlen verwendet. Eine Zahl wird dabei nach den 

Regeln des jeweiligen Zahlensystems als Folge von Ziffern beziehungsweise Zahlzeichen dargestellt. 

In einem Stellenwertsystem (auch polyadisches Zahlensystem) bestimmt die Stelle (Position) 

den Wert der jeweiligen Ziffer. Die niederwertigste Position steht dabei im Allgemeinen rechts. 

Ein Stellenwertsystem hat eine Basis b (man spricht auch von einem b-adischen Zahlensystem). 

Jede Zifferposition hat einen Wert, der einer Potenz der Basis entspricht. Für die n-te Position 

hat man einen Wert von b n−1 (wenn die niederwertigste Position mit 1 nummeriert ist). 

Die Berechnung des Zahlenwertes erfolgt durch Multiplikation der einzelnen Ziffernwerte z i mit 

den zugehörigen Stellenwerten b i und der Addition dieser Produkte: 

Zahlenwert = z n · b n + . . . + z i · b i + . . . + z 0 · b 0 . (1) 

2.1 Motivation und Anwendung 

Im Allgemeinen wird das Zahlensystem zur Basis 10 eingesetzt. Es gibt jedoch Anwendungsfälle, 

in denen das Zahlensystem zur Basis 10 ungeeignet ist. Aufgrund des digitalen Aufbaus eines 

Computers eignet sich das Zahlensystem zur Basis 10 zur Darstellung der Bit-Information in 

keinster Weise. Es verschleiert die Zusammenhänge, die mit Anwendung eines Zahlensystems 

zur Basis 2 oder zur Basis einer 2er Potenz einfach und klar in Erscheinung treten würden. 

Vergleichbar ist dieser Zusammenhang der Anwendung 

verschiedener Koordinatensysteme. So ist z.B. die Beschreibung 

einer rechteckigen Fläche im 2 dimensionalen 

karthesischen Koordinatensystem sehr einfach. Hierbei 

entkoppeln die Unterdimensionen Länge und Breite 

(siehe Abb. 6). Eine Fläche ist allein durch Vorgabe dieser 

Werte möglich. Soll demgegenüber eine Kreisfläche 

im 2 dimensionalen karthesischen Koordinatensystem beschrieben 

werden, so sind die Unterdimensionen Länge 

Abbildung 6: Rechteckfläche 

und Breite offensichtlich gekoppelt. Eine Vorgabe dieser Werte allein reicht nicht mehr aus, um 

die Fläche zu beschreiben (siehe Abb. 7). Wählt man hingegen ein polares Koordinatensystem 

mit den Unterdimensionen Radius und Winkel, so ist es wieder möglich durch Vorgabe zweier 

Werte, in diesem Fall Radius und Winkelbereich, eine Kreisfläche zu beschreiben. 

Da der Computer aufbauend auf der logischen Elementareinheit Bit (0 und 1 / aus und ein) in 

Paketen von zumeist 8 Bits (1 Byte) strukturiert ist, empfiehlt es sich aufgrund der Unübersichtlichkeit 

des dualen Zahlensystems Bits zur gruppieren. Werden 3 Bits gruppiert erhält man als 

natürliches Zahlensystem das Zahlensystem zur Basis 8 (Oktalsystem). Werden 4 Bits gruppiert 

erhält man als natürliches Zahlensystem das Zahlensystem zur Basis 16 (Hexadezimalsystem). 

19.10.2011


Abbildung 7: Kreisfläche in karthesischen und polaren Koordinaten 

2.2 Beispiele zur Konvertierung zwischen Zahlensystemen 

Beispiel 1: 

Konvertierung von 142 5 in das Zahlensystem zur Basis b = 3. 

• Schritt 1: 

Konvertierung in das 10-System 

142 5 = 1 · 5 2 + 4 · 5 1 + 2 · 5 0 

= 25 10 + 20 10 + 2 10 

= 47 10 

• Schritt 2a: 

Konvertierung in das 3-System vollständig über 10-System 

47 10 = 1 · 3 3 + 2 · 3 2 + 0 · 3 1 + 2 · 3 0 

= 45 10 + 0 10 + 2 10 

= 1202 3 

• Schritt 2b: 

Ziffernweise Konvertierung in das 3-System 

142 5 = 1 · 5 2 + 4 · 5 1 + 2 · 5 0 

= 25 10 + 20 10 + 2 10 

= 221 3 + 202 3 + 2 3 

= 1202 3 

E. Baeck

2. ZAHLENSYSTEME Seite 9 

Beispiel 2: 

Konvertierung von 142 10 in das Zahlensystem zur Basis b = 6. 

Der Algorithmus zur Konvertierung einer Zahl in das Zahlensystem zur Basis b erfolgt durch 

b-Division und aufsammeln der Divisionsreste nach dem folgenden Prinzip (siehe Abb. 8). 

142 wird durch 6 dividiert. Dies ergibt 23 Rest 4 



Die erhaltenen Reste 4, 5 und 3 werden in die Reihenfolge 

von unten nach oben gebracht und von 

links nach rechts hin geschrieben. Damit erhalten 

wir die Zahl 354 6 . 

Abbildung 8: Rechteckfläche 

In Abbildung 8 wird die Umrechnung in einer EXCEL-Tabelle implementiert (siehe dazu auch 

Abschnitt 1). In A2 wird die zu konvertierende Zahl eingetragen. Der Divisor ist stets b, also 

6. Das Ergebnis der ganzzahligen Division erhalten wir mit der Formel =GANZZAHL(A2/B2). Der 

Divisionsrest in der grünen Spalte ergibt sich mit der Formel =REST(A2;B2). Das Ergebnis der 

ganzzahligen Division orange Felder werden in der folgenden Zeile in die Spalte des Dividenden 

eingetragen. Die Formel der ersten Zeile kann in die zweite Zeile eingetragen kopiert werden. 

Die Bezüge werden dabei, da relative Adressen verwendet werden, automatisch angepasst. In der 

Spalte E werden zur Kontrolle alle Anteile der Ziffern berechnet und in E6 zum Kontrollwert 

aufaddiert. 

Ein Übungsbeispiel: 

In nachfolgendem Übungsbeispiel ist in der Tabelle die in Spalte Zahl gegebene Zahl in die 

verschiedenen Zahlensysteme zur Basis b umzurechnen. 

Zahl b = 2 b = 5 b = 7 b = 8 b = 10 b = 16 

2021 3 

453 6 

246 7 

246 8 

33 10 

2F 16 

Tabelle 1: Zahlensysteme 

19.10.2011


2.3 Darstellung negativer Zahlen 

Negative Zahlen können bei einer endlichen Ziffernbreite so konstruiert werden, dass die Summe 

aus positiver und negative Zahl gerade die Zahl ergibt, die im Bereich der Ziffernbreite alle Ziffern 

zu Null setzt und einen Übertrag von 1 erzeugt, der aufgrund der beschränkten Ziffernbreite und 

eines Überlaufs nicht mehr darstellbar ist. So verbleiben also die ausgenullten Ziffern und die 

führende 1 verschwindet. Im Rahmen der vorliegenden Ziffernbreite ist das aber gerade die 

Darstellung des Null-Wertes. 

Die Konstruktion der negativen Zahl beginnt mit dem sogenannten Stellenkomplement. Das 

Stellenkomplement ist die Zahl, deren Ziffern sich ergeben zu b − z − 1, d.h. wir subtrahieren 

von der Basis b die gegebenen Ziffer und die 1. Eine Summe aus Stellenkomplement und 

gegebener Zahl ergibt demnach eine Ziffernfolge, die nur die größte Ziffer, also b − 1 enthält. 

Wenn wir auf diese Ziffernfolge eins aufaddieren wird ein Übertrag erzeugt, der aufgrund der 

Begrenzung der Ziffernbreite verschwindet und alle Ziffern werden auf Null gesetzt. Damit ist die 

Darstellung der negativen Zahl, das b-Komplement, gegeben durch das um eins inkrementierte 

Stellenkomplement. 

In der Tabelle 2 sind die Darstellungen der negativen Zahlen im angegebenen b-Komplement 

(Zahlensystemkomplement) bei vorgegebener Ziffernbreite einzutragen. 

Beispiel: 

b-Komplement der Zahl 346 7 bei einer Ziffernbreite von 4. 

Anmerkungen 

0346 7 zu komplementierende Zahl mit 4 Ziffer 

6320 7 Stellenkomplement: Komplementziffer = 6 -Ziffer 

+ 1 b-Komplement = Stellenkomplement +1 

6321 7 b-Komplement der Zahl 

Addition von Zahl und b-Komplement 

0346 7 zu komplementierende Zahl 

+ 6321 7 b-Komplement 

10000 7 Wird der Überlauf abgeschnitten ist das Ergebnis der Addition Null. 

Zahl Breite b − Komplement 

−2021 3 6 

−453 6 6 

−246 7 5 

−246 8 5 

−33 10 4 

−2F 16 4 

Tabelle 2: b-Komplement 

E. Baeck

3. DIE VBA-IDE Seite 11 

3 Die VBA-IDE 

Die VBA-IDE, (integrierte Entwicklungsumgebung) ist in allen Applikationen verfügbar, die 

VBA zur Automation einsetzten (z.B. MS-Office-Programm, AutoCAD, RStab, etc.). 

3.1 Oberfläche und Projektbrowser 

Die VBA-IDE wird standardmäßig 

über Alt-F11 oder 

Extras/Makro/Visual-Basic- 

Editor gestartet. Sie besteht 

aus einem Editor, einem 

Code-Generator für Rahmenprogramme 

ausgewählter 

Eventfunktionen und einem 

Programmtestmodul (Debugger) 

(siehe Abbildung 9). 

Abbildung 9: VBA-IDE 

Im Projektbrowser werden die folgenden Ordner angezeigt. 

• MS-EXCEL-Objekte 

Der Ordner enthält alle Tabellen der EXCEL-Datei (Workbook). 

• Modul-Objekte 

Der Ordner enthält Modul-Objekte, die ihrerseits die Quellen sequentieller (konventioneller) 

Programme enthalten. Module sind optional. 

• Userform-Objekte 

Der Ordner enthält Userform-Objekte, d.h. Layouts und Event-Quellen der Dialoge. Module 

sind optional. 

• Klassenmodul-Objekte 

Der Ordner enthält Klassenmodule. Ein Klassenmodul ist ein Objekt (mit Abstrichen) im 

Sinne der OOP. Module sind optional. 

Optionale Ordner werden beim Einfügen (Menü Einfügen oder Rechtsklick in Browserfenster) 

der entsprechenden Objekte (Module, Userform und Klassenmodul) angelegt. 

19.10.2011


3.2 Testen eines Programms, Debugger 

Programme können in der IDE 

mit dem integrierten Debugger 

getestet werden. Dazu geht man 

wie folgt vor. Das Programm 

wird nach setzen eines Haltepunktes 

unterbrochen und kann 

im Einzelschrittmodus, d.h. es 

wird Programmzeile um Programmzeile 

ausgeführt durchlaufen 

werden. Die Belegung der lokalen 

Variablen oder der Zustand 

gewählter Testausdrucke können 

ausgegeben werden. 

Abbildung 10: VBA-IDE-Debugger 

Der Debugger bietet die folgenden Ausführungsoptionen. 

• Haltepunkt 

An einem Haltepunkt wird das Programm unterbrochen. Der Haltepunkt kann mit F9 

oder im Menü Debuggen ein- oder ausgeschaltet werden. 

• Einzelschritt 

Mit dem Einzelschritt (F8) wird nur eine Programmanweisung ausgeführt. Mit dem Einzelschritt 

läuft der Debugger in Unterprogramme. 

• Prozedurschritt 

Mit dem Prozedurschritt (Shift+F8) wird nur eine Programmanweisung ausgeführt. Mit 

dem Prozedurschritt überspringt der Debugger Unterprogramme, d.h. die Unterprogramme 

werden ausgeführt ohne dass der Debugger das Programm anhält. 

• Cursorposition 

Mit der Ausführung bis zur Cursorposition (Strg+F8) kann das Programm bis zur aktuellen 

Cursorposition ausgeführt werden, sofern die Cursorposition in einem Programmteil 

liegt, der bei Ausführung durchlaufen wird. 

Abbildung 10 zeigt den Debugger im Testbetrieb. Haltepunkte werden als braune Punkte am 

linken Fensterrand des Editors angezeigt. Die aktuelle Programmposition wird in den Quellen 

gelb hinterlegt und zudem am linken Fensterrand durch einen gelben Pfeil markiert. 

E. Baeck

3. DIE VBA-IDE Seite 13 

Um den Zustand eines Programms prüfen zu können bietet die IDE die folgenden Einblicke. 

• Direktbereich 

Der Direktbereich ist ein Fenster, in das vom Programm aus mit der Objektfunktion 

—debug.print— direkt geschrieben werden kann. In dieses Fenster können Testausdrucke 

geschrieben werden, wenn z.B. ein Einzelschritt-Debuggen zu aufwendig wäre (z.B. Test 

bei zahlreichem Schleifendurchlauf). 

• Lokal 

Um die Transparenz mit wenig Aufwand zu gewährleisten, werden im Lokal-Fenster alle 

lokalen Variabelen und eventuelle Programmrückgabewerte ausgegeben. 

• Überwachungsausdrücke 

Ein Überwachungsausdruck ist eine Variabel oder ein Ausdruck mit mehreren Variablen. 

Überwachungsausdrücke können zum bedingten Anhalten eines Programmlaufes eingesetzt 

werden. 

19.10.2011


4 VBA-Interface 

Der Codegenerator der IDE verbindet Ereignisse (Klicken, Maus schieben, etc.) mit den 

gewünschten Programmen. Dazu ist zunächst ein Steuerelement (hier eine Schaltfläche) zu erzeugen. 

Die Eigenschaften des Steuerelements sind im Eigenschaftsfenster zu bearbeiten. 

Nach Doppelklick auf das Steuerelement 

wird ein Rahmen einer 

Klick-Ereignisfunktion im entsprechenden 

Tabellenordner der 

Tabelle, in der das Steuerelement 

erzeugt wurde, geschrieben. 

Ereignisfunktionen verknüpfen 

Ereignisse eines Steuerelements 

mit dem zu implementierenden 

Programmcode. 

4.1 Beispiel 1 in 6 Schritten 

Abbildung 11: VBA-IDE 

Im folgenden Beispiel 2 wird ein Programm implementiert, dass über eine Schaltfläche gestartet 

alle ganzen Zahlen aus einem vorgegebenen Intervall aufsummiert. 

4.1.1 Schritt 1: Gestaltung der Oberfläche 

In einem ersten Schritt wird die Programmoberfläche 

in einer Tabelle zusammengestellt. 

Es sind die Felder VON 

und BIS anzulegen, die die Intervallgrenzen 

enthalten werden. Zudem ist 

ein Feld SUM anzulegen, in das das 

zu schreibende Programm den Ergebniswert 

eintragen wird. Auf die Vergabe 

der Namen (hier: VON, BIS und SUM ) 

Abbildung 12: Beispiel: Schritt 1 

sollte nicht verzichtet werden, da das 

Programm Felder in einfacher Weise über Namen ansprechen kann und zudem eine Kopplung 

2 Das Programm ist als Beispiel1 in der Beispiel-Sammlung zur Veranstaltung enthalten. 

E. Baeck

4. VBA-INTERFACE Seite 15 

an das Oberflächenlayout ausgeschlossen wird. Die Schaltfläche ist mit der Werkzeugleiste Steuerelemente 

zu generieren. 

4.1.2 Schritt 2: Gestaltung der Steuerelemente 

Nach dem Erzeugen der Schaltfläche (eines 

Steuerelements) ist diese zunächst 

im Entwurfsmodus, d.h. die Eigenschaften 

sind zu bearbeiten, Ereignisfunktionen 

werden automatisch durch einen 

Doppelklick generiert. 

Die Standardbezeichnung einer Schaltfläche 

ist CommandButton1. Dies ist 

der Objektname unter dem ein Objekt 

(hier die Schaltfläche) im Programmcode 

angesprochen werden kann. 

Die Schaltfläche soll nun ein Ereignis 

auslösen. Der Klick auf die Schaltfläche 


soll das Programm starten. Dazu ist der 

schon automatisch angelegte Rahmen der Ereignisfunktion CommandButton1_Click() mit dem 

entsprechenden Programmcode zu füllen. 

Die Syntax eines Ereignisfunktionsnamens wird in VBA wie folgt aufgebaut. Der erste Teil 

des Namens (der Text vor dem _) ist der Name des Objekts (hier: CommandButton1). Der 

zweite Teil des Namens ist der Bezeichner für das Ereignis (hier: Click()). Rahmen für weitere 

Ereignisfunktionen werden automatisch nach Auswahl eines Ereignisses aus der Ereignisliste 

(siehe Abbildung 13) erzeugt. 

Wird z.B. das Ereignis LostFocus ausgewählt, d.h. Verlust des Eingabefokus, dann wird der 

Rahmen der Ereignisfunktion CommandButton1_LostFocus() erzeugt. Um die Wirkungsweise 

einer Ereignisfunktion zu studieren, kann in diese einfach der Aufruf einer Meldungsbox 

MsgBox "Meldungstext" eingetragen werden. Damit wird immer bei Auftreten des Ereignisses 

eine Meldungsbox in EXCEL ausgegeben. 

19.10.2011


4.1.3 Schritt 3: Generieren eines Moduls für Funktion Summe 

Mit einem Rechtsklick auf den Objektbrowser 

öffnet sich ein Menü mit der 

Funktion Einfügen/Modul. In den eingefügten 

Modul ist der Programmcode 

einzutragen. Der Name des Moduls wird 

in den Eigenschaften auf Beispiel1 abgeändert. 

Das noch zu implementierende Programm 

Summe wird nun aus der 

Ereignisfunktion für das Klickereignis 


CommandButton1_Click() aufgerufen. Dazu ist die Zeile Beispiel1.Summe in die Ereignisfunktion 

einzutragen. 

Damit ergibt sich für die Ereignisfunktion folgender Code. 

Private Sub CommandButton1_Click() 

Beispiel1.Summe 

End Sub 

4.1.4 Schritt 4: Das Programm Summe 

Um das Programm Summe zu implementieren, ist der Modulordner Beispiel1 zu öffnen und der 

Programmcode im Editor wie folgt einzugeben. 

’ Summation aller ganzer Zahlen aus einem Zahlenintervall 

Public Sub Summe() 

’ Öffentliches Programm "Public Sub" 

Dim ivon As Integer 

Dim ibis As Integer 

Dim isum As Integer 

Dim i As Integer 

’ Deklarationen mit Dim 

’ Initialisierung 

isum = 0 

ivon = Range("VON") 

ibis = Range("BIS") 

’ Schleife über das Intervall 

For i = ivon To ibis 

isum = isum + i 

Next 

’ Rückgabe des Summenwerts nach EXCEL-Tabelle 

Range("SUM") = isum 

End Sub 

E. Baeck

4. VBA-INTERFACE Seite 17 

In nachfolgender Tabelle werden die Anweisungen des Summe-Programms erläutert. 

Schlüssel 

Public 

Sub 

Dim 

Integer 

Range 

For 

End Sub 

Bemerkung 

gibt ein Unterprogramm, eine Funktion oder eine Variable frei für Zugriffe aus anderen 

Modulen. 

leitet ein Unterprogramm ein. 

explizite Deklaration der Variablen. 

Ganzzahlige Variable, Länge 2 Byte. 

Das Range-Objekt liefert einen Zugriff auf EXCEL-Tabellenfelder. Als Argument ist 

die EXCEL-Adresse, z.B. "VON" oder auch "C1", anzugeben. Mit Range wird sowohl 

aus einem Tabellenfeld gelesen als auch geschrieben (z.B. a = Range("TEST") und 

Range("TEST") = a). 

Mit For · · · Next wird eine Schleife implementiert. Die Laufvariable i durchläuft 

hierbei den Wertebereich von ivon bis ibis in Schritten von eins. 

schließt das Unterprogramm ab. 

Tabelle 3: Anmerkungen zum Programm Summe 

4.1.5 Schritt 5: Programmtests 

Bei einem ersten Programmtest könnte 

die in Abbildung 15 dargestellte 

Fehlersituation auftreten: Die Methode 

Range für das Object _Global ist fehlgeschlagen, 

d.h. der Zugriff auf ein Tabellefeld 

(Lesen oder Schreiben) konnte 

nicht durchgeführt werden. Grund 

dafür ist oft die Angabe einer falschen 

oder unbekannten Range-Adresse. In 

diesem Fall wurde vergessen, die EX- 

CEL-Tabellenfelder, auf die zugegriffen 

werden soll, mit einem entsprechenden 

Namen zu bezeichnen. 


19.10.2011


Wenn in der Absturzmeldung die Funktion 

Debuggen aufgerufen wird, springt 

der Programmzeiger in die Zeile des 

Quellcodes, in der der Fehler aufgetreten 

ist: Gelbe Zeile mit dem Schlüsselwort 

Range. Hier führt der Aufruf zum 

Programmabsturz. Der Grund kann nur 

eine unzulässige EXCEL-Adresse sein. 

Lösung: Vergabe der noch fehlenden Bezeichner 

in der Tabelle. 


4.1.6 Schritt 6: Das Ziel 

Um ein Programm zu testen, sind Aufgabenstellungen 

mit bekanntem Ergebnis 

zu suchen. Ein Programmtest ist 

dann erfolgreich, wenn eine hinreichende 

Anzahl von Testergebnissen reproduziert 

werden kann. Ein absturzfreier 

Durchlauf des Programms alleine ist 

natürlich als Test nicht ausreichend. 

Das Programm Summe berechnet die 

Summe der ganzen Zahlen von 1 bis 7 


zu 28. Auf der rechten Seite der Tabelle 

(siehe Abbildung 17) erfolgt zur Kontrolle eine Berechnung mit der Standard-EXCEL-Funktion 

Summe. Die Ergebnisse sind identisch. 

E. Baeck

5. ELEMENTARE ALGORITHMEN Seite 19 

5 Elementare Algorithmen 

Die Implementierung einfacher Algorithmen in VBA erfolgt in einer EXCEL-Tabelle. Die Eingabefelder 

(gelb hinterlegt) werden mit einem Namen versehen. Über diesen Namen werden die 

Eingabedaten aus den Feldern in den VBA-Code eingelesen (Funktion Range). Die Ergebniswerte 

werden ebenfalls mit der Funktion Range oder im Fall der Ausgabe einer Tabelle mit der 

Funktion Cells in die Tabelle geschrieben. 

Das Programm wird mit einer Schaltfläche gestartet. Es ist darauf zu achten, dass der Programm- 

Code in einem Modul und nicht im Tabellenobjekt abgelegt wird. 

5.1 Fakultät 

Es ist die Faktultät für eine beliebige natürliche Zahl n zu ermitteln. Die Benutzeroberfläche 

ist nach Abbildung 18 zu implementieren. Die Zwischenwerte der Produktbildung sind in einer 

Tabelle auszugeben. Die Abhängigkeit des realisierbaren Definitionsbereichs vom gewählten 

Datentyp (integer, long, etc.) ist zu untersuchen. 

n∏ 

n! = 1 · 2 · · · · · (n − 1) · n = i (2) 

i=1 

Abbildung 18: Oberfläche zur Fakultät und zu Binomialkoeffizienten 

5.2 Binomialkoeffizient 

Es ist der Binomialkoeffizient für zwei beliebige natürliche Zahlen n und m zu ermitteln. Die 

Benutzeroberfläche ist nach Abbildung 18 zu implementieren. Die Zwischenwerte der Produktbildung 

sind in einer Tabelle auszugeben. Die Abhängigkeit des realisierbaren Definitionsbereichs 

vom gewählten Datentyp (integer, long, etc.) ist zu untersuchen. 

⎛ ⎞ 

⎝ n ⎠ = n · n − 1 · · · · · n − m + 1 n! 

= 

m 

m! 

m! · (n − m)! 

(3) 

19.10.2011


5.3 Winkel zwischen 2 Vektoren des R n 

Der Winkel α zwischen 2 Vektoren ⃗a und ⃗ b aus dem R n kann mit Hilfe des Skalarprodukts wie 

folgt berechnet werden. 

( ) 

⃗a ·⃗b 

α = arccos 

||⃗a|| · || ⃗ (4) 

b|| 

Das Skalarprodukt zwischen den Vektoren ⃗a und ⃗ b berechnet sich wie folgt. 

⃗a ·⃗b = 

n∑ 

a i · b i (5) 

i=1 

Die Beträge im Nenner können wie folgt mit dem Skalarprodukt berechnet werde. 

||⃗a|| = √ ⃗a · ⃗a (6) 

5.3.1 Pseudocode für Hauptprogramm 

Der Pseudocode für das Programm könnte wie folgt lauten. 

(1) Einlesen der Vektoren aus Tabelle und Prüfung der Dimensionen. 

(2) Berechnung des Betrages von ⃗a mit der Funktion a = SP rod(⃗a,⃗a). 

(3) Berechnung des Betrages von ⃗ b mit der Funktion b = SP rod( ⃗ b, ⃗ b). 

(4) Berechnung des Skalarprodukts von ⃗a mit ⃗ b mit der Funktion x = SP rod(⃗a, ⃗ b). 

(5) Winkelberechnung α = arccos( x 

a · b ) 

5.3.2 Pseudocode für Funktion SP rod 

Der Pseudocode für die Funktion des Skalarproduktes könnte wie folgt lauten. 

(1) Bestimme die Dimension der Vektoren (Muß identisch sein!). 

(2) Initialisiere die Summenvariable (s = 0). 

(3) Setze Vektorindex auf Startposition (i = 1) 

(4) Berechne für die Position i das Produkt p = a(i) ∗ b(i) 

(5) Summiere das Produkt auf die Summenvariable s = s + p 

(6) Inkrementiere den Vektorindex um 1 

(7) Falls i ≤ n gehe zu (4). 

(8) Beende die Routine mit der Übergabe des Summenwertes s. 

E. Baeck


5.4 Reihenentwicklungen 

Im folgenden wird die Entwicklung der Funktionen sinus, cosinus und der e-Funktion diskutiert. 

5.4.1 Entwicklung der Funktion sinus 

Es ist ein Programm zu implementieren, das die Funktion sinus mit Hilfe der Potenzreiehenentwicklung 

(siehe unten) berechnet. Die Eingabensgrößen sind aus der Tabelle abzugreifen, die 

Ergebnisgrößen sind in den Ausgabebereich der Tabelle zu schreiben. 

Beachten Sie bei der Umsetzung der Gleichung 7, dass die Fakultäten im Nenner der Terme zu 

numerischen Problemen führen können, wenn sie unabhängig vom Zähler berechnet werden. 

Zu beachten ist ferner (siehe Tabelle in Abbildung 19): 

• Der X-Wert ist aus der Tabelle in [ 0 ] zu übernehmen. 

• Die Genauigkeit der Approximation ist aus der Tabelle zu übernehmen. 

• Es ist berücksichtigen, dass das Argument der Reihenentwicklung (siehe Gleichung 7) 

gegebenenfalls in rad umzurechnen ist. 

• In den Ausgabebereich der Tabelle ist der Index des Terms, der Wert des Terms und die 

aktuelle Summe zu schreiben. 

• Bevor die Ergebniswerte in die Tabelle ausgegeben werden, sind die Zeilen des Ergebenisbereichs 

zu löschen. 

sin(x) = x − x3 

3! + x5 

x2n+1 

− · · · + (−1)n 

5! (2n + 1)! ± . . . (7) 

Abbildung 19: EXCEL-Tabelle zur Reihenentwicklung 

19.10.2011


5.4.2 Reihenentwicklung weiterer Funktionen 

Analog zur Entwicklung der sinus-Funktion kann für die Funktion cosinus(x) eine Reihenentwicklung 

programmiert werden (siehe Gleichung 8). 

cos(x) = 1 − x2 

2! + x4 

x2n 

− · · · + (−1)n/2 

4! (2n)! ± . . . (8) 

Analog zur Entwicklung der sinus-Funktion kann für die Funktion f(x) = e x eine Reihenentwicklung 

programmiert werden (siehe Gleichung 9). 

e x = 1 + x 1! + x2 

2! + · · · + xn 

(n)! . . . (9) 

5.5 Newton-Verfahren 

5.5.1 Der Algorithmus des 1-dimensionalen Falls 

Mit dem Newton-Verfahren kann iterativ eine Nullstelle 

einer Funktion f(x) bestimmt werden. Hierfür 

sind ein Startwert x 0 , eine Genauigkeit ɛ und eine 

maximale Iterationsanzahl n x vorzugeben. 

Durch Nullsetzen einer Taylor-Reihenentwicklung 

um den Punkt x n kann die Iterationsformel des 

Newton-Verfahrens abgeleitet werden. 

Abbildung 20: Graphische Darstellung des 

Newton-Verfahrens 

f(x n+1 ) = f(x n ) + (x n+1 − x n ) · f ′ (x n ) = 0 ⇒ (10) 

x n+1 = x n − f(x n) 

f ′ (n = 0, 1, 2, . . . ; x 0 gegeben) 

(x n ) 

Die Ableitung der Funktion f(x) kann durch den Differenzenquotienten angenähert werden. 

f ′ (x) = 

f(x + h/2) − f(x − h/2) 

h 

z.B. mit h = 0.001 (11) 

E. Baeck


5.5.2 Pseudo-Code 

Das Problem kann wie folgt in einem Pseudo-Code (umgangsprachliche Beschreibung) formuliert 

werden. 

1. Wähle einen Startwert x. 

2. Berechne f(x) 

3. Falls |f(x)| < ɛ, dann Nullstelle gefunden. 

4. Falls maximale Anzahl Iterationen erreicht, Ausgabe Fehlermeldung. 

5. Berechne f ′ (x). 

6. Falls |f ′ (x)| < ɛ, Ausgabe einer Fehlermeldung. 

7. Nächsten x-Wert berechnen: x ⇐ x − f(x) 

f ′ (x) 

8. Nächster Iterationsschritt mit Punkt 2. 

Anmerkung: 

Ein Problem tritt auf, wenn die Ableitung der Funktion verschwindet. Geometrisch: es gibt 

keinen Schnittpunkt zwischen Tangente und x-Achse. 

5.5.3 Programmablaufplan 

Das Newtonverfahren geht aus von einem Startwert 

x. Dieser wird zunächst eingelesen. Die Iterationsschleife 

beginnt mit der Berechnung des Funktionswertes 

f(x). Darauf folgt die Nullabfrage. Falls der 

Absolutbetrag des Funktionswertes kleiner als die 

Genauigkeit ɛ ist, wird die Iterationsschleife abgebrochen 

und die Lösung ausgegeben. 

Es folgt die Prüfung der zulässigen Iterationsdurchläufe. 

Nach der Berechnung der Tangentensteigung f ′ (x) 

wird, falls diese nicht verschwindet, ein neuer x- 

Wert berechnet und ein neuer Schleifendurchlauf gestartet. 

Abbildung 21: Programmablaufplan des 

Newton-Verfahrens 

19.10.2011


5.5.4 Nassi-Schneidermann-Diagramm 

Das Nassi-Shneiderman- 

Diagramm zeigt den linearen 

Fluß des Programms. Es werden 

keine Sprünge (Goto) durch 

Verbinder nahe gelegt. 

Im Fall des Erreichens der maximal 

vorgegebenen Iterationsanzahl 

und im Fall verschwindender 

Tangentensteigung wird das Programm 

direkt mit einer entsprechenden 

Meldung abgebrochen. 

Abbildung 22: NS-Diagramm des Newton-Verfahrens 

5.5.5 Die Oberfläche 

In den gelb hinterlegten Tabellenfeldern 

C3-C5 werden die Eingangsgröße, 

der Startwert x, die 

maximal zulässige Anzahl der 

Iterationen und die gewünschte 

Genauigkeit eingegeben. Mit 

der Schaltfläche wird das Programm 

gestartet. In den Ausgabefeldern 

C8-C10 werden die Ergebnisgrößen, 

die eventuell gefundene 

Nullstelle, der durchlaufenen 

Iterationen und eine Kommentierung 

des Iterationsverlaufs ausgegeben. 

Abbildung 23: EXCEL-Tabelle zum Programm 

Im unteren Teil der Tabelle werden die Ergebnisse der einzelnen Interationsschritte ausgegeben. 

E. Baeck


5.5.6 Animation des Verfahrens 

Die animierte Darstellung des Newtonverfahrens 

zeigt die Annäherung an die 

Nullstelle durch konsequentes Verfolgen 

der Funktione (blaue Linie) entlang 

ihrer Tangente (rote Kurve). 

Start der Animation durch Anklicken 

Abbildung 24: Animation des Newton-Verfahrens. 

19.10.2011


6 Elementare Sortiert-Algorithmen 

Einfache Sortieralgorithmen können problemlos zum Sortieren kleiner Datenmengen eingesetz 

werden. Da der Sortieraufwand zumeist in quadratischer Ordnung O(n 2 ) der zu sortierenden 

Datensätze anwächst, sind große Datenmengen i.A. mit diesen Algorithmen nicht mehr wirtschaftlich 

zu sortieren. 

Im folgenden werden zwei der einfachen Sortieralgorithmen dargestellt, 

• Select-Sort oder Auswahlsortierung und 

• Bubble-Sort 

6.1 Select-Sort 

Select-Sort wählt aus einer zu sortierenden 

Menge das größte Element aus 

und tauscht es mit dem Element der 

ersten Position. Aus den verbleibenden 

Elementen wählt er wiederum das 

größte Element aus und tauscht es mit 

dem Element der zweiten Position. Dieses 

Verfahren wird solange fortgesetzt, 

bis die zu durchsuchende Menge auf 

ein Element zusammen geschrumpft ist. 

Der so implementierte Algorithmus ist 

offensicht von quadratischer Ordnung, 

d.h. O(n 2 ), da in einer Schleife alle Positionen 

neu besetzt werden müssen und 

in dieser in einer inneren Schleife der 

Datenbestand - zwar nicht zur Gänze - 

durchlaufen wird, um das aktuell größte 

Element zu bestimmen. 

Abbildung 25: SelectSort: SORTIERANGS 

In Abbildung 25 wird das Wort SORTIERANGS alphabetisch sortiert. In jedem Schritt wird aus 

der aktuellen Sortiermenge der kleinste Buchstabe im Sinne des Alphabets gesucht. Im ersten 

Schritt wird das A gefunden und mit dem Buchstaben der ersten Position S getauscht. Der erste 

Buchstabe der aktuellen zu durchsuchenden Menge wird fett berandet dargestellt. Der kleinste 

Buchstabe wird farbig markiert. In nachfolgenden Zeile wird zum einen der Buchstabentausch 

dargestellt, zum anderen wird die neue Suchmenge und ihr kleinster Buchstabe dargestellt. Um 

die einzelnen Suchschritte visuell abzusetzen wird für jeden Such- und dazugehörigen Tauschschritt 

eine eigene Hintergrund-Farbe gewählt. 

E. Baeck

6. ELEMENTARE SORTIERT-ALGORITHMEN Seite 27 

6.2 Bubble-Sort 

Die Idee des Bubble-Sort-Algorithmuses folgt der Vorstellung von aufsteigenden Luftblasen in 

einer Flüssigkeit. Vom letzten Element an wird in einer inneren Schleife vom ersten Element an 

bis zum betrachteten dann eine Vetauschung ausgeführt wenn das Element der inneren Schleife 

größer (bzw. kleiner) 3 ist als das betrachtete. So steigen die größeren (bzw. kleineren) Element 

nach vorne auf wie Luftblasen in einer Flüssigkeit (Bubble-Sort). 

Im Vergleich zu SelectSort benötigt BubbleSort einen unnötig hohen Aufwand des Vertauschens. 

3 Abhängig von der Sortierrichtung steigt entweder das kleinere oder größere Element auf Richtung Platz 1. 

19.10.2011


7 Arbeiten mit Dateien 

7.1 Dateioperationen für sequentiellen Zugriff 

Die Datei wird geöffnet unter Vorgabe des Dateinamens und des Verarbeitungskenners (Input, 

Output, Append). Die Zugriffe auf die Datei erfolgen unter Vorgabe der Kanalnummer. 

In nachfolgender Tabelle werden wesentliche Dateifunktionen zusammengefaßt. 

Funktion Beschreibung Beispiel 

Open Öffnen einer Datei. Open "bsp.txt" For Input As #1 

Input Einlesen aus einer Datei. Input #1, x, y 

Write Schreiben ín eine Datei. Write #1, x, y 

Close Schließen der Daten. Close #1 

Input Line Einlesen einer Datenzeile aus Textdatei. Input Line #1, s 

EOF Dateiende erkennen. Do While Not EOF(1) 

Die EXCEL-Anwendung liefert einen Standarddialog zur Suche einer Datei. Der Aufruf dieses 

Dialogs wird in nachfolgendem Code dargestellt. 

Die im nachfolgenden Beispiel dargestellte Funktion wird als Steuerprogramm zur Berechnung 

des Torsionsträgheitsmomentes nach der Brendt’schen Formel eingesetzt (siehe Gleichung 12). 

Im 2. Schritt wird die Methode GetOpenFilename des Application-Objekts 4 aufgerufen. Die 

Methode startet den allgemeinen Windows-Datei-Öffnen-Dialog. Als Rückgabewert liefert die 

Methode den Namen der gewählten Datei. Wird der Dialog vom Anwender abgebrochen, so 

wird der String Falsch zurückgegeben. 5 

’ Dateinamen ermitteln 


’ 1: Initialisierung 

Call Brendt.Init 

’ 2: Dateinamen festlegen 

datei$ = Application.GetOpenFilename( _ 

fileFilter:="Textdateien (*.txt),*.txt") 

’ 3: Starten der Berechnung 

If Not datei$ = "Falsch" Then 

Range("Datei") = datei$ 

’ Einlese der Datei und Berechnung 

Call Brendt.ProfilLesen(datei$) 

4 Das Objekt Application, siehe auch OOP, stellt alle Objekte der EXCEL-Anwendung zur Verfügung. Objekt 

der EXCEL-Anwendung sind z.B. die Listen der Tabellen und Diagramme, sind auch die Range-Objekte, die die 

Kommunikation mit den Tabellenfeldern ermöglicht. 

5 Mit der Rückgabe Falsch im Fall des Abbruchs ist es unzulässig eine Datei mit dem Namen Falsch anzusprechen, 

was i.A. kein Problem sein dürfte. 

E. Baeck

7. ARBEITEN MIT DATEIEN Seite 29 

Call Brendt.ProfilBerechnen 

End If 

End Sub 

7.2 Torsionsträgeheitsmoments nach 2. Brendt’scher Formel 

In einer Datei wird eine beliebige, konvexe Kontur eines Profils durch Punkte auf der Mittelfläche 

im üblichen y-z-Koordinatensystem beschrieben (x-Achse ist Profillängsrichtung). Zu 

jedem Punkt wird als dritter Wert die Dicke des Profils am Ort des Punktes angegeben. 

Das Programm zur Berechnung des Torsionsträgheitsmomentes nach der 2. Brendt’schen Formel 

erhält die folgenden Optionen. 

• Einlesen und Speichern der Datei in dynamisch angelegten Feldern (Arrays), wobei die 

Information eines Punktes in einer benutzerdefinierten Strukur (TYPE/END TYPE) gehalten 

werden soll. Um eine zyklische Profilbeschreibung zu erleichtern, sind die Daten des 

ersten Punktes als zusätzlicher der Punktliste anzuhängen. 

• Ausgabe der Daten des Feldes in einer Tabelle. Die Altdaten werden zunächst mit der 

Funktion Löschen aus der Tabelle entfernt. 

• Ausgabe der Profilkontur in einem Diagramm in Form eines X-Y-Plots. 

• Berechnung des Torsionsträgheitsmoments mit Hilfe der 2. Brendt’schen Formel. 

I T = (2 · A m) 2 

∮ ds 

t 

(12) 

Im Fall dünnwandiger Profile kann die Gleichung 12 wie folgt vereinfacht werden. 

1. Zunächst ist das Linienintegral durch die Summe ∑ N L i 

i=1 

L i = √ (y i − y i+1 ) 2 + (z i − z i+1 ) 2 und t i = 0.5 · (t i + t i+1 ). 

t i 

zu berechnen, wobei 

2. Die Fläche der Kontur kann mit der folgenden Formel zur Bestimmung einer Polgonfläche 

ermittelt werden. 

A m = 

N∑ 

i=1 

y i · z i+1 − z i · y i+1 

2 

(13) 

mit: y N+1 = y 1 , und z N+1 = z 1 

19.10.2011


8 Das Clapeyron-Problem 

Mit der Gleichung nach Clapeyron können die Stützmomente eines n-Feldträgers (Durchlaufträger) 

berechnet werden. Die Herleitung der Gleichung 6 aus dem Kraftgrößenverfahren wird in 

Abschnitt A dargestellt. 

Der Abschnitt zeigt exemplarisch die wesentlichen Schritte der Entwicklung eines Berechnungsprogramms 

mit moderner Eingabeoberfläche und entsprechender Datenhaltung. 

8.1 Motivation 

In diesem Abschnitt wird die Entwicklung eines Programms zur Berechnung der Stützmomente 

eines n-Feld-Durchlaufträgers dargestellt. Es werden als Belastungen Streckenlasten, Punktlasten 

und Punktmomente vorgesehen, die beliebig auf den Feldern des Trägers positioniert werden 

können. 

Die Entwicklung erfolgt den Schritten: 

1. Gestaltung der Eingabe in einer Benuzteroberfläche. 

2. Modellierung der Datenstrukturen und Visualisierung im ER-Modell. 

3. Algorithmus zur Generierung der Modell-Datenstrukturen. 

4. Algorithmus zum Aufbau des linearen Gleichungssystems (A · x = b). 

5. Cholesky-Algorithmus zur Zerlegung der Matrix A = L · L T . 

6. Berechnung der Stützmomente durch Vorwärts- Rückwärtseinsetzen. 

7. Ausgabe der Ergebnisgrößen in der Benutzeroberfläche. 

8.2 Oberflächenlayout und Eingabe 

Als Eingabeoberfläche wird eine EXCEL-Tabelle eingesetzt, in der die Felder bzw. die Belastungen 

der Felder in Listenform eingetragen werden. Die Eingabetabelle orientiert sich ausschließlich 

an den Bedürfnissen des Anwenders und enthält keinerlei Daten, die nur durch die Organisation 

der Daten im Programm (Datenstrukturen) betreffen. 

Generell sollte sich die Eingabeoberfläche eines Programms nur an der Sicht des Anwenders 

orientieren. So sollten keine für die Gestaltung der Datenstruktur wichtigen Parameter als Eingabeparameter 

vorgesehen werden, da deren Notwendigkeit dem Anwender kaum vermittelbar 

ist. 

Die Anzahl der Felder z.B. ergibt sich aus ihrer Beschreibung. Die Vorgabe der Anzahl der 

gewünschten Felder wäre somit für den Anwender eine redundante Eingabe. Die Anzahl der 

Felder ist für die Dimensionierung der Feldvariabeln erforderlich und ist vom Programm aus 

den Eingaben des Anwenders abzuleiten. 

6 Die Gleichung von Clapeyron wird auch 3-Momentengleichung genannt. 

E. Baeck

8. DAS CLAPEYRON-PROBLEM Seite 31 

Im Vorschlag der 

Eingabe werden 

die Felder von 

links nach rechts 

eingegeben. Die 

Feldnummerierung 

ergibt sich automatisch 

aus der 

Reihenfolge. 

Abbildung 26: Eingabe Oberfläche des Programms 

8.2.1 Feldbeschreibung 

Die Felddaten können in Form einer Liste eingegeben werden. Die Reihenfolge entspricht der 

Feldreihenfolge vom Festlager (links) hin zum Gleitlager (rechts), siehe z.B. Abbildung 43. Pro 

Feld werden 

• die Feldlänge in [cm] und 

• das Verhältnis der Flächenträgheit zur Referenzträgheit I c 

eingegeben. Das Import-Programm liest die Datensätze von oben nach unten aus der Tabelle 

und schreibt die erfassten Daten in ein Feld aus entsprechenden Datenstrukturen. Die Dimensionierung 

ergibt sich aus der Anzahl der Datensätze. 

8.2.2 Lastbeschreibung 

Die Lastdaten können beliebig in Form einer Liste eingegeben werden. Ein Lastdatensatz enthält 

die folgenden Daten. 

• Die Lastfallnummer, Wahl der rechten Seite (siehe Abschnitt D). 

• Die Feldnummer beschreibt den Ort der zu erfassenden Last. 

• Der Belastungstyp: 

– Typ 1, die Streckenlast 

Parameter: Lastordinate q, Abszisse des Lastschwerpunktes a und Lasteinleitungslänge 

c. 

– Typ 2, die Punktlast 

Parameter: Lastordinate P , Abszisse der Lasteinleitung a. 

– Typ 3, das Punktmoment 

Parameter: Lastordinate M, Abszisse der Lasteinleitung a. 

• Lastordinate für Typ 1, q, in [kN/cm], für Typ 2, P , in [kN] und für Type 3 M in [kNcm]. 

Dieses Eingabefeld und alle weiteren beschreiben die Details der gewünschten Last. 

19.10.2011


• Der Parameter a beschreibt den Abstand des Lastschwerpunktes vom linken Lager in [cm] 

(für alle Typen relevant). 

• Der Parameter c beschreibt die Länge der Lasteinleitung in [cm] (nur für Typ 1 relevant). 

8.3 ER-Modell der Datenstruktur 

Das ER-Modell (nach Chen siehe Abschnitt B) der Datenstruktur des Clapeyron-Problems besteht 

aus zwei Teilen, dem Datenmodell der Struktur und dem Datenmodell der Belastung. 

In den Diagrammen zum Struktur- und Lastdantenmodell des Clapeyron-Problems werden Container-Objekte 

kursiv geschrieben. Container-Objekte sind Objekte, die eine beliebige Anzahl 

von Objekten aufnehmen können. In diesem Beispiel werden einfache Datenfelder eingesetzt. In 

VBA werden diese durch die Vorgabe des Index-Bereiches vereinbart. 

Beispiele 1: Statische Deklaration eines Containers für 20 Felder 

Dim FA(1 to 20) As Feld 

Beispiele 2: Dynamische Deklaration eines Containers für n Felder 

Dim FA() As Feld 

... 

n = ... 

Redim FA(1 to n) 

8.3.1 ER-Modell der Struktur 

Das System des Durchlaufträgers 

besteht aus mehreren 

Feldern. Diese werden in dem 

Objekt Felder zusammen gefaßt. 

Die Anzahl der Felder ist 

theoretisch Unbeschränkt, somit 

eine 1-n-Beziehung. Ein Feld 

hat die Attribute Länge und 

Trägheit (siehe Abbildung 27). 

Abbildung 27: ER-Modell der Struktur 

Aufgabe 8.3.1: 

Es sind dem ER-Modell entsprechende Datenstrukturen (Schlüsselwort Type ... End Type) in 

VBA zu entwickeln. 

E. Baeck


8.3.2 ER-Modell der Belastung 

Das Datenmodell der Belastung 

geht aus von einem 

Container (Liste oder Feld) 

der Lastfälle. Der Container 

kann beliebig viele Lastfälle aufnehmen 

(1-n-Beziehung). Jeder 

Lastfall enthält wiederum drei 

Container. Der erste Container 

enthält die Streckenlasten, 

der zweite die Punktbelastungen 

und der dritte die Punktmomente. 

Jeder dieser drei Beziehungen 

ist eine 1-n-Beziehung, 

da jeder Container beliebig viele 

Lasten aufnehmen kann. 

Ein Lastfall hat das Attribut Nr, 

er weiß sozusagen, wie er heißt. 

Die Lastarten haben als Attribute 

ihre Parameter, Lastordinate, 

Lastabszisse und die 

Streckenbelastung hat zudem 

das Attribut der Lasteinleitungslänge. 

Abbildung 28: ER-Modell der Belastung 

Aufgabe 8.3.2: 

Es sind dem ER-Modell entsprechende Datenstrukturen (Schlüsselwort Type ... End Type) in 

VBA zu entwickeln. 

19.10.2011


8.4 Aufbau der Datenstruktur 

In diesem Abschnitt wird ein Algorithmus zum Aufbau der Datenstrukturen für System und 

Belastung entwickelt. 

8.4.1 Die Datenstruktur des Systems 

Die Daten eines Feldes werden in der Struktur 

(Type) Feld abgespeichert. Als Container 

wird zunächst ein Datenfeld eingesetzt. 

Dieses wird dynamisch an die zu speichernde 

Datenmenge angepaßt (dynamisches Allokieren). 

Da die Anzahl der Felder nicht explizit 

festgelegt wird, ist diese zunächst aus den Eintragungen 

der Tabelle zu ermitteln. Die ausgefüllten 

Tabellenfelder der Spalte Feldlänge 

(siehe Abbildung 26) werden im ersten Durchlauf 

gezählt, um den Container dimensionieren 

zu können. 

Wenn die Feldanzahl feststeht, wird der Container 

entsprechend dimensioniert. In einem 

zweiten Durchlauf über die Tabelle wird die 

Feldlänge und das Trägheitsverhältnis eines 

Abbildung 29: Aufbau der Strukturdaten 

Feldes ausgelesen und in die Feldstruktur eingetragen. 

Die Feldstruktur wird in den Container aufgenommen. 

Aufgabe: 

Es ist ein Programm zu implementieren, dass aus der Tabelle der Abbildung 26 die Daten der 

Felder ausliest und diese in einem Container passender Größe abspeichert. 

Hinweis: 

Der Container wird mit dem Schlüsselwort Dim [Bezeichnung]() As [Type] und 

ReDim [Bezeichnung](1 to nFeld) angelegt. Der Zugriff auf die Tabellenfelder erfolgt 

mit dem Objekt Cells (i,j), wobei Cells (1,1) der Tabellenadresse A1 entspricht. 

E. Baeck


8.4.2 Die Datenstruktur der Belastungen 

Der Aufbau der Datenstrukturen für die Belastungen 

erfolgt in drei Durchläufen. In jedem 

Durchlauf werden die Datenfelder neu Eingelesen 

und nach anderen Kriterien ausgewertet. 

Im ersten Durchlauf werden die extremalen 

Lastfallnummern ermittelt (siehe Abbildung 

30). Im Intervall zwischen den extremalen 

Lastfallnummern wird ein Indexvektor aufgestellt, 

der mit der Lastfallnummer indiziert 

wird. 

Abbildung 30: Ermitteln extremaler Lastfallnummern 

Aufbau des Lastfall-Indexvektors 

In den Lastfall-Indexvektor ist in einem zweiten 

Durchlauf 

• die gefundene Lastfallnummer, 

• die Anzahl der Streckenlasten zu diesem 

Lastfall, 

• die Anzahl der Punktlasten zu diesem 

Lastfall und 

• die Anzahl der Punktmomente zu diesem 

Lastfall 

einzutragen. Das Eintragen erfolgt durch 

schrittweises Hochzählen der gefundenen 

Lastdaten (siehe Abbildung 31). 

Abbildung 31: Ermitteln der Lastdatenanzahlen 

19.10.2011


Aufbau der Datenstruktur 

Der Lastfall-Container wird im Bereich der 

gefundenen Lastfallnummern angelegt, d.h. 

ein Lastfall wird direkt über seine Nummer 

angesprochen, auf eine kompakte Speicherung 

wird hier verzichtet, da die Datenstruktur der 

Belastung abgesehen von der Lastfallnummer 

zunächst nur leere Container für die Lastdaten 

enthält. 

Abbildung 32: Aufbau der Last-Datenstruktur 

In einer Schleife über den Lastfall-Indexvektor ILF wird für jeden vorhandenen Lastfall 

• die Lastfallnummer aus ILF übertragen, 

• falls Streckenlasten vorhanden, ein Container ausreichender Größe für diese dimensioniert, 

• falls Punktlasten vorhanden, ein Container ausreichender Größe für diese dimensioniert 

und 

• falls Punktmomente vorhanden, ein Container ausreichender Größe für diese dimensioniert. 

Wie viele Streckenlasten, Punktlasten und Punktmomente vorhanden sind, ist dem entsprechenden 

Zähler des Lastfall-Indexvektors zu entnehmen (ILF(lf).sl, ILF(lf).pl und ILF(lf).pm). 

Einlesen der Lastdaten 

Bevor die Lastdatensätze eingelesen werden 

können, werden die Lastdatenzähler im 

Lastfall-Indexvektor zurück gesetzt (d.h. auf 

0 gesetzt). Die Einleseschleife läuft sodann 

über alle Lastdatensätze. Es werden zunächst 

Lastfallnummer und Lasttyp eingelesen. Der 

Zähler des vorliegenden Lastfalls bzw. des 

vorliegenden Lasttyps wird inkrementiert, um 

ein fortlaufendes Einspeichern der Lastdaten 

in den Container zu ermöglichen. Mit diesem 

inkrementierten Zähler wird sodann der 

Lastdaten-Container (Streckenlast, Punktlast 

oder Punktmoment) indiziert. Die Lastdaten 

werde aus der Tabelle mit der Funktion Cells 

gelesen und in den entsprechenden Container 

übertagen (siehe Abbildung 33). 

Abbildung 33: Einlesen der Lastdaten 

E. Baeck


8.5 Aufbau des Linearen Gleichungssystems 

In diesem Abschnitt wird aus den Daten der Datenstrukturen der Felder und Lasten (siehe 

Abschnitt 8.4) das lineare Gleichungssystem entwickelt. 

8.5.1 Aufbau der Koeffizientenmatrix 

Die Koeffizienten-Matrix A eines n-Feldträgers (siehe Gleichung 33) hat die Dimension (n−1)⊗ 

(n − 1) und ist zudem (siehe Gleichung 28) 

• symmetrisch mit 

• Bandstruktur der Bandweite 1 7 . 

Für einen 5-Feldträger der Feldlängen l 1 bis l 5 ergibt sich die folgende Koeffizienten-Matrix. 

⎡ 

⎤ 

2 · (l 1 + l 2 ) l 2 0 0 

l 

A = 

2 2 · (l 2 + l 3 ) l 3 0 

(14) 

⎢ 0 l 

⎣ 

3 2 · (l 3 + l 4 ) l 4 ⎥ 

⎦ 

0 0 l 4 2 · (l 4 + l 5 ) 

Da die Symmetrie der Matrix A während der Zerlegung erhalten bleibt (siehe Abschnitt D.3), 

kann auf das Abspeichern der oberen Hälfte der Matrix A verzichtet werden. 

Im Fall der Clapeyron’schen Gleichung ist zudem nur die erste Nebendiagonale besetzt, d.h. 

es ist nur erforderlich, die Diagonale und die erste Nebendiagonale von A zu speichern. Eine 

kompakte Speicherung einer symmetrischen Bandmatrix mit Bandbreite m erfordert die folgende 

Indexsubstitution. 

a i,k → a i,k−i+m+1 (k ≤ i) (15) 

Mit der Indexsubstitution (15) folgt für die Matrix (14) 

⎡ 

⎤ 

0 2 · (l 1 + l 2 ) 

l 

A = 

2 2 · (l 2 + l 3 ) 

⎢ l 

⎣ 3 2 · (l 3 + l 4 ) ⎥ 

⎦ 

l 4 2 · (l 4 + l 5 ) 

(16) 

7 Die Bandweite einer Matrix ist gegeben durch die Anzahl der besetzten Nebendiagonalen. 

19.10.2011


Der erforderliche Speicher für die Koeffizientenmatrix 

eines n-Feldträger ergibt sich somit 

zu (n − 1) · 2 (siehe (16)). 

Die Besetzung der Matrix folgt aus (16). In die 

erste Spalte werden die Feldlängen geschrieben, 

wobei die erste Feldlänge durch 0 erstetzt 

wird. In der zweiten Spalte steht die zweifache 

Summe aufeinander folgender Felder. Der Algorithmus 

des Aufbaus wird in Abbildung 34 

Abbildung 34: Aufbau der Koeffizientenmatrix 

dargestellt. Die Länge des i-ten Feldes l i , wird 

aus dem Feld-Container abgegriffen und mit dem Trägheitsverhältnis skaliert FA(i).L/FA(i).dI 

(siehe Abschnitt A) 

Durch die kompakte Speicherung der Matrix reduziert sich der erforderliche Speicher wie folgt. 

A kompakt 2 · (n − 1) 

= 

A komplett 

(n − 1) 2 = 2 

n − 1 

(17) 

Im betrachteten Beispiel des 5-Feldträgers reduziert sich der erforderliche Speicherplatz auf 

2 

5−1 = 1 2 

2 

101−1 = 1 

50 

= 50%. Im Fall eines 101-Feldträgers beträgt der erforderliche Speicherplatz bereits 

= 2% der Gesamtmatrix. 

8.5.2 Aufbau der Lastvektoren 

Die Lastvektoren werden der Einfachheit halber nicht dicht sondern im Intervall [lf min , lf max ] 

angelegt. Ob ein Lastvektor Lasten enthält oder nicht ergibt sich aus der Summe der Lastdatensätze 

eines Lastfalls (siehe Lastfall-Indexvektor Abschnitt 8.4.2). Für die drei Lastarten 

werden Lastgeneratoren implementiert. Die generierten Lastdaten werden in den Lastvektor 

aufsummiert. 

Nach [1] ergibt sich für den i-ten Eintrag in den Lastvektor, d.h. für das rechte Stützmoment 

des i-ten Feldes 8 . 

• für eine Streckenlast aus linksseitigem Feld 

b i,l = −R i−1 · l i−1 = −q · a · c 

(1 − α 2 − 1 ) 

4 · γ2 · l i−1 (18) 

• für eine Streckenlast aus rechsseitigem Feld 

b i,r = −L i · l i = −q · b · c 

(1 − β 2 − 1 ) 

4 · γ2 · l i (19) 

8 Es werden die folgenden Abkürzungen verwendet: α = a l , β = b l = l − a 

l 

und γ = c l 

E. Baeck


• für eine Punktlast aus linksseitigem Feld 9 

b i,l = −R i−1 · l i−1 = −P · a · b (1 − α) (20) 

• für eine Punktlast aus rechtsseitigem Feld 

b i,r = −L i · l i = −P · a · b (1 − β) (21) 

• für ein Punktmoment aus linksseitigem Feld 10 

b i,l = −R i−1 · l i−1 = M L · (1 

− 3 · α 2) · l i−1 (22) 

• für ein Punktmoment aus rechtsseitigem Feld 

b i,r = −L i · l i = −M L · (1 

− 3 · β 2) · l i (23) 

9 Die Feldlängen kürzen sich aus den Termen für Punktlasten. 

10 M L ist ein linksdrehendes (mathematisch positives) Moment. Der Vorzeichenwechsel folgt aus der Symmetrie. 

19.10.2011


9 VBA-Objekte 

Objekte oder Klassen im Sinne der OOP (objektorientierten Programmierung) werden in VBA 

mit Klassenmodul bezeichnet. Die Klassenbestandteile (siehe UML in Abschnitt C) bestehen 

aus den folgenden Komponenten. 

• Die Bezeichnung des Klassenmoduls ist die Klassenbezeichnung. 

• Globale Variablen eines Klassenmoduls sind die Klassenattribute. 

• Die Funktionen und Programme in einem Klassenmodul sind die Methoden der Klasse. 

Auf alle Mechanismen der Vererbung von Klassen (Generalisierung, Polymorphismus), die in 

den meisten Programmiersprachen der OOP implementiert werden, wird in VBA aus Sicherheitsgründen 

verzichtet. 

9.1 Konstruktor und Destruktor 

Jeder Klassenmodul hat die folgenden Methoden. 11 

• Der Konstruktor Class Initialize 

Diese Methode wird aufgerufen, wenn eine Instanz des Klassenmoduls mit dem new- 

Operator (set s = new Stab) erzeugt wird. Im Beispiel wird das Objekt Stab initialisiert. 

Es werden Fläche und E-Modul vorbelegt. Es werden die Instanzen der Knoten- 

Klassenmodul für die Stabenden erzeugt. 

Private Sub Class_Initialize() 

Set Ka = new Knoten 

Set Kb = new Knoten 

Fl = 0# 

Em = 210000# 

End Sub 

• Der Destruktor Class Terminate 

Wenn eine Instanz eines Klassenmoduls zerstört wird, d.h. aus dem Speicher entfernt 

wird, wird zunächst diese Methode aufgerufen, um dem Programm die automatisierte 

Möglichkeit zu bieten, Aufräumarbeiten auszuführen. Das Zerstören einer Instanz erfolgt 

mit dem nothing-Operator (set s = nothing). 

Im nachfolgenden Beispiel werden vor dem Entfernen eines Stab-Objekts dessen beide 

Knoten-Instanzen entfernt. 12 

Private Sub Class_Terminate() 

Set Ka = nothing 

Set Kb = nothing 

End Sub 

11 Die Beispiele dieses Abschnitts beziehen sich auf die Objekte Knoten und Stab des Abschnitts 9.4). 

12 Da in VBA nur dann ein Objekt vernichtet wird, wenn alle Verweise auf nothing gesetzt werden, können alle 

Knoten-Instanzen durch den dargestellten Destruktor vernichtet werden. 

E. Baeck

9. VBA-OBJEKTE Seite 41 

9.2 Vektoren und Matrizen 

Vektoren- und Matrizen können im Sinne der OOP 

als Klassenmodule implementiert werden. Abbildung 

35 zeigt hierfür ein UML-Klassendiagramm. 

Im Konstruktor (Class Initialize) werden Standard- 

Dimensionen gesetzt. Im Beispiel des Anhangs wird 

mit n = 3 das Feld des Vektors bzw. das Feld der 

Matrix x dimensioniert. Der Vektor wird als Einheitsvektor 

in x-Richtung initialisiert (1, 0, 0). 

Abbildung 35: Vektor- und Matrix-Objekte 

9.2.1 Methoden des Klassenmoduls Vektor 

Methode Anmerkung 

Laenge 

Norm 

Rot 

SP rod 

SetX 

GetX 

Xi 

List 

Berechnung und Rückgabe der Vektorlänge 

Normierung der Vektor-Instanz 

Multiplikation des Vektors mit einer Matrix-Instanz 

Skalare Multiplikation mit anderer Vektor-Instanz 

Belegen der Vektor-Elemente (Übergabe mit Feld) 

Lesen der Vektor-Elemente (Übergabe mit Feld) 

Lesen einer Vektor-Komponente 

Kontrolausgabe der Vektor-Attribute 

9.2.2 Methoden des Klassenmoduls Matrix 

Methode Anmerkung 

SetX 

GetX 

GetK 

List 

Belegen der Matrix-Elemente (Übergabe mit Feld) 

Lesen der Matrix-Elemente (Übergabe mit Feld) 

Lesen eines Matrixelements 

Kontrolausgabe der Matrix-Attribute 

19.10.2011


9.3 Die Containerklasse Collection 

Mit dem in VBA implementierten Klassenmodul Collection wird die Möglichkeit geschaffen, auf 

einfache Weise Instanzen von Klassenmodulen in Listen-Form abzuspeichern. 13 Die gespeicherte 

Instanz kann optional über den Index oder über einen freiwählbaren Schlüssel angesprochen 

werden. Die Collection bietet hierbei ein automatisches Speichermanagement, das jederzeit für 

ausreichenden Speicher sorgt. 

Die Collection bietet die foldenden Methoden. 14 

• Add 

Mit Add kann eine Instanz einer Klasse in die Liste übernommen werden. 

Parameter Anmerkung 

Item 

Key 

Before 

After 

Zeiger auf Instanz eines Objekts 

Objektbezeichnung der Instanz 

Objektbezeichnung für Einfügen vor 

Objektbezeichnung für Einfügen nach 

Beispiel: 

Das folgende Beispiel zeigt das Erzeugen zweier Instanzen des Klassenmoduls Knoten. Die 

Adressen der Instanzen werden in der Collection unter den Bezeichnungen Knoten 1 und 

Knoten 2 abgespeichert. 

dim Kn as Knoten 

set Kn = new Knoten 

Liste.Add item:= Kn key:="Knoten 1" 

set Kn = new Knoten 

Liste.Add item:= Kn key:="Knoten 2" 

• Item 

Mit der Methode Item wird die Adresse einer Instanz eines Klassenmoduls aus der Collection 

gelesen. Die Methode hat die folgenden Parameter. 


Index 

Index der zu lesenden Instanz oder 

dessen Bezeichnung (d.h. key), siehe Add-Methode. 

Beispiel: 

In nachfolgendem Beispiel wird aus der Collection der Bezeichnung Liste die Adresse der 2. 

Instanz gelesen. Hierfür kann optional auf das explizite Notieren der Methodenbezeichnung 

Item verzichtet werden (Variante 2). In der 3. Variante wird die Adresse der Instanz 

über deren Bezeichnung gelesen. In allen Varianten wird die gelesene Adresse der Objekt- 

Variablen Kn mit dem Operator Set zugewiesen. 15 

13 Die Beispiele dieses Abschnitts beziehen sich auf die Objekte Knoten und Stab des Abschnitts 9.4). 

14 Bedauerlich an der Implementierung der Collection ist, dass auf alle Fehlerprüfungen verzichtet wurde, d.h. 

es gibt keine Fehlerkenner in der Rückgabe. Wird z.B. auf ein nicht vorhandenes Element zugegriffen, stürzt das 

Programm ab, wenn nicht durch einen Fehlerhandler der Fehler abgefangen wird, was eine für diese Situation 

recht aufwendige Mimik erfordert. 

15 Kurioserweise wurde bei der Implementierung der Collection auf eine Inquire-Methode verzichtet, mit deren 

Hilfe die Existenz einer Instanz in der Collection ermittelt werden könnte. 

E. Baeck


dim Kn as Knoten 

set Kn = Liste.Item(2) 

set Kn = Liste(2) 

set Kn = Liste.Item("Knoten 2") 

• Remove 

Mit der Methode Remove wird eine in der Collection gespeicherte Instanz-Adresse 

gelöscht. Es wird nur der Eintrag der Adresse gelöscht, nicht die Instanz selbst. 16 


Index 

Index der zu löschenden Instanz oder 

dessen Bezeichnung (d.h. key), siehe Add-Methode. 

Beispiel: 

In nachfolgendem Beispiel wird zunächst der 1. Eintrag aus der Collection entfern. Anschließend 

wird eine Instanz mit der Bezeichnung Knoten 2 entfernt. 

Liste.Remove(1) 

Liste.Remove("Knoten 2") 

• Count 

Mit der Methode Count wird die Anzahl der in der Collection gespeicherten Instanz- 

Adressen zurückgegeben. 

Beispiel: 

In nachfolgendem Beispiel werden in einer Schleife alle Einträge aus einer Collection entfernt. 

Dies erfolgt durch n-faches Löschen des ersten Eintrages, da nach Löschen eines 

Eintrages die Indizierung lückenlos aktualisiert wird, d.h. der vormals 2. Eintrag der Liste 

rückt auf die 1. Stelle vor, nachdem der 1. Eintrag entfernt wurde. Die Anzahl der 

gespeicherten Einträge n liefert die Methode Count. 

n = Liste.Count 

for i=1 to n 

Liste.Remove(1) 

next 

16 Eine Instanz wird dann gelöscht, wenn allen Objektvariablen, die auf diese Instanz verweisen, der Wert 

nothing zugewiesen wird. 

19.10.2011


9.4 Datenstruktur eines Stabwerks 

Ein Stabwerk besteht aus n-Stäben. Ein Stab hat die Attribute 

E-Modul und Querschnittsfläche (beide double). 

Die Geometrie eines Stabes wird beschrieben durch den 

Start- und den Endknoten. Als Attribut erhält eine Stab- 

Instanz den Verweis (Objektvariable) auf zwei Knoten- 

Instanzen, d.h. eine Knoten-Instanz wird i.A. von mehreren 

Stab-Instanzen referenziert. 

Abbildung 36: Datenstruktur eines 

Stabwerks 

Der in Abbildung 37 dargestellte 

Rahmen ist auf der Grundlage des 

in Abbilung 36 dargestellten UML- 

Diagrammes zu implementieren. Die 

Daten des Rahmens sind aus der in Abbildung 

38 dargestellten Tabelle auszulesen. 

Nach Aufbau der Datenstruktur 

sind die Rahmendaten mit der Funktion 

List im Ausgabebereich der Tabelle 

anzulisten. 

Die Knotendaten sind in der Collection 

KListe, die Stäbe in der Collection SListe 

abzuspeichern. 

Abbildung 37: Rahmenbeispiel 

E. Baeck


9.4.1 Die Oberfläche 

Mit der Klassen-Methode Verschieben 

ist der Rahmen mit einer zweiten Ereignisfunktion 

um den vorgegebenen Verschiebungsvektor 

zu verschieben. Das 

Ergebnis der Verschiebung ist erneut in 

der Tabelle auszugeben. 

Zudem ist mit der Stab-Methode Laenge 

die Stablänge zu ermitteln und diese 

in der entsprechenden Tabellenspalte 

einzutragen. 

9.4.2 Methoden des Punktes 

Abbildung 38: Eingabetabelle 

Für das Punkt-Objekt sind die folgenden Methoden zu implementieren. 

• Verschieben 

Auf die Koordinaten des Knotens wird der Verschiebungsvektor v aufaddiert. 

⎛ ⎞ ⎛ ⎞ ⎛ ⎞ 

⎝ x ⎠ ⇐ ⎝ x ⎠ + ⎝ v x 

⎠ (24) 

y y v y 

• Drehen 

Auf den Ortsvektor des Knotens wird die Drehmatrix zum Winkel ϕ aufmultipliziert. 17 

⎛ ⎞ ⎛ 

⎞ ⎛ ⎞ 

⎝ x ⎠ ⇐ ⎝ + cos(ϕ) − sin(ϕ) ⎠ · ⎝ x ⎠ (25) 

y + sin(ϕ) + cos(ϕ) y 

• Listen 

Die Ausgabe der Knotenattribute x und y in ein Tabellenfeld erfolgt zweckmäßig unter 

Vorgabe des Tabellenadressenursprungs (Spalten- und Zeilennummer für die Funktion 

Cells). 

9.4.3 Methoden des Stabes 

Für den Stab sind die folgenden Methoden zu implementieren. 

• Länge 

l = √ (x a − x b ) 2 + (y a − y b ) 2 (26) 


Es sind nach (24) beide Knoten des Stabes zu verschieben. 

17 Generell sind die Winkel in Winkelfunktionen der Programmiersprachen in rad einzusetzen. Die Umrechnung 

von ◦ in rad erfolgt unter Ausnutzung der Rechengenauigkeit mit der Skalierung atan(1)/45 ◦ . 

19.10.2011


• Drehen 

Es sind nach (25) beide Knoten des Stabes zu drehen. 

• Listen 

Die Ausgabe der Stab- und Knotenattribute in eine Tabelle erfolgt zweckmäßig unter Vorgabe 

des Tabellenadressenursprungs (Spalten- und Zeilennummer für die Funktion Cells). 

9.5 2-fach verkettete lineare Listen 

Lineare Listen können als rekursive Datenstrukturen 

implementiert werden. Ein Listen-Objekt (hier VNode) 

enthält bei 2-facher Verkettung (als Attribute) einen Zeiger 

auf das vorhergehende (hier prv)und einen Zeiger auf 

das nachfolgende Listen-Objekt (hier nxt). Mit dieser Verkettung 

ist es bei vorgegebenem Listen-Objekt möglich, 

über die Verkettung einerseits bis zum ersten Listen- 

Objekt zurück, andererseits zum letzten Listen-Objekt 

vorwärts zu laufen. 

Üblicherweise wird die verkettete Liste durch ein spezielles 

Objekt eröffnet bzw. abgeschlossen. Diese beiden Objekte 

können in einer Listen-Klasse als Attribute geführt werden 

(hier VListe), um sowohl über das erste als auch über das 

letzte Listen-Objekt in eine Listen-Iteration einzusteigen. 

Abbildung 39: 

Objekte einer verketteten Liste 

Ferner kann über diese Attribute ein neues Objekt sowohl als erstes als auch als letztes Objekt 

in die Liste eingefügt werden. 

Mit Ausnahme der Start- und Abschluss-Objekte der Liste können Listen-Objekten über einen 

Datenzeiger (hier dat) Datenobjekte referenzieren, d.h. sie zeigen auf die Instanzen (beliebiger 

Objekte), die in der Liste gespeichert werden sollen. 

Die zu implementierende Liste VListe erhält die folgenden für Listen üblichen Methoden. 18 

Methode 

AddF irst 

AddLast 

GetF irst 

GetNext 

GetLast 

GetP rev 

Insert 

Remove 

RemoveAll 

Anmerkung 

Fügt ein Objekt an erster Stelle in die Liste ein. 

Fügt ein Objekt an letzter Stelle in die Liste ein. 

Liefert einen Zeiger auf das erste Listen-Objekt. 

Liefert einen Zeiger auf das nächste Listen-Objekt. 

Liefert einen Zeiger auf das letzte Listen-Objekt. 

Liefert einen Zeiger auf das vorhergehende Listen-Objekt. 

Fügt ein Objekt in die Liste vor einem vorgegebenem ein. 

Entfernt ein vorgegebenes Objekt aus der Liste. 

Entfernt alle Objekte aus der Liste. 

18 Da es z.Z. in VBA nicht möglich ist einen Null-Zeiger abzufragen (nothing), erhält der VKnoten das Attribut 

Ken, das die folgenden Werte annehmen kann. Ken=0: Datenknoten, Ken=1: Startknoten und Ken=2: Endknoten. 

E. Baeck


9.5.1 Beispiel einer 2-fach verketten Liste 

In Abbildung 40 zeigt die Implementierung 

einer 2-fach verketteten Liste, die 3 

Zeiger auf Instanzen des Klassenmoduls 

Stab enthält. Der 1. Knoten dient als 

Einstiegsknoten am Listenanfang (ken 

= 1 ), der letzte Knoten dient als Einstiegsknoten 

am Listenende (ken=2 ). 

Abbildung 40: Verkettete Liste mit 3 Stab-Instanzen 

Der Objektzeiger nxt enthält die Adresse des jeweils nächsten Knotens der Liste. Der Objektzeiger 

prv enthält die Adresse des jeweils vorhergehenden Knoten der Liste. Der Objektzeiger 

dat enthält für Datenknoten Zeiger auf die gespeicherten Datenobjekte (hier Stab-Instanzen). 

9.5.2 Einfügen eines Datenknotens 

Das Einfügen eines Datenknotens in eine 2-fach verkettete Liste erfordert die Umordnung der 

Knotenzeiger in zwei Schritten. Zum einen sind die Knotenzeiger des neuen Knotens zu belegen. 

Zum andere sind die Knotenzeiger der bereits gespeicherten Knoten im Umfeld des Einfügens 

an D anzupassen. 

Abbildung 41 zeigt das Einfügen eines 

Knotens in eine 2-fach verkettete Liste. 

Die Liste enthält bereits die Knoten mit 

den Instanzen Stab1 und Stab3. Es soll 

die Instanz Stab2 zwischen die beiden 

genannen Instanzen eingefügt werden. 

In der Ausgangssituation sind Stab1 

und Stab3 mit den blauen Pfeilen verkettet. 

Der nxt-Zeiger von Stab1 wird 

Abbildung 41: Einfügen bzw. Entfernen eines Knotens 

auf auf Stab2 gesetzt. In gleicher Weise wird der prv-Zeiger von Stab3 auf Stab2 gerichtet. 

Zusätzlich wird der nxt-Zeiger von Stab2 auf Stab3 und der prv-Zeiger von Stab2 auf Stab1 

erzeugt. Nach Einfügen von Stab2 werden die Knoten im Umfeld von Stab2 durch die roten 

Pfeile verkettet. 

9.5.3 Entfernen eines Datenknotens 

Das Entfernen eines Datenknotens aus einer 2-fach verkettete Liste erfordert die Umordnung der 

Knotenzeiger in zwei Schritten. Zum einen sind die Knotenzeiger des zu löschenden Knotens zu 

entfernen. Zum andere sind die Knoten vor und nach dem zu entfernenden Knoten mit einander 

zu verketten. 

Abbildung 41 zeigt das Löschen des Datenknotens von Stab2. Zunächst ist Stab2 noch eingebunden 

(blaue Pfeile). Es ist der nxt-Zeiger von Stab1 auf Stab3 zu setzen. Der prv-Zeiger von Stab3 

ist auf Stab1 zu setzen. Beim Entfernen eines Knotens ist darauf zu achten, dass gelöscht wird, 

bevor die Zeiger auf ihn entfernt werden, da eine Instanz ohne Zeiger nicht mehr ansprechbar 

ist. 

19.10.2011


9.5.4 Iteratoren 

Der Iterator ist ein Zeiger mit dessen Hilfe eine Liste durchlaufen wird. Startpunkt einer Iteration 

ist bei einfach verketteten Listen der Kopf der Liste. Bei zweifach verketteten Listen kann zudem 

der das Ende der Liste als Startpunkt der Iteration gewählt werden. Die Iteration erfolgt in 

diesem Fall rückwärts über die Rückwärtsverkettung. 

Gängigerweise wird eine Iteration durch das Holen des Startzeigers initiiert. Darauf folgend wird 

in einer Schleife durch Holen des jeweils nächsten Zeigers die Iteration ausgeführt. 

Eine Listeniteration kann somit wie folgt im Pseudocode formuliert werden. 

• Hole 1. Zeiger (Kopfzeiger oder Endezeiger) 

• Hole nächsten Zeiger bis das Iterationsende erreicht ist. Der nächste Zeiger ist von der 

Iterationsrichtung abhängig. 

E. Baeck

10. REKURSIVE ALGORITHMEN Seite 49 

10 Rekursive Algorithmen 

Ein Algorithmus ist dann rekursiv, wenn er sich selbst enthält oder durch sich selbst teilweise 

definiert wird. 

Einer der bekanntesten und einfachsten rekursiven Algorithmen ist gegeben durch die Berechnung 

der Fakultät (siehe auch Abschnitt 5.1). 

⎧ 

⎨ 1 

n! = 

⎩ (n − 1)! 

:n = 0 

: sonst 

(27) 

Wie im Fall der Fakultät (27) bekannt, ist die rekursive Formulierung des Problems im Gegensatz 

zur direkten (2) nicht wirtschaftlich. 

10.1 Quick-Sort 

Das Sortierverfahren QuickSort arbeitet nach der Devise Herrsche und Teile. Der Algorithmus 

geht zurück auf C.A.R Hoare 1960. 

Das zu sortierende Feld wird zerlegt 

in zwei Teilfelder. Die Teilung erfolgt 

durch Wahl eines beliebigen Elements 

P. Die Elemente der Teilfelder werden 

so umsortiert, dass im einen Teilfeild alle 

Elemente kleiner P im anderen Teilfeld 

alle Elemente größer P einsortiert 

werden. 

Die auf diese Weise generierten Teilfelder 

werden erneut in zwei Teilfelder 

durch Wahl eines jeweils neuen Teilerelements 

P zerlegt. Die Zerlegung eines 

Teilfeldes wird solange fort gesetzt, bis 

sich nur noch ein Element im Teilfeld 

befindet. 

Reduziert sich die Anzahl der Elemente 

alle Teilfelder auf ein Element, ist die 

Sortierung abgeschlossen. 

In Abbildung 42 wird das Wort SOR- 

TIERANGS alphabetisch sortiert. Das 

berandete Feld am rechten Intervallrand 

teilt das Intervall. Zum einen läuft 

Abbildung 42: QuckSort: SORTIERANGST 

ein Zeiger vom linken Intervallrand nach rechts und sucht das erste Zeichen, das größer oder 

gleich dem Teiler ist, dieses wird türkis eingefärbt. Andererseits läuft ein zweiter Zeiger von rechts 

nach links und sucht ein Zeichen, das kleiner oder gleich dem Teiler ist. Dieses Zeichen wird gelb 

19.10.2011


dargestellt. Gelbes und türkises Zeichen werden getauscht. Daraufhin wird die Suche von beiden 

Seiten fortgesetzt. Gefundene Zeichen werden getauscht. Dies wird solange fort geführt, bis sich 

die beiden Zeiger treffen. Daraufhin wird das Zeichen, auf das der linksseitige Zeiger verweist mit 

dem Teilerzeichen getauscht. Das Teilerzeichen erhält damit seine endgültige Position. In Abbildung 

42 werden gefundene Intervallgrenzen durch einen vertikalen roten Strich gekennzeichnet. 

Links- bzw. rechsseitiges Intervall (ohne das Teilerzeichen) werden erneut nach beschriebener 

Art umsortiert. Die Zerlegung in Teilintervalle wird solange fort gesetzt, bis die Teilintervallen 

nur noch ein Zeichen enthalten. Vertauschte Zeichen werden hellgrau gekennzeichnet. Zeichen, 

die bereits ihre endgültige Position erhalten haben, werden dunkelgrau gekennzeichnet. 

E. Baeck

A. DREIMOMENTENGLEICHUNG, CLAPEYRON Seite 51 

A 

Dreimomentengleichung, Clapeyron 

In diesem Abschnitt wird das Verfahren der Dreimomentengleichung oder Verfahren nach Clapeyron 

dargestellt (siehe auch [1]). 

A.1 Das Verfahren 

Mit der Dreimomentengleichung 

werden unter folgender Einschränkungen 

die Stützmomente 

mehrfeldriger Durchlaufträger 

berechnet. 

Abbildung 43: Durchlaufträger mit 8 Feldern 

Voraussetzungen: 

• Stützpunkte sind starr gelagert. 

• Auftretende Lasten wirken senkrecht zur Stabachse. 

• Die Biegesteifigkeit EI ist feldweise konstant. 

Für 2-feldrigen Abschnitt gilt (mit m ∈ [b, h] in Abbildung 43): 

M l · l l + 2 · M m · (l l + l r ) + M r · l r = −R l · l l − L r · l r (28) 

mit: M l , M m , M r , 

l l , l r , 

R l , L r , 

dem linken, mittleren und rechten Stützmoment 

der effektiven linken und rechten Feldweite 

dem linken und rechten Belastungsglied (rechte Seite) 

Die effektiven Feldweiten l l und l r sind bei unterschiedlichen Steifigkeiten auf ein Vergleichsträgheitsmoment 

I c zu beziehen, d.h. l l = Ic 

I l 

· l l,0 mit l l,0 , der realen Feldweite. 

A.2 Herleitung 

Vorgehen: 

Als statisch bestimmtes Grundsystem 

wird ein durch Gelenke 

entkoppelter Mehrfeldträger 

gewählt. Als statisch Unbestimmte 

werden die Stützmo- 

Abbildung 44: Statisch Unbestimmte an Zwischenlagern 

mente in den Mittenlagern gewählt (Stützmomente an Randlagern verschwinden). Durch 

Ansetzen dieser Momente (als äußere Lasten) werden die Verdrehungen ϕ in den Gelenken in 

der Weise beeinflußt, dass sich in den Gelenken knicklose Übergänge (C1 stetig) ergeben. 

19.10.2011


Für den in Abbildung 43 dargestellten Durchlaufträger ergeben sich für die Verdrehwinkel an 

den Lagern 1-7 bei Wahl der Stützmomente als statische Unbestimmte die folgenden Verträglichkeitsbedingungen 

(knickfreier Übergang zwischen den Feldern!). Aus den Verträglichkeitsbedinungen 

folgt ein lineares Gleichungssystem für den gesuchten Momenten-Vektor X ⃗ (X 1 bis 

X 7 ). 

Gl. X 1 X 2 X 3 X 4 X 5 X 6 X 7 

1 δ 11 δ 12 0 0 0 0 0 δ 10 = 0 

2 δ 21 δ 22 δ 23 0 0 0 0 δ 20 = 0 

3 0 δ 32 δ 33 δ 34 0 0 0 δ 30 = 0 

4 0 0 δ 43 δ 44 δ 45 0 0 δ 40 = 0 

5 0 0 0 δ 54 δ 55 δ 56 0 δ 50 = 0 

6 0 0 0 0 δ 65 δ 66 δ 67 δ 60 = 0 

7 0 0 0 0 0 δ 76 δ 77 δ 70 = 0 

Tabelle 4: Gleichungssystem zur Ermittlung der Momente X 1 bis X 7 

Da die Momentenfläche eines angesetzten 1- 

Momente am Lager i jeweils dreieckförmig 

zu den benachbarten Lagern i − 1 und i + 1 

ausläuft, ergeben sich bei der Integration der 

Eigenspannungszustände δ ij nur dann nicht 

verschwindende Werte wenn |i − j| ≤ 1. 

In Abbildung 45 werden die Momentenflächen 

für die ersten 5 Lager dargestellt. Es 

ist zu erkennen, dass jeweils zwei zur Mittelachse 

symmetrische Dreieckflächen benachbarter 

Lagerpunkte zu überlagern sind. 

δ ij = ∑ s 

∫ 

1 

E · I · M i · M j · dx = 

Abbildung 45: Statisch Unbestimmte an Zwischenlagern 

l i 

6 · E · I , für i > j 

δ ii = ∑ s 

∫ 

l i+1 

= 

6 · E · I , für i < j 

1 

E · I · M i 2 · dx = l i + l i+1 

, für Diagonalterme i = j (29) 

3 · E · I 

Aus Gleichung 29 und Tabelle 4 folgt: 

l i 

X i−1 · 

6EI + X i · li + l i+1 

+ X i+1 · li+1 

3EI 

6EI + δ i0 = 0 

X i−1 · l i + 2 · X i · (l i + l i+1 ) + X i+1 · l i+1 = −δ i0 · 6 · E · I (30) 

E. Baeck

A. DREIMOMENTENGLEICHUNG, CLAPEYRON Seite 53 

Die rechte Seite aus Gleichung 30 kann wie folgt umgeformt werden. 

δ i0 = ϕ i,r − ϕ i,l 

6 · E · I · ϕ i,l = −R i · l i 

6 · E · I · ϕ i,r = L i+1 · l i+1 (31) 

mit den Stabenddrehwinkeln 19 ϕ i,r und ϕ i,l . 

Aus den Gleichungen 30 und 31 folgt die Formel von Clapeyron (siehe Gleichung 28). 

Es gibt spezielle Integrationstabellen (siehe z.B. [1] Seite 65) für die die Belastungsglieder L r 

und R l der Dreimomentengleichung (siehe Gleichung 28). Diese sind ebenso aus der allgemeinen 

Überlagerung der Belastungsmomentenfläche mit den jeweiligen Dreiecks.Momentenflächen des 

Einheitsmomentes am betrachteten Lagerpunkt zu erhalten. 

δ i0 = ∑ ∑ 

∫ 

1 

E · I · (M i + M i+1 ) · M 0,l · dx (32) 

s 

l 

mit M i , der linksseitigen, und M i+1 , der rechtsseitigen Momentenfläche am Lager i. M 0,l ist die 

Momentenfläche aus einer Belastung l. Bei der Berechnung von δ i0 sind die Momentenflächen 

aller l Belastungen zu berücksichtigen. 

19 Die Winkel ϕ sind Endwinkel eines Balkens auf zwei Stützen. Dies entspricht dem statisch bestimmten Grundsystems 

des Durchlaufträgers 

19.10.2011


B 

Das ER-Modell 

Das ER-Modell (Entity-Relationship- 

Modell) oder Gegenstands- 

Beziehungs-Modell von Peter 

Pin-Shan Chen (1976) dient zur 

Beschreibung einer Datenstruktur 

in einem Modell bestehend aus graphischen 

Symbolen (siehe Abbildung 

46). Eine ähnliche Visualisierung 

der Abhängigkeiten der Objekte des 

ER-Modells ist auch in der UML 

(Unified Modelling Language) zu finden. 

Abbildung 46: ER-Modell nach P.P. Chen 

• Entität (Entities): 

Objekt der Wirklichkeit, materiell oder abstrakt (zum Beispiel Lastfall oder Feld). 

• Beziehung (Relationships): 

Semantische Beziehung zwischen zwei Objekten (zum Beispiel Lastfall enthält Lasten) 

• Attribut: 

Elementarinformation einer Entität oder einer Beziehung (z.B. hat eine Last eine Ordinate 

q, ein Feld hat eine Länge l). 

• Kardinalität: 

Mögliche Anzahl der an einer Beziehung beteiligten Entitäten (z.B. 1 Lastfall enthält 20 

Lasten). Die Kardinalität wird optional am Ende einer Beziehungslinie angemerkt. 

E. Baeck

C. UML-ASPEKTE Seite 55 

C 

UML-Aspekte 

Die Unified Modeling Language ist eine überwiegend graphische Modellierungssprache für objektorientierte 

Entwicklungsansätze. Die UML geht zurück auf Booch, Rumbaugh und Jacobson. 

An dieser Stelle werden nur die Klassendiagramme erläutert, die als Erweiterung der ER- 

Diagramme betrachtet werden können. 

Ein Klassendiagramm stellt die Beziehungen zwischen den einzelnen Klassen (Objekten) des 

Systems dar. Das Diagramm besteht aus Klassen, die durch Assoziation und/oder Generalisierung 

miteinander verbunden sind. Eine Klasse wird als Rechteck mit den 3 folgenden Bereichen 

dargestellt. 

• Der obere Bereich enthält den Namen der Klasse. 

• Der mittlere Bereich enthält die Liste der Attribute, d.h. die Daten, die eine Klasse umfaßt. 

• Der untere Bereich enthält die Methoden der Klasse (Klassen-Funktione). 

Assoziationen entsprechen den Relationen 

des ER-Modells. Sie werden 

durch Kanten dargestellt an deren Enden 

die Quantitäten vermerkt werden. 

Generalisierungen werden mit einer 

Richtung vorgegeben. 20 

Beispiel: 

Ein Beispiel objektorientierter Modellierung 

sind z.B. Geometrieobjekte eines 

CAD-Systems. Das Basis-Objekt 

der Modellierung ist das Geo-Objekt 

(Geometrieobjekt), es liefert die folgenden 

Standarddaten und Grundfunktionalität 

aller spezialisierten Objekte. 

Abbildung 47: UML-Klassendiagramm 

Standarddaten 

Grundfunktionalität 

: Farbe, Layer, Linientyp, Strickstärke. 

: Löschen, Verschieben, Rotieren, Spiegeln. 

Eine Generalisierung des Geo-Objektes wäre z.B. das Punkt-Objekt. Es geht aus dem Geo- 

Objekt hervor und beerbt dessen Attribute und Funktionen. Zudem erhält das Objekt Punkt die 

Attribute x, y und z, die die Lage des Punktes im Raum beschreiben. Die Funktionen der Basisklasse 

Geo werden überschrieben mit speziellen Funktionen des Punktes. So ist im Gegensatz 

zur Linie beispielsweise beim Verschieben eines Punktes nur ein Ortsvektor zu variieren. 

20 Generalisierungen wurden in VB nicht vorgesehen. In der aktuellen VB-Version wurde die Generalisierung 

implementiert. In VBA unter EXCEL wurde bislang auf Generalisierungen verzichtet. 

19.10.2011


D 

Gauß’scher Algorithmus und Cholesky-Zerlegung 

In diesem Abschnitt wird der Gauß’sche Algorithmus zur Lösung des linearen Gleichungssystems 

erläutert. Bei den hier betrachteten Problemen ist das folgende symmetrisch-definites 

Gleichungssystem zu lösen 2122 . 

A · x + b = 0 , mit A T = A und A positiv definit (33) 

In Komponentendarstellung erhält man: 

⎛ 

⎞ ⎛ 

a 1,1 a 1,2 . . . a 1,n 

a 2,1 a 2,2 . . . a 2,n 

. 

⎜ . . .. · 

. ⎟ ⎜ 

⎝ 

⎠ ⎝ 

a n,1 a n,2 . . . a n,n 

⎞ ⎛ 

x 1 

x 2 

= 

. . . ⎟ ⎜ 

⎠ ⎝ 

x n 

b 1 

b 2 

. . . 

b n 

⎞ 

⎟ 

⎠ 

(34) 

oder 

n∑ 

a ik · x k + b i = 0 (i = 1, 2, ..., n) (35) 

k=1 

Zur Lösung der Dreimomentengleichungen (Clapeyron) wären die Einträge der Matrix A die 

Längengewichte der Momente. Der Vektor x wäre der Vektor der gesuchten Stützmomente, der 

Vektor b, der Vektor der Belastungsglieder. 

D.1 Der Gauß’sche Algorithmus 

In einem ersten Schritt eliminiert man die erste Unbekannte x 1 aus den Gleichungen 2 bis n, in 

dem das (a i1 /a 11 )-fache der ersten Zeile von der i-ten Zeile subtrahiert wird. Damit erhält man 

ein reduziertes Gleichungssystem für die Unbekannten x 2 bis x n . 

mit 

n∑ 

k=2 

a (1) 

ik · x k + b (1) 

i 

= 0 (i = 2, 3, ..., n) (36) 

a (1) 

ik 

= a ik − a i1 · a 1k 

a 11 

(i, k = 2, 3, ..., n) (37) 

b (1) 

i 

= b i − a i1 · b 1 

a 11 

(i = 2, 3, ..., n) (38) 

es werden die folgenden l-Faktoren eingeführt 

l i1 = a i1 

a 11 

(i = 2, 3, ..., n) (39) 

Unter Berücksichtigung von (39) folgt aus (37) und (38) 23 

a (1) 

ik 

= a ik − l i1 · a k1 (40) 

b (1) 

i 

= b i − l i1 · b 1 (i = 2, 3, ..., n; k = 2, 3, ..., i) (41) 

21 Weiterführende Erläuterungen und Algorithmen siehe [2]. 

22 Für eine transponierte Matrix A T gilt: A T i,j = A j,i . 

23 Die l i1 können erst nach Abschluss des Reduktionsschrittes in den Speicher der a i1 geschrieben werden. 

E. Baeck

D. GAUß’SCHER ALGORITHMUS UND CHOLESKY-ZERLEGUNG Seite 57 

In (40) und (41) wurde die Symmetrie der Matrix A berücksichtigt. Zum einen läuft der Index 

k nicht mehr bis n, sondern nur noch bis i, d.h. bis zur Diagonalen der Matrix. Zum zweiten 

wurde in (40) a 1k durch a k1 ersetzt. Damit kann auf die Matrixeinträge des oberen Dreiecks 

verzichtet werden. 

Wird die erste Gleichung aus (35) durch a 11 dividiert, so folgt mit (39) die Bestimmungsgleichung 

für die Unbekannte x 1 . 24 

x 1 = − 

n∑ 

k=2 

l k1 · x k − c 1 mit c 1 = b 1 

a 11 

(42) 

Mit dem reduzierten Gleichungssystem der Stufe (1) (Bestimmungsgleichungen für x 2 bis x n 

(36)), folgen in analoger Weise die Größen des reduzierten Gleichungssystems der Stufe (2). 

Die l-Faktoren ergeben sich zu 

l i2 = a(1) i2 

a (1) 

22 

(i = 3, 4, ..., n) (43) 

die Koeffizienten der zweiten Stufe ergeben sich zu 

a (2) 

ik 

= a (1) 

ik − l i2 · a (1) 

k2 

(44) 

b (2) 

i 

= b (1) 

i 

− l i2 · b 2 (i = 2, 3, ..., n; k = 2, 3, ..., i) (45) 

und die Bestimmungsgleichung für die Unbekannte x 2 ergibt sich zu 

n∑ 

x 2 = − l k2 · x k − c 2 

k=3 

mit c 2 = b(1) 2 

a (1) 

22 

(46) 

Bei konsequenter Fortführung dieser Reduktion folgt nach n − 1 Schritten die Bestimmungsgleichung 

der letzten Unbekannten x n zu 

a (n−1) 

nn 

· x n + b (n−1) 

n = 0 (47) 

und somit folgt für die letzte Unbekannte x n 

x n = −c n 

mit c n = b(n−1) n 

a (n−1) 

nn 

(48) 

Die Berechnung aller Unbekannten x 1 bis x n erfolgt somit rekursiv, d.h. zur Berechnung der 

1. Unbekannten ist die Lösung der 2. erforderlich, zur Berechnung der 2. die 3. usw.. Nach 

vollständiger Reduktion des Gleichungssystems (35) zu (48), können sozusagen rückwärts, 

deshalb Rückwärtseinsetzen, alle Unbekannten x n−1 , x n−2 bis x 1 ermittelt werden. 

24 Die c i Werte werden in den Speicher der b i-Werte geschrieben. 

19.10.2011


D.2 Interpretation des Gauß’schen Algorithmuses als Dreieckszerlegung 

Aus den Gleichungen des Abschnitts D.1 folgen die Lösung des linearen Gleichungssystems 

für eine Inhomogenität oder rechte Seite, d.h. einen Vektor b. Da i.A. mehrere Lastfälle zur 

Berechnung vorliegen, müßte nach dem besprochenen Algorithmus für jeden Lastfall individuell 

eine Lösung berechnet werden. 

Mit der Interpretation des Gauß’schen Algorithmuses als Zerlegung einer Matrix A in eine 

Linksdreiecksmatrix L mit 1-Werten auf der Diagonalen und eine Rechtsdreiecksmatrix R läßt 

sich eine Berechnungsvorschrift ableiten, die den Lösungsalgorithmus in drei Schritte aufspaltet, 

wobei der aufwendigste erste Schritt unabhängig von der rechten Seite, d.h. unabhängig vom 

Lastvektor durchgeführt werden kann. 

⎡ 

⎤ ⎡ 

⎤ ⎡ 

⎤ 

1 0 0 0 a 11 a 12 a 13 a 14 

a 11 a 12 a 13 a 14 

l 21 1 0 0 

0 a (1) 

· 

22 a (1) 

23 a (1) 

24 

a ⎢ l 

⎣ 31 l 32 1 0 ⎥ ⎢ 0 0 a (2) 

⎦ ⎣ 

33 a (2) 

= 

21 a 22 a 23 a 24 

34 

⎥ ⎢ a 

⎦ ⎣ 31 a 32 a 33 a 34 ⎥ 

⎦ 

l 41 l 42 l 43 1 0 0 0 a (3) 

44 

a 41 a 42 a 43 a 44 

L · R = A 

(49) 

Die Beziehung (49) 25 läßt sich elementar z.B. durch (44) im Fall des ersten reduzierten Gleichungssystems 

zeigen. 

Die Rechtsdreiecksmatrix R läßt sich auf die Linksdreiecksmatrix L in folgender Beziehung 

zurück führen. 

R = 

= 

⎡ 

a 11 a 12 a 13 a 14 

0 a (1) 

22 a (1) 

23 a (1) 

24 

⎢ 0 0 a (2) 

⎣ 

33 a (2) 

34 

0 

⎡ 

0 0 a (3) 

44 

a 11 0 0 0 

⎢ 

⎣ 

= D · L T 

0 a (1) 

22 0 0 

0 0 a (2) 

33 0 

0 0 0 a (3) 

44 

⎤ 

⎥ 

⎦ 

⎤ ⎡ 

⎤ 

1 l 21 l 31 l 41 

0 1 l · 

32 l 42 

⎥ ⎢ 0 0 1 l 

⎦ ⎣ 

43 ⎥ 

⎦ 

0 0 0 1 

(50) 

Aus (49) und (50) folgt die Gleichung der Dreieckszerlegung nach Gauß. 

A = L · D · L T (51) 

Damit folgt für das lineare Gleichungssystem (34) 

L · D · L T x + b = 0 (52) 

25 Zur Erläuterung der matriziellen Zusammenhänge wird der Fall n = 4 in Komponentenform dargestellt. Die 

Verallgemeinerung auf beliebige Dimension erfolgt entsprechend. 

E. Baeck


Zur Bestimmung der Unbekannten wird zunächst der Hilfsvektor y wie folgt eingeführt 26 . 

y = −D · L T · x (53) 

Der Vektor y wird zudem wie folgt in c skaliert. 

D · c = y (54) 

Somit kann (52) in den folgenden 3 Schritten umformuliert werden. 

− L · y + b = 0 (55) 

−D · c + y = 0 (56) 

L T · x + c = 0 (57) 

Die Unbekannten x i für mehrere Lastfälle wird demnach in den folgenden 3 Schritten ermittelt. 

• Dreieckszerlegung 

Die Matrix A wird nach (51) unabhängig von den rechten Seiten in eine Lingsdreiecksmatrix 

und eine Diagonalmatrix zerlegt. 

• Vorwärtseinsetzen 

Berechnung einer modifizierten rechten Seite c nach (55 und 56). 

• Rückwärtseinsetzen 

Berechnung aller Unbekannten mit modifizierten rechten Seite c nach (57). 

Der Vorteil dieses Verfahrens ist, dass der aufwendigste Schritt, die Dreieckszerlegung der Koeffizientenmatrix 

(O(n 3 )), nur einmal für alle Lastfälle (Inhomogenitäten b) durchzuführen ist. 

Die Berechnung der Unbekannten durch Vorwärtseinsetzen (O(n 2 )) und Rückwärtseinsetzen 

(O(n 2 )) erfolgt dann für jeden Lastfall individuell. 

26 Bei Anwendung der Standardvariante des Gauß’schen Algorithmus wird das Gleichungssystem für jede rechte 

Seite (Lastfall) individuell gelöst. Ziel der Betrachtung hier ist, den aufwendigen Schritt der Zerlegung im Falle 

mehrerer rechter Seiten, d.h. für mehrere Lastfälle, von der Berechnung der Unbekannten zu separieren, sodass 

die Zerlegung nur einmal durchgeführt werden muss. 

19.10.2011


D.3 Die Cholesky-Zerlegung 

Zur optimalen Nutzung des Speichers werden die Faktoren l ik an die Stelle der entsprechenden 

Matrixelemente der Matrix A gespeichert. Der Gauß’sche Algorithmus wirft das Problem auf, 

dass die Faktoren l ik erst dann auf die Matrixelemente abgespeichert werden können, wenn 

der Eliminationsschritt vollständig durchgeführt wurde (siehe Gleichung 44). Wird darauf nicht 

geachtet, gehen Matrixelemente verloren, die zukünftig noch gebraucht werden. 

Durch Cholesky’s Idee einer symmetrischen Zerlegung der Matrix A wird dieses Problem gelöst. 

Der Algorithmus wird vereinfacht. Durch die symmetrische Aufspaltung der Matrix A wird aus 

den Diagonalelementen die Wurzel gezogen. Dies reduziert die Größenordung der Matrixelemente 

auf die Halfte (z.B. √ 100 = 10 und √ 10000 = 100), die Matrixelemente rücken zusammen, 

was zu einer besseren Konditionierung der Matrix und dadurch zu einer höheren numerische 

Stabilität der Berechnung führt. 

Die Zerlegung nach Cholesky ergibt folgende Beziehung. 

A = L · L T (58) 

Die Diagonalelemente der Gauß’schen Zerlegung, Matrix D (51) werden in der Cholesky- 

Zerlegung symmetrisch in die Dreiecksmatrizen L und L T aufgenommen. Damit ergibt sich 

die folgende Beziehung. 

A = L Chol · L T Chol 

, mit L Chol 

= L Gaus · D (1/2) (59) 

Für die l-Faktoren ergibt sich mit 

l i1 = 

a i1 

√ 

a11 

(i = 2, 3, ..., n) (60) 

die symmetrische Form 27 

a (1) 

ik = a ik − l i1 · l k1 (i = 2, 3, ..., n; k = 2, 3, ..., i) (61) 

wobei für die erste Gleichung gilt 

l 11 = √ a 11 , und 

c 1 

c 1 = √ = b 1 

(62) 

a11 l 11 

Mit (60), (61) und (62) folgt für die Bestimmungsgleichung für die erste Unbekannte x 1 

[ n∑ 

] 

x 1 = − 1 · l k1 · x k + c 1 

l 11 

k=2 

(63) 

für (45) folgt mit (60) und (62) 

b (1) 

i 

= b i − l i1 · c 1 (i = 2, 3, ..., n) (64) 

27 Aus (61) folgt, dass unmittelbar nach Berechnung eines neuen Matrixelements, das entsprechend alte nicht 

mehr benötigt wird, d.h. das neue kann unmittelbar nach Berechnung auf den Speicherplatz des alten geschrieben 

werden. 

E. Baeck


Das Aufstellen der reduzierten Gleichungssysteme erfolgt analog zur Gauß’schen Zerlegung. Für 

das reduzierte Gleichungssystem der zweiten Stufe ergibt sich folgende Gleichungen. 

l 22 = 

√ 

a (1) 

22 , l i2 = a(1) i2 

(i = 3, 4, ..., n) (65) 

l 22 

a (2) 

ik 

= a (1) 

ik − l i2 · l k2 (i = 3, 4, ..., n; k = 3, 4, ..., i) (66) 

c 2 = b 2 

l 22 

(67) 

b (2) 

i 

= b (1) 

i 

− l i2 · c 2 (i = 3, 4, ..., n) (68) 

Die Gleichungen (65) und (66) zeigen die symmetrische Zerlegung nach Cholesky, die Gleichungen 

(67) und (68) das Vorwärtseinsetzen, die Berechnung des Hilfsvektors zur Ermittlung der 

Unbekannten im Rückwärtseinsetzen. 

Die Linksdreiecksmatrix nach der Cholesky-Zerlegung (vgl. (58)) hat die folgende Gestalt. 

⎡ 

⎤ 

l 11 0 0 0 

l 

L = 

21 l 22 0 0 

(69) 

⎢ l 

⎣ 31 l 32 l 33 0 ⎥ 

⎦ 

l 41 l 42 l 43 l 44 

Im Gegensatz zum Gauß’schen Algorithmus benötigt der Algorithmus nach Cholesky nur einen 

Hilfvektor (c = −L T · x) für das Vorwärts-, Rückwärtseinsetzen. Die Skalierung mit der Diagonalmatrix 

(siehe (56)) entfällt. 

Für das lineare Gleichungssystem (33) folgt mit der Zerlegung (58) 

L · L T · x + b = 0 (70) 

Der Hilfsvektor der Lastseite c wird durch das Vorwärtseinsetzen (71) berechnet. Die Unbekannten 

ergeben sich aus dem Rückwärtseinsetzen (72)mit Hilfe des Vektors c. 

− L · c + b = 0 (71) 

L T · x + c = 0 (72) 

19.10.2011


D.4 Pseudocode für Cholesky-Zerlegung 

Die Berechnung der Unbekannten aus dem linearen Gleichungssystem (33) werden für mehrere 

rechte Seiten, d.h. Lastfälle, sinnvollerweise durch drei getrennte Programmteile (Funktionen) 

implementiert, 

• die Dreieckszerlegung, 

• das Vorwärtseinsetzen und 

• das Rückwärtseinsetzen, 

wobei die Dreieckszerlegung nur einmal, das Vorwärts- und Rückwärtseinsetzen für jede rechte 

Seite b, d.h. für jeden Lastfall erfolgt. 

D.4.1 

Pseudocode der Zerlegung 

Der Prozess der Dreieckszerlegung wird durch den folgenden Pseudocode beschrieben. 

für p = 1, 2, ..., n 

l pp = √ a pp 

für i = p + 1, p + 2, ..., n 

l ip = a ip /l pp 

für k = p + 1, p + 2, ..., i 

für a ik = a ik − l ip · l kp (58’) 

D.4.2 

Pseudocode des Vorwärtseinsetzens 

Der Prozess des Vorwärtseinsetzens wird durch den folgenden Pseudocode beschrieben. 

für k = 1, 2, ..., n 

s = b k 

für i = 1, 2, ..., k − 1 

s = s − l ki · c i 

c k = s/l kk (71’) 

D.4.3 

Pseudocode des Rückwärtseinsetzens 

Der Prozess des Rückwärtseinsetzens wird durch den folgenden Pseudocode beschrieben. 

für k = n, n − 1, ..., 1 

s = c k 

für i = k + 1, k + 2, ..., n 

s = s + l ik · x i 

x k = −s/l kk (72’) 

E. Baeck


D.5 VBA-Code des Gleichungslösers nach Cholesky 

In diesem Abschnitt werden die VBA-Codes für die Dreieckszerlegung nach Cholesky sowie 

die Codes des Vorwärts- und Rückwärtseinsetzens gegeben. Der VBA-Code ergibt sich aus der 

direkten Umsetzung des Pseudocodes (siehe Abschnitt D.4) in die VBA-Sprache. 

D.5.1 

VBA-Code der Cholesky-Zerlegung 

Option Explicit 

’ Zerlegen einer Matrix A(n x n) nach Cholesky 

’ 

’ A = L * L^T 

’ 

’ A: Dim A(1 to n, 1 to n) 

Public Function Cholesky(n As Integer, a() As Double) As Integer 

Dim P As Integer 


Dim k As Integer 

’ über die Spalten 

For P = 1 To n 

’ Matrix nicht zerlegbar 

If a(P, P)


D.5.2 

VBA-Code des Vorwärtseinsetzens 

’ Vorwärtseinsetzen 

Public Sub Vorwaerts(n As Integer, L() As Double, b() As Double, c() As Double) 



Dim s As Double 

For k = 1 To n 

s = b(k) 

For i = 1 To k - 1 

s = s - L(k, i) * c(i) 

Next 

c(k) = s / L(k, k) 

Next 

End Sub 

D.5.3 

VBA-Code des Rückwärtseinsetzens 

’ Rückwärtseinsetzen 

Public Sub Rueckwaerts(n As Integer, L() As Double, c() As Double, x() As Double) 




For k = n To 1 Step -1 

s = -c(k) 

’ "-" falls: A*x = b 

’ s = +c(k) ’ "+" falls: A*x + b = 0 

For i = k + 1 To n 

s = s + L(i, k) * x(i) 

Next 

x(k) = -s / L(k, k) 

Next 

End Sub 

E. Baeck

E. LÖSUNGEN ZUM ABSCHNITT ELEMENTARE ALGORITHMEN Seite 65 

E 

Lösungen zum Abschnitt Elementare Algorithmen 

In diesem Anhang werden Lösungsvorschläge zu den Aufgaben im Abschnitt 5 gegeben. Auf 

die Darstellung an die Eventfunktionen wird hierbei verzichtet, da diese bei allen Programmen 

ähnlich ist und damit aus der Darstellung des Abschnitts 4.1 prinzipiell entnommen werden 

kann. 

E.1 Summe aller Zahlen aus vorgegebenem Intervall 

’ Summe der ganzen Zahlen von "VON" nach "BIS" 

Public Sub Summe() 

’ Deklaration 

Dim von As Integer 

Dim bis As Integer 

Dim sum As Integer 


Abbildung 48: Eingabefelder und Programstart 


sum = 0 

’ Hole Daten aus Tabelle 

von = Range("VON") 

bis = Range("BIS") 

’ Berechnung der Summe 

For i = von To bis 

sum = sum + i 

Next 

’ Schreibe Ergebnis in Tabelle 

Range("SUM") = sum 

End Sub 

19.10.2011


E.2 Berechnung der Fakultät 

Aufgabenstellung in Abschnitt 5.1. 

’ Berechnung der Fakultät 

Public Sub Fakultaet() 

Dim n As Integer 


Dim f As Double 

’ Eingangsgröße 

’ Laufvariable 

’ Ergebnis: Achtung 8Bytes! erforderlich 


f = 1 

n = Range("NWERT") 

’ Berechnung 

For i = 2 To n 

f = f * i 

Next 


’ Ergebnis 

Range("NFAKULTAET") = f 

End Sub 

E. Baeck


E.3 Berechnung des Binomialkoeffizienten 

Aufgabenstellung in Abschnitt 5.2 28 

’ Berechnung des Binomialkoeffizienten 

Public Sub Binomi() 



’ Ergebnis kritsch! => 8Bytes! 


Dim m As Integer 

’ Eingangsgrößen aus Tabelle 

n = Range("B_N") 

m = Range("B_M") 


f = 1 

’ Berechnung 

For i = 1 To m 

f = f * (n - i + 1) / i 

Next 

’ Ausgabe in Tabelle 

Range("W_BIN") = f 

End Sub 

28 Das Beispiel zeigt die möglichen Kombinationen für die Auswahl von 6 aus 49. Der Kehrwert wäre die 

Wahrscheinlichkeit einen 6er im Lotto zu holen. Füllen Sie also 14 Millionen Lottoscheine aus und es wird Ihnen 

einmal das große Glück zu winken. Dies allerdings nur, bei hinreichend häufiger Wiederholung! 

19.10.2011


E.4 Beispiel 4: Winkel zwischen 2 Vektoren im R n 

Aufgabenstellung in Abschnitt 5.3 

VBA liefert keine Arkuskosinus-Funktion. Arkuskosinus wird wie folgt auf Arkustangens zurück 

geführt 29 . 

( ) −x 

arccos(x) = arctan √ + π (73) 

1 − x 2 

’ Berechnung des Winkels zwischen 2 Vektoren aus R^n 

Public Function Winkel(i0 As Integer, j0 As Integer) 


Dim dm As Integer 

’ Laufindex 

’ Dimension 

Dim V1() As Double ’ Vektor 1 

Dim V2() As Double ’ Vektor 2 

Dim L1 As Double ’ Vektorlänge 1 

Dim L2 As Double ’ Vektorlänge 2 

Dim L3 As Double ’ Skalarpodukt V1, V2 

Dim cs As Double ’ Cosinus-Wert 

i = 1 

’ Dimension ermitteln 

Do While (Cells(i + i0, 1 + j0) "") 

i = i + 1 

Loop 

dm = i - 1 

’ Dimensionierung der Vektoren 

ReDim V1(1 To dm) 

ReDim V2(1 To dm) 

’ Einlesen der Vektoren 

For i = 1 To dm 

V1(i) = Cells(i + i0, 1 + j0) 

V2(i) = Cells(i + i0, 2 + j0) 

Next 


’ Vektorlängen berechnen 

L1 = Sqr(SkalProd(V1, V1)) 

L2 = Sqr(SkalProd(V2, V2)) 

L3 = SkalProd(V1, V2) 

29 Die Umrechnung von Rad in Grad erfolgt durch Skalierung mit Faktor 

45 

arctan(1) 

E. Baeck


’ Winkelberechnung 

cs = L3 / (L1 * L2) 

’ Berechnung des Winkels in Grad 

Winkel = acos(cs) * 45# / Atn(1#) 

End Function 

’ arccos - Arcuscosinus 

Function acos(x) 

acos = Atn(-x / Sqr(-x * x + 1)) + 2 * Atn(1) 

End Function 

’ Berechnung des Skalarprodukts 

Function SkalProd(a() As Double, b() As Double) 

Dim nu As Integer 

Dim no As Integer 


nu = LBound(a) 

no = UBound(b) 

s = 0 

’ untere Grenze 

’ obere Grenze 

’ über alle 

For i = nu To no 

s = s + a(i) * b(i) 

Next 

SkalProd = s 

End Function 

19.10.2011


E.5 Lösung der sinus-Entwicklung 

Das Programm wird als Eventfunktion zum Click-Ereignis der Schaltfläche in der Tabelle implementiert. 

Private Sub SinusStart_Click() 


Dim x As Double 

Dim eps As Double 

Dim t As Double 

Dim i As Long 

Dim j As Long 

Dim g As Integer 

On Error GoTo Fehler 

g = 0 

’ Löschen der Ausgabebereiche 

Range("sinus_kom") = "" 

’ Löschen der Tabelle 

i = 10 

Do While Cells(i, 2) "" 

Cells(i, 2) = "" 

Cells(i, 3) = "" 

Cells(i, 4) = "" 

i = i + 1 

Loop 

’ Eingabedaten 

x = Range("sinus_x") 

eps = Range("sinus_eps") 


f = 0: g = 1 

x = x * Atn(1) / 45 

’ Term 1 

f = x: t = x 

i = 1: j = 1 

Cells(9 + i, 2) = i 

Cells(9 + i, 3) = t 

Cells(9 + i, 4) = f 

E. Baeck


´ 

’ Summationsschleife 

Do While Abs(t) > eps 

t = -t * x * x 

j = j + 1 

t = t / j 

j = j + 1 

t = t / j 

f = f + t 

’ Ausgabe in die Tabelle 

i = i + 1 

Cells(9 + i, 2) = i 

Cells(9 + i, 3) = t 

Cells(9 + i, 4) = f 

Loop 

g = 2 

Exit Sub 

Fehler: 

Range("sinus_kom") = "Programmfehler: Überlauf (Code " & g & ")!" 

End Sub 

19.10.2011


E.6 Implementierung des Newton-Verfahrens 

Das Verfahren besteht aus drei Programmteilen, dem Unterprogramm newton und den Funktionen 

f bzw. fs. In vorliegender Implementierung wird die Ableitung der Funktion numerisch 

berechnet. Da es in VBA nicht möglich ist, als Parameter eine Funktion zu übergeben, erhält 

die Funktion generell die Bezeichnung f. Die Funktion f ist demzufolge ebenfalls als Programmeingabe 

zu verstehen. 

Option Explicit 

’ alle Variablen deklarieren 

’ Funktion 

Private Function f(x As Double) As Double 

f = x ^ 2 - 1 

End Function 

’ Numerische Ableitung der Funktion f(x) 

Private Function fs(x As Double) As Double 

Dim h As Double 

h = 0.00001 

fs = (f(x + h / 2) - f(x - h / 2)) / h 

End Function 

’ Newtonalgorithmus 

Public Sub newton() 

Dim x As Double 

Dim eps As Double 

Dim nx As Integer 


Dim z0 As Integer 

Dim s0 As Integer 

’ Ursprung der Ausgabetabelle 


x = Range("NX0") 

eps = Range("NEPS") 

nx = Range("NIX") 

n = 0 

z0 = 13 

s0 = 1 

’ Zurücksetzen der Ausgabetabelle 

’ ... noch ein Geheimnis ... 

’ Iterationsschleife 

Do 

’ Fall 1: Nullstelle gefunden 

If Abs(f(x)) < eps Then 

E. Baeck


Range("NXN") = x 

Range("NIT") = n 

Range("NKOM") = "Nullstelle gefunden!" 

Exit Sub 

’ Fall 2: Anzahl zulässiger Iterationen erreicht 

ElseIf n >= nx Then 

Range("NXN") = "---" 


Range("NKOM") = "Keine Nullstelle gefunden!" 

Exit Sub 

’ Fall 3: Horizontale Tangente 

ElseIf Abs(fs(x)) < eps Then 

Range("NXN") = "---" 


Range("NKOM") = "Abbruch wegen horizontaler Tangente!" 

Exit Sub 

End If 

’ Iterationsschritt 

x = x - f(x) / fs(x) 

n = n + 1 

’ Protokoll der Iteration 

Cells(z0 + n, s0 + 1) = n 

Cells(z0 + n, s0 + 2) = x 

Cells(z0 + n, s0 + 3) = f(x) 

Cells(z0 + n, s0 + 4) = fs(x) 

Loop 

End Sub 

19.10.2011


F 

Lösungen zum Clapeyron-Problem 

In diesem Abschnitt werden Lösungsvorschläge für das Clapeyron-Problem zusammen gestellt. 

F.1 Aufgabe 8.3.1 

Eine mögliche Datenstrukturen gemäß der ER-Modelle wäre die folgende. 

’ Daten eines Feldes 

Type Feld 

L As Double 

i As Double 

End Type 

’ Feldlänge 

’ Trägheitsverhältnis 

Der Container für die Felder wird als globale Variabel angelegt, d.h. er ist aus allen Routinen des 

Moduls direkt ansprechbar. Zudem wird die Anzahl der Felddaten nFeld als globale Variabel 

geführt. 

’ Globale Variable 

Dim FA() As Feld 

’ Container für die Felder 

Dim nFeld As Integer 

’ Feldanzahl 

E. Baeck

F. LÖSUNGEN ZUM CLAPEYRON-PROBLEM Seite 75 

F.2 Aufgabe 8.3.2 

Eine mögliche Datenstrukturen gemäß der ER-Modelle wären die folgende. 

’ Daten einer Streckenlast 

Type SLast 

nF As Integer 

q As Double 

a As Double 

c As Double 

End Type 

’ Feldnummer 

’ Ordinate 

’ Position im Feld 

’ Einleitungslänge 

’ Daten einer Punktlast 

Type PLast 

nF As Integer 

P As Double 

a As Double 

End Type 


’ Ordinate 


’ Daten einer Punktmoment 

Type PMoment 

nF As Integer 

M As Double 

a As Double 

End Type 


’ Ordinate 


’ Daten eines Lastfalls 

Type Lastfall 

Nr As Integer 

’ Lastfallnummer 

’ Lasten und Momente 

SL() As SLast 

PL() As PLast 

PM() As PMoment 

End Type 

’ Container der Streckenlasten 

’ Container der Punktlasten 

’ Container der Punktmomente 

’ Index für Lastfall 

’ "Strichliste" zum Zählen der Lasten 

Type IndLF 

Nr As Integer 


SL As Integer 

’ Zähler der Streckenlasten 

PL As Integer 

’ Zähler der Punktlasten 

PM As Integer 

’ Zähler der Punktmomente 

End Type 

19.10.2011


F.3 Einlesen der Systemdaten und Aufbau des Datenmodell 

Das Programm zählt in einem ersten Schritt die Anzahl der eingegeben Felder, legt dann den 

Container in entsprechender Größe an und überträgt dann in einem zweiten Schritt die Daten 

aus der Tabelle in das Datenmodell. 

’ Einlesen der Strukturdaten 

’ Tabellenoffset: i0, j0 

’ Rückgabe: Fehlerkenner = 0 (alles ok) 

Public Function LeseSystem(i0 As Integer, j0 As Integer) As Integer 

’ Schritt 1: Feldanzahl ermitteln 

Dim i As Integer ’ Laufindex der Zeilen 

Dim j As Integer ’ Laufindex der Spalten 


LeseSystem = 0 

nFeld = 0 

i = i0 + 1 

j = j0 + 1 

’ 0: alles ok 

’ Initialisierung der Feldanzahl 

’ 1. Zeile 

’ 1. Spalte 

’ über alle Zeilen bis leeres Feld gefunden 

Do While (Cells(i, j) "") 

i = i + 1 

Loop 

’ Anzahl der Felder: Offset und Leerfeld berücksichtigen 

nFeld = i - i0 - 1 

’ Wurden Felder eingegeben 

If nFeld < 1 Then 

LeseSystem = 1 

Exit Function 

End If 

’ Container anlegen 

ReDim FA(1 To nFeld) 

’ Schritt 2: Daten lesen und speichern 

For i = 1 To nFeld 

FA(i).L = Cells(i + i0, 1 + j0) 

FA(i).i = Cells(i + i0, 2 + j0) 

Next 

End Function 

E. Baeck


F.4 Einlesen der Belastungsdaten und Aufbau des Datenmodell 

Das Problem des Aufbaus der Belastungsdaten wird in zwei verschiedene Unterprogramme separiert. 

30 

• Der Aufbau des Lastfall-Indexvektors. 

• Der Aufbau des Lastfall-Containers. 

F.4.1 

Aufbau des Lastfall-Indexvektors 

Der Lastfallindex-Vektor ILF wird wie der Feld-Container als globale Variable deklariert. Zudem 

werden die Anzahl der Lastdaten nLast und die extremalen Lastfallnummern lfmin und lfmax 

als globale Variabel geführt. 


Dim ILF() As IndLF 

’ Container der Lastindizes 

Dim nLast As Integer 

Dim lfmin As Integer 

Dim lfmax As Integer 

’ Lastdatenanzahl 

’ minimale Lastfallnummer 

’ maximale Lastfallnummer 

In einem ersten Schritt wird der Lastfallnummern-Bereich ermittelt. 3132 

’ Aufbau des Lastfall-Indexvektors 



Public Function GenLastIndex(i0 As Integer, j0 As Integer) As Integer 

’ Schritt 1: Lastfallbereich ermitteln 


Dim lf As Integer ’ Lastfallnummer aus Tabelle 

Dim typ As Integer ’ Lastfalltyp aus Tabelle 


GenLastIndex = 0 

nLast = 0 

i = 1 

’ 1. Zeile 

’ über alle Zeile 


lf = Cells(i + i0, 1 + j0) ’ Lastfallnummer lesen 

30 Das Zerlegen längerer Programmsequenzen in abgegrenzte Einheiten, Module führt i.A. zu wesentlich übersichtlicheren 

und dadurch verständlicheren Programmen. Daumenwert für die maximale Code-Länge sind 1-2 

A4-Seiten im Ausdruck. 

31 Bei der select case Anweisung im Schritt 2, die in verschiedene Lasttypen verzweigt, wurden in den case- 

Zweigen jeweils zwei Code-Zeilen mit dem : aus Gründen der Übersichtlichkeit zusammen gefasst. 

32 Wenn in einer if...endif-Klammer nur eine Anweisung ausgeführt werden soll, kann auf die Schlüsselworte 

then und endif verzichtet werden. 

19.10.2011


’ 1. Datensatz => Initialisierung 

If i = 1 Then 

lfmax = lf 

lfmin = lf 

’ Extremale Lastfallnummern herausfischen 

Else 

If lfmax < lf Then lfmax = lf 

If lfmin > lf Then lfmin = lf 

End If 

i = i + 1 

Loop 

’ Anzahl der Lasten 

nLast = i - 1 

’ Wurden Lasten eingegeben 

If nLast < 1 Then 

GenLastIndex = 1 

Exit Function 

End If 

’ Container anlegen 

ReDim ILF(lfmin To lfmax) 

’ Schritt 2: Lastdaten der Lastfälle zählen 

For i = 1 To nLast 

lf = Cells(i + i0, 1 + j0) 


ILF(lf).Nr = lf 

’ ... übernehmen 

typ = Cells(i + i0, 3 + j0) ’ Lasttyp 

’ Welche Last liegt vor 

Select Case typ 

’ Steckenlast zählen 

Case 1: ILF(lf).SL = ILF(lf).SL + 1 

’ Punktlast zählen 

Case 2: ILF(lf).PL = ILF(lf).PL + 1 

’ Punktmoment zählen 

Case 3: ILF(lf).PM = ILF(lf).PM + 1 

End Select 

Next 

End Function 

E. Baeck


F.4.2 

Aufbau des Lastfall-Containers 

Der Lastfall-Container LA wird wie der Feld-Container als globale Variable deklariert. 


Dim LA() As Lastfall 

’ Container der Lastfälle 

In einem ersten Schritt wird der Lastfall-Container aus der Information des Lastfall-Indexvektors 

dimensioniert. Bevor die Lasten in die Container eingelesen werden, werden die Lastenzähler im 

Lastfall-Indexvektor zurück gesetzt (=0). Da als Container indizierte Variablen (Felder) eingesetzt 

werden, benötigt man einen Füllzeiger, der als Index für den jeweils nächsten Datensatz 

eingesetzt wird. 

’ Aufbau des Lastfall-Containers und einlesen der Lastdaten 



Public Function GenLastdaten(i0 As Integer, j0 As Integer) As Integer 

’ Schritt 1: Dimensionierung des Lastfall-Containers 


Dim lf As Integer ’ Lastfallnummer aus Tabelle 

Dim typ As Integer ’ Lastfalltyp aus Tabelle 


GenLastdaten = 0 

’ Dimensionieren der Lastfälle 

ReDim LA(LBound(ILF) To UBound(ILF)) 

’ über alle Lastfälle 

For i = LBound(ILF) To UBound(ILF) 

’ für vorhandene Lastfälle werden die 

’ Last-Container dimensioniert 

If ILF(i).Nr > 0 Then 

’ Streckenlasten dimensionieren 

If ILF(i).SL > 0 Then ReDim LA(i).SL(1 To ILF(i).SL) 

’ Punktlasten dimensionieren 

If ILF(i).PL > 0 Then ReDim LA(i).PL(1 To ILF(i).PL) 

’ Punktmomente dimensionieren 

If ILF(i).PM > 0 Then ReDim LA(i).PM(1 To ILF(i).PM) 

End If 

Next 

’ Schritt 2: Einlesen der Lastdaten 

’ - Initialisierung der Lastenzähler 

19.10.2011


For i = LBound(ILF) To UBound(ILF) 

ILF(i).SL = 0 

ILF(i).PL = 0 

ILF(i).PM = 0 

Next 

’ - über alle Datensätze 

’ Zeiger auf ersten Lastdatensatz setzen 

i = 1 


lf = Cells(i + i0, 1 + j0) ’ Lastfallnummer lesen 

typ = Cells(i + i0, 3 + j0) ’ Lasttyp lesen 

’ Welche Last liegt vor 

Select Case typ 

’ Steckenlast lesen 

Case 1 

ILF(lf).SL = ILF(lf).SL + 1 ’ Zähler inkrementieren 

LA(lf).SL(ILF(lf).SL).nF = Cells(i + i0, 2 + j0) 

LA(lf).SL(ILF(lf).SL).q = Cells(i + i0, 4 + j0) 

LA(lf).SL(ILF(lf).SL).a = Cells(i + i0, 5 + j0) 

LA(lf).SL(ILF(lf).SL).c = Cells(i + i0, 6 + j0) 

’ Punktlast lesen 

Case 2 

ILF(lf).PL = ILF(lf).PL + 1 ’ Zähler inkrementieren 

LA(lf).PL(ILF(lf).PL).nF = Cells(i + i0, 2 + j0) 

LA(lf).PL(ILF(lf).PL).P = Cells(i + i0, 4 + j0) 

LA(lf).PL(ILF(lf).PL).a = Cells(i + i0, 5 + j0) 

’ Punktmoment lesen 

Case 3 

ILF(lf).PM = ILF(lf).PM + 1 ’ Zähler inkrementieren 

LA(lf).PM(ILF(lf).PM).nF = Cells(i + i0, 2 + j0) 

LA(lf).PM(ILF(lf).PM).M = Cells(i + i0, 4 + j0) 

LA(lf).PM(ILF(lf).PM).a = Cells(i + i0, 5 + j0) 

End Select 

i = i + 1 

Loop 

’ nächste Lastdaten-Zeile 

End Function 

E. Baeck


F.4.3 

Aufbau der Koeffizientenmatrix 

Die Koefizientenmatrix wird kompakt unter Ausnutzung von Symmetrie und Bandstruktur aufgebaut. 

Die Matrix A wird als globale Variable deklariert. 


Dim A() As Double 

’ Koeffizientenmatrix 

’ Aufbau der Kooeffizentenmatrix A 

’ Der Aufbau erfolgt in kompakter Form unter Ausnutzung von 

’ Symmetrie und Bandstruktur 


Public Function GenMatA() As Integer 


GenMatA = 0 

’ Für ein Felder ist Lösung bekannt 

If nFeld < 2 Then 

GenMatA = 1 

Exit Function 

End If 

’ Anlegen der Matrix 

ReDim A(1 To nFeld - 1, 1 To 2) 

’ Setzen der Matrixelemente 

For i = 1 To nFeld - 1 

If i = 1 Then 

A(1, 1) = 0 

Else 

A(i, 1) = FA(i).L / FA(i).i 

End If 

A(i, 2) = 2 * (FA(i).L / FA(i).i + FA(i + 1).L / FA(i + 1).i) 

Next 

End Function 

19.10.2011


F.4.4 

Lesen einer kompakt gespeicherten Bandmatrix 

In der nachfolgenden Route wird aus der Matrix A das Element A ij gelesen. Das Programm 

berücksichtigt zum einen die Symmetrie der Matrix, zum anderen die kompakte Speicherung 

der Matrix als symmetrische Bandmatrix (siehe auch Abschnitt 8.5.1). 

’ Lesen der Matrixelemente i,j einer globalen Band-Matrix A 

Function AIJ(i As Integer, j As Integer) As Double 

’ i,j -> i,j-i+m+1 mit m=1 

’ i >=j und i-j m Then 

AIJ = 0# 

Exit Function 

End If 

’ 1: oberen Dreieck z.B. a(1,2) 

If j > i Then 

ki = j 

kj = i - j + m + 1 

’ 2: unteres Dreieck + Hauptdiagonale 

Else 

ki = i 

kj = j - i + m + 1 

End If 

AIJ = A(ki, kj) 

End Function 

E. Baeck


F.4.5 

Das Hauptprogramm 

Die einzelnen Teilschritte, die jeweils in eigenen Unterprogrammen codiert wurden, werden nacheinander 

in einem Hauptprogramm aufgerufen. Dieses Hauptprogramm liegt (z.Z. noch) in der 

Ereignisfunktion zum Click-Event. 

Aus der Ereignisfunktion werden die Tabellen-Ursprungskoordinaten den Programmen weiter 

gereicht, die aus den Tabellen Eingabedaten entnehmen. Zudem wird nach jedem Teilschritt 

eine entsprechende Fehlerprüfung durchgeführt, um zu klären, ob eine weiteres Abarbeiten des 

Programms noch sinnvoll ist. 

’ Starten von "Clapeyron" 


’ Einlesen der Strukturdaten 

ierr = MClapeyron.LeseSystem(9, 1) 

’ Prüfen der Rückgabe 

Select Case ierr 

Case 1: MsgBox "Fehler: kein Feld gefunden!": Exit Sub 

End Select 

’ Einlesen Lastindex 

ierr = MClapeyron.GenLastIndex(9, 4) 

’ Prüfen der Rückgabe 

Select Case ierr 

Case 1: MsgBox "Fehler: keine Lasten gefunden!": Exit Sub 

End Select 

’ Einlesen der Lastdaten 

ierr = MClapeyron.GenLastdaten(9, 4) 

’ Aufbau der Kooefizientenmatrix 

ierr = MClapeyron.GenMatA() 

End Sub 

19.10.2011


G 

Lösungen zum Abschnitt Vektor- und Matrixobjekte 

In diesem Abschnitt wird das Arbeiten mit Vektoren und Matrizen unter Verwendung von 

Klassenmodulen (OOP) an Beispielen erläutert (siehe auch Abschnitt 9.2). 

G.1 Deklaration eines Vektor-Klassenmoduls 

In VBA ist es nicht möglich auf Feldelemente (Arrays) eines Klassenmoduls als Public zuzugreifen. 

Aus diesem Grund werden Zugriffsfunktionen als Methoden implementiert, die die internen 

Feldelemente x() belegen oder auslesen. 

Dim x() As Double ’ Vektorkomponenten 

Public n As Integer ’ Vektordimension 



n = 3 ’ Vektoren aus R3 

ReDim x(1 To n) 


x(i) = 0 

Next 

x(1) = 1 

’ Initialisierung mit EV in X-Richtung 

End Sub 

’ Berechnen der Vektorlänge 

Public Function Laenge() As Double 


Laenge = 0# 


Laenge = Laenge + x(i) * x(i) 

Next i 

Laenge = Sqr(Laenge) 

End Function 

’ Vektornormierung 

Public Function Norm() As Double 


l = Laenge() 


x(i) = x(i) / l 

Next i 

Norm = 1 

End Function 

’ Vektor belegen 

E. Baeck

G. LÖSUNGEN ZUM ABSCHNITT VEKTOR- UND MATRIXOBJEKTE Seite 85 

Public Function SetX(dX() As Double) As Integer 

Dim ie As Integer 

ie = n 

If UBound(dX) < n Then ie = UBound(dX) 

For i = 1 To ie 

x(i) = dX(i) 

Next i 

SetX = 1 

End Function 

’ Vektor auslesen 

Public Function GetX(dX() As Double) As Integer 

Dim ie As Integer 

ie = n 

If UBound(dX) < n Then ie = UBound(dX) 

For i = 1 To ie 

dX(i) = x(i) 

Next i 

GetX = 1 

End Function 

’ Rotieren eines Vektors mit Drehmatrix "m" 

Public Function Rot(m As Matrix) As Integer 


Dim xs() As Double 

ReDim xs(n) 


xs(i) = 0# 

For j = 1 To n 

xs(i) = xs(i) + m.GetK(i, j) * x(j) 

Next j 

Next i 


x(i) = xs(i) 

Next i 

Rot = 1 

End Function 

’ Zugriffsfunktion auf Feld x(i) 

Public Function xi(i As Integer) As Double 

xi = x(i) 

End Function 

’ Skalarprodukt mit anderem Vektor 

19.10.2011


Public Function sprod(v As Vektor) As Double 


’ Skalarprodukt 

s = 0 


s = s + x(i) * v.xi(i) 

Next 

sprod = s 

End Function 

’ Testausgabe 

Public Function List() As Integer 

Debug.Print "Vektor: " + Format(x(1), "0.0000") + "; " + _ 

Format(x(2), "0.0000") + "; " + _ 

Format(x(3), "0.0000") + "; " 

List = 1 

End Function 

G.2 Deklaration eines Matrix-Klassenmoduls 

In VBA ist es nicht möglich auf Feldelemente (Arrays) eines Klassenmoduls als Public zuzugreifen. 

Aus diesem Grund werden Zugriffsfunktionen als Methoden implementiert, die die internen 

Feldelemente x() belegen oder auslesen. 

’ Klasse quadratischer n x n-Matrizen 

’ 

Dim x() As Double 


Dim i, j As Integer 


n = 3 

ReDim x(1 To n, 1 To n) As Double 



x(i, j) = 0# 

Next j 

Next i 

End Sub 

’ Belegen der Matrixelemente 

Public Function SetX(dX() As Double) As Integer 



x(i, j) = dX(i, j) 

Next j 

E. Baeck


Next i 

SetX = 1 

End Function 

’ Lesen der Matrixelemente 

Public Function GetX(dX() As Double) As Integer 



dX(i, j) = x(i, j) 

Next j 

Next i 

GetX = 1 

End Function 

’ Lesen eines Matrixelements 

Public Function GetK(ByVal i1 As Integer, ByVal i2 As Integer) As Double 

GetK = x(i1, i2) 

End Function 

’ Testausdruck für den Fall n x n 

Public Function List() As Integer 

Debug.Print "Matrix: " + Format(x(1, 1), "0.0000") + "; " + _ 

Format(x(1, 2), "0.0000") + "; " + _ 

Format(x(1, 3), "0.0000") + "; " 

Debug.Print " " + Format(x(2, 1), "0.0000") + "; " + _ 

Format(x(2, 2), "0.0000") + "; " + _ 

Format(x(2, 3), "0.0000") + "; " 

Debug.Print " " + Format(x(3, 1), "0.0000") + "; " + _ 

Format(x(3, 2), "0.0000") + "; " + _ 

Format(x(3, 3), "0.0000") + "; " 

List = 1 

End Function 

19.10.2011


G.3 Programm Vektor 1 

Das Programm Vektor 1 erzeugt eine Instanz des Vektor-Klassemoduls. Der Vektor wird initialisiert. 

Es wird die Vektorlänge berechnet. Im zweiten Teil des Programms wird der Vektor 

normiert und zur Prüfung erneut die Vektorlänge berechnet und ausgegeben. 

’ Testprogramm für Klasse Vektor 

Sub vektor1() 

Dim l As Double 

Dim v As Vektor 

’ Vektorlänge 

’ Zeiger Vektor 

Dim x(1 To 3) As Double 

x(1) = 2: x(2) = 2: x(3) = 0 

Set v = New Vektor ’ Instanz von Vektor anlegen 

l = v.Laenge() 

Call v.List ’ Vektorausgabe in Direktfenster 

Debug.Print "Länge: " + Format(l, "0.000") 

r = v.SetX(x) ’ Daten setzen 

l = v.Laenge() 



Call v.Norm ’ Normierung des Vektors 


l = v.Laenge() ’ Vektorlänge berechnen 


End Sub 

E. Baeck


G.4 Programm Vektor Drehen 

Das Programm Vektor Drehen erzeugt eine Instanz des Vektor-Klassemoduls v und eines Matrix- 

Klassenmoduls D. Der Vektor wird initialisiert. Die Matrix wird mit den Matrixelementen einer 

2d-Drehmatrix (Drehen um (0,0) um die z-Achse) belegt. Der Drehoperator wird in Form der 

Matrixmultiplikation v ′ = D · v ausgeführt. 

’ Vektor- und Matrixobjekte: 

’ - 2D-Drehmatrix, Drehen eines Vektors 

Sub Vektor_Drehen() 

Dim phi, co, si As Double 

Dim x(1 To 3, 1 To 3) As Double 

Dim y(1 To 3) As Double 

’ Drehwinkel 

phi = Atn(1#) / 45# * 90# 

’ Drehmatrix 

Dim m As Matrix 

’ Vektor 

Dim v As Vektor 

’ Initialisierungen 

Set m = New Matrix 

Set v = New Vektor 

co = Cos(phi) 

si = Sin(phi) 

x(1, 1) = co: x(1, 2) = -si: x(1, 3) = 0# 

x(2, 1) = si: x(2, 2) = co: x(2, 3) = 0# 

x(3, 1) = 0#: x(3, 2) = 0#: x(3, 3) = 1# 

y(1) = 1#: y(2) = 0#: y(3) = 0# 

’ Setzen der Objektwerte 

n = m.SetX(x) 

n = v.SetX(y) 

’ Ausgabe der Objekte 

n = m.List() 

n = v.List() 

’ Multiplikation: v := m*v 

n = v.Rot(m) 

’ Ausgabe des Vektors 

n = v.List() 

End Sub 

19.10.2011


H 

Lösungen zum Abschnitt Rahmen und Collection 

In diesem Abschnitt wird die Implementierung des Speicherkonzepts zum Rahmenbeispiel dargestellt. 

Es werden die Klassenmodule Stab und Knoten angelegt (siehe Abschnitt 9.4). Die 

Assoziation zwischen Stab und Knoten erfolgt über die Objektzeiger der Knoten-Instanzen. 

Stäbe und Knoten werden in den VBA-Listen , den Collections, gespeichert. 

H.1 Deklaration des Stab-Klassenmoduls 

Ein Stab-Objekt erhält die Attribute Stabnummer (Nr), E-Modul (E) und Querschnittsfläche 

(a) sowie die Knoten-Instanz-Zeiger KnA und KnB. 

Die Methode Laenge ermittelt die Stablänge über die Koordinatenwerte der assoziierten Knoten- 

Instanzen. 

Public Nr As Integer 

Public E As Double 

Public a As Double 

Public KnA As Knoten 

Public KnB As Knoten 

’ Nummer des Stabes 

’ E-Modul 

’ Fläche 

’ Knoten A 

’ Knoten B 

’ Berechnen der Stablänge 

Public Function Laenge() As Double 

Laenge = Sqr((KnA.x - KnB.x) ^ 2 + (KnA.y - KnB.y) ^ 2) 

End Function 

H.2 Deklaration des Knoten-Klassenmoduls 

Ein Knoten erhält die Attribute Knotennummer (Nr) und die Knotenkoordinaten (x und y). 

Die Methode Verschieben addiert einen Translationsvektor auf den Ortsvektor des Knotens 

(Koordindatenwerte). 

Public Nr As Integer 

Public x As Double 

Public y As Double 

’ Nummer des Knotens 

’ x-Koordinate 

’ y-Koordinate 

’ Verschieben eines Knotens 

Public Sub Verschieben(dx As Double, dy As Double) 

x = x + dx 

y = y + dy 

End Sub 

E. Baeck

H. LÖSUNGEN ZUM ABSCHNITT RAHMEN UND COLLECTION Seite 91 

H.3 Implementierung des Anwendungsprogramms 

Das Anwendungsprogramm besteht aus den folgenden drei Teilprogrammen. 

• Einlesen 

liest die Daten aus der Tabelle, erzeugt die Instanzen der Stäbe bzw. Knoten und speichert 

diese in die Stabliste SL bzw. Knotenliste KL. Als Parameter erwartet das Programm den 

Offset (i0,j0) des Eingabebereichs der Tabelle. 

• Ausgabe 

schreibt die Daten der Stäbe bzw. Knoten, die in den Listen (Collections) gespeichert wurden 

in den Ausgabebereich der Tabelle. Zudem wird noch die Länge der Stäbe ausgegeben. 

Als Parameter erwartet das Programm den Offset (i0,j0) des Ausgabebereichs der Tabelle. 


addiert den in der Tabelle eingegebenen Verschiebungsvektor auf alle Knotenkoordinaten. 

Als Parameter werden die Verschiebungen in x- bzw. y-Richtung erwartet. 

• StabAnzahl 

ermittelt als Hilfsfunktion die Anzahl der bereits eingegebenen Stäbe. Wurden keine Stäbe 

eingelesen, so wird vor dem Ausführen der Verschiebungsfunktion der Datenbestand eingelesen. 

H.3.1 

Die Listen 

Die Listen (Collection) werden als globale Variablen angelegt, damit sie von allen Programmen 

des Moduls erreichbar sind. 

Dim KL As New Collection 

Dim SL As New Collection 

’ Anlegen der Knotenliste 

’ Anlegen der Stabliste 

H.3.2 

Die Funktion Einlesen 

Es werden zunächst die Listen der Knoten und Stäbe zurückgesetzt, d.h. es werden alle Instanzen 

mit der Item-Funktion gelesen und gelöscht (=nothing). Der Indexeintrag der Collection wird 

mit der Funktion Remove entfernt. 33 Im nächsten Schritt werden zunächst die Knotendaten 

eingelesen und die Knotenliste aufgebaut. Die Knoten werden für den Aufbau der Stabdaten 

benötigt. Als letzter Schritt werden die Stabdaten eingelesen, hierbei werden die Knotennummern 

in Knotenverweise gewandelt. Diese werden aus der bereits existierenden Knotenliste abgegriffen. 

Die Parameter i0 und j0 sind Zeilen- und Spaltenoffset des Eingabebereichs der Tabelle. 

33 Da beim Löschen in einer Liste die verbleibenden Einträge zum Listenkopf rücken, wenn vor ihnen ein Eintrag 

gelöscht wird, wird mit der Anzahl der in der Liste gespeicherten Elemente immer der Erste Eintrag gelöscht. 

19.10.2011


’ Einlesen der Daten aus Tabelle 

Public Sub Einlesen(i0 As Integer, j0 As Integer) 

Dim s As Stab 

Dim k As Knoten 

’ nur Stabzeiger! 

’ Knotenzeiger 

’ Liste der Knoten zurücksetzen 

N = KL.Count 

For i = 1 To N 

Set k = KL(1) ’ Zeiger holen 

Set k = Nothing ’ Objekt löschen 

KL.Remove (1) ’ Index löschen 

Next 

’ Liste der Stäbe zurücksetzen 

N = SL.Count 

For i = 1 To N 

Set s = SL(1) ’ Zeiger holen 

Set s = Nothing ’ Objekt löschen 

SL.Remove (1) ’ Index löschen 

Next 

’ Einlesen der Knoten 

iZ = 1 ’ 1. Zeile 

Do While (Cells(i0 + iZ, j0 + 7) "") 

Set k = New Knoten 

’ neus Knotenobjekt anlegen 

k.Nr = Cells(i0 + iZ, j0 + 7) 

k.x = Cells(i0 + iZ, j0 + 8) 

k.y = Cells(i0 + iZ, j0 + 9) 

iZ = iZ + 1 ’ nächste Zeile 

KL.Add Item:=k, key:="K" & k.Nr 

Loop 

’ Einlesen der Stäbe 

iZ = 1 ’ 1. Zeile 

Do While (Cells(i0 + iZ, j0 + 1) "") 

Set s = New Stab 

’ neues Stabobjekt anlegen 

s.Nr = Cells(i0 + iZ, j0 + 1) 

s.E = Cells(i0 + iZ, j0 + 2) 

s.a = Cells(i0 + iZ, j0 + 3) 

nA = Cells(i0 + iZ, j0 + 4) 

nB = Cells(i0 + iZ, j0 + 5) 

Set s.KnA = KL("K" & nA) 

E. Baeck


Set s.KnB = KL("K" & nB) 

iZ = iZ + 1 

’ nächste Zeile 

SL.Add Item:=s, key:="S" & s.Nr 

Loop 

End Sub 

H.3.3 

Die Funktion Ausgabe 

In einer Schleife über die Stabliste werden alle Stab-Instanzen aus der Liste abgegriffen. Zunächst 

werden Stab-Attribute in den Ausgabebereich der Tabelle geschrieben. Die Knotenkoordinaten 

werden über die Verweise aus der assoziierten Knoteninstanz abgegriffen und ausgegeben. Die 

Länge des Stabes liefert die Methode Laenge des Stabes, die ihrerseits auf die Knotenkoordinaten 

der assoziierten Knoten-Instanzen verweisen (Abschnitt H.1). Die Parameter i0 und j0 sind 

Zeilen- und Spaltenoffset des Ausgabebereichs der Tabelle. 

’ Ausgabe der Daten in die Tabelle 

Public Sub Ausgabe(i0 As Integer, j0 As Integer) 

Dim s As Stab 

’ nur Stabzeiger! 

’ über alle Stäbe 

For i = 1 To SL.Count 

Set s = SL(i) 

’ Stab holen 

Cells(i0 + i, j0 + 1) = s.Nr 

Cells(i0 + i, j0 + 2) = s.E 

Cells(i0 + i, j0 + 3) = s.a 

Cells(i0 + i, j0 + 4) = s.KnA.x 

Cells(i0 + i, j0 + 5) = s.KnA.y 

Cells(i0 + i, j0 + 6) = s.KnB.x 

Cells(i0 + i, j0 + 7) = s.KnB.y 

Cells(i0 + i, j0 + 8) = s.Laenge() 

Next 

End Sub 

19.10.2011


H.3.4 

Die Funktion Verschieben 

In einer Schleife über die Knotenliste werden alle Knoten-Instanzen aus der Liste abgegriffen. 

Für jeder dieser Knoten-Instanzen wird die Knoten-Methode Verschieben aufgerufen (Abschnitt 

H.2). 

’ Knoten verschieben 

Public Sub Verschieben(vx As Double, vy As Double) 

Dim k As Knoten 

’ über alle Knoten 

For i = 1 To KL.Count 

Set k = KL(i) 

Call k.Verschieben(vx, vy) 

’ Knoten holen 

’ und verschieben 

Next 

End Sub 

H.3.5 

Die Funktion StabAnzahl 

Mit der Funktion StabAnzahl ermittelt die Verschieben-Ereignisfunktion, ob bereits Stab- 

Instanzen in die Stabliste gespeichert wurden. Hierfür ermittelt StabAnzahl über die Methode 

Count die Anzahl der Listenelemente. 

’ Anzahl der Stäbe ermitteln 

Public Function StabAnzahl() As Integer 

StabAnzahl = SL.Count 

End Function 

H.3.6 

Die Ereignisfunktionen 

Die erste Ereignisfunktion 34 wird aufgerufen, wenn die Schaltfläche Einlesen der Daten betätigt 

wird. Mit Offset (4,0) wird der Eingabebereich der Tabelle ausgelesen. Die Daten werden in 

Listen gespeichert und in aufbereiteter Form mit Offeset (22,0) in den Ausgabebereich der 

Tabelle eingetragen 


Call Staebe.Einlesen(4, 0) 

Call Staebe.Ausgabe(22, 0) 

End Sub 

34 Die Ereignisfunktionen stehen im Code-Bereich des Tabellenobjekts, im Order Microsoft Excel Objekte. 

E. Baeck


Die zweite Ereignisfunktion wird aufgerufen, wenn die Schaltfläche Verschieben betätigt wird. 

Zunächst werden die Daten des Verschiebungsvektors (vx,vy) aus der Tabelle gelesen. Falls keine 

Stab-Instanzen in der Stabliste gefunden werden, wird der Eingabebereich der Tabelle eingelesen, 

die Datenstrukturen werden aufgebaut. Im zweiten Schritt werden die Knoten verschoben, im 

dritten die Daten des verschobenen Rahmens in den Ausgabebereich der Tabelle eingetragen. 


Dim vx As Double 

Dim vy As Double 

vx = Range("VX") 

vy = Range("VY") 

’ Verschiebung in x 

’ Verschiebung in y 

If Staebe.StabAnzahl < 1 Then 

Call Staebe.Einlesen(4, 0) 

End If 

Call Staebe.Verschieben(vx, vy) 

Call Staebe.Ausgabe(22, 0) 

End Sub 

19.10.2011


I 

Lösungen zum Abschnitt 2-fach verkettete Listen 

In diesem Abschnitt wird die Implementierung einer 2-fach verketteten Liste dargestellt. Die 

Liste besteht aus zwei Klassenmodulen. Der Klassenmodul VListe ist das Hauptobjekt, das 

die einzelnen Listenmethoden enthält. Der Klassenmodul VNode dient als Listenelement, das 

zum einen Bestandteil der Listentopologie ist, zum anderen die Zeiger auf die Instanzen der 

einzuspeichernden Datenobjekte erhält (siehe Abschnitt 9.5). 

I.1 Deklaration des VNode-Klassenmoduls 

Der Listenknoten enthält nur eine Methode, die Initialisierung. Alle Zeiger werden auf nothing 

gesetzt. Der Knoten ist standardmäßig ein Datenknoten. 

Public prv As Object 

Public nxt As Object 

Public Dat As Object 

’ Zeiger auf vorhergehenden Knoten 

’ Zeiger auf nachfolgenden Knoten 

’ Zeiger auf Daten 

Public Ken As Integer 

’ 0: Datenknoten 

’ 1: Startknoten 

’ 2: Endknoten 


Set prv = Nothing 

Set nxt = Nothing 

Set Dat = Nothing 

Ken = 0 

End Sub 

I.2 Deklaration des VListe-Klassenmoduls 

Der Klassenmodul VListe implementiert die Container-Klasse. In der Instanz-Initialisierung wird 

Start- und Endknoten in die Liste aufgenommen. Beide Knoten werden gegenseitig verzeigert. 

Public Count As Integer 

’ Anzahl der Datenknoten 

Public N1 As VNode 

Public NL As VNode 

’ Startknoten 

’ Endknoten 


Set N1 = New VNode: N1.Ken = 1 

Set NL = New VNode: NL.Ken = 2 

’ Startknoten setzen 

’ Endknoten setzen 

Set N1.nxt = NL 

Set NL.prv = N1 

’ Liste ist leer 

’ Start -> Ende 

End Sub 

E. Baeck

I. LÖSUNGEN ZUM ABSCHNITT 2-FACH VERKETTETE LISTEN Seite 97 

I.2.1 

Daten am Listenkopf einfügen 

Implementierung nach Abschnitt 9.5.2. 

’ Objekt am Listenkopf einfügen 

Public Function AddFirst(Dat As Object) As Integer 

Dim N As New VNode 

’ Neuen Knoten erzeugen 

Set N1.nxt.prv = N 

Set N.nxt = N1.nxt 

Set N1.nxt = N 

’ ... ist Vorgänger des ehemals ersten 

’ ... der Nachfolger ist eben dieser 

’ ... der neue Knoten ist nun erster der Liste 

Set N.prv = N1 

Set N.Dat = Dat 

’ ... der Vorgänger des ersten ist der Startknoten 

’ ... und dann der Zeiger auf die Daten 

Count = Count + 1 

AddFirst = Count 

’ ... damit Liste um 1 vergrößert 

End Function 

I.2.2 

Daten am Listenende einfügen 

Implementierung nach Abschnitt 9.5.2. 

’ Objekt am Listenende einfügen 

Public Function AddLast(Dat As Object) As Integer 

Dim N As New VNode 

’ Neuen Knoten erzeugen 

Set NL.prv.nxt = N 

Set N.prv = NL.prv 

Set NL.prv = N 

’ ... ist nächster des letzten 

’ ... vorhergehender ist vormals letzter 

’ ... wird neuer letzter Knoten 

Set N.nxt = NL 

Set N.Dat = Dat 

’ ... Listenende zeigt auf neuen Knoten 

’ ... und Datenzeiger setzen 


AddLast = Count 


End Function 

19.10.2011


I.2.3 

Vorwärtsiterator 

Implementierung nach Abschnitt 9.5.4. Die Implementierung setzt voraus, dass die zurückgegebenen 

Listenknoten (Instanz VNode) vom aufrufenden Programm nicht verändert werden. 

’ Ersten Knoten holen 

Public Function GetFirst(Nd As VNode) As Integer 

If N1.nxt.Ken = 2 Then 

GetFirst = 0 

’ ... Listenende (Kein Datenknoten vorh.) 

Else ’ ... 0: Ende 

Set Nd = N1.nxt 

’ ... ersten Datenknoten holen 

GetFirst = 1 ’ ... 1: Daten vorhanden 

End If 

End Function 

’ Nächsten Knoten holen 

Public Function GetNext(Nd As VNode) As Integer 

If Nd.nxt.Ken = 2 Then 

’ ... Listenende (Kein weiterer Datenknoten vorh.) 

GetNext = 0 ’ ... 0: Ende 

Else 

Set Nd = Nd.nxt 

’ ... nächsten Datenknoten holen 

GetNext = 1 ’ ... 1: Daten vorhanden 

End If 

End Function 

In nachfolgendem Beispiel wird eine Liste mit Stab-Instanzen iteriert. 

... 

Dim L As new VListe ’ ... Instanz der Liste 

Dim Nd As New VNode 

’ ... Knoteninstatnz 

... Aufbau der Liste ... 

’ Liste vorwärts iterieren 

nret = L.GetFirst(Nd) 

’ ... holen des ersten Knotens 

Do While (nret > 0) 

’ ... nächsten holen solange das Ende 

Debug.Print " Stab: " & Nd.Dat.Nr ’ ... der Liste nicht erreicht ist. 

nret = L.GetNext(Nd) 

’ ... Zuvor Stabnummer ausgeben 

Loop 

... 

E. Baeck

I. LÖSUNGEN ZUM ABSCHNITT 2-FACH VERKETTETE LISTEN Seite 99 

I.2.4 

Einfügen eines Knotens 

Implementierung nach Abschnitt 9.5.2. Die Implementierung setzt voraus, dass die zurückgegebenen 

Listenknoten (Instanz VNode) vom aufrufenden Programm nicht verändert werden. 

Ein neuer Listenknoten ist im aufrufenden Programm zu erzeugen und mit den entsprechenden 

Daten zu versehen. Das Einfügen des Listenknotens in die Liste über nimmt die Methode Insert. 

’ Knoten einfügen vor Referenzknoten 

Public Function Insert(Nd As VNode, NdNew As VNode) As Integer 

If Nd.Ken = 1 Then 

Insert = 0 

Exit Function 

End If 

’ ... Einfügen vor Start nicht möglich 

Set Nd.prv.nxt = NdNew 

Set NdNew.prv = Nd.prv 

Set NdNew.nxt = Nd 

Set Nd.prv = NdNew 

’ ... prv- von Nd soll auf Ndnew zeigen 

’ ... Belegen der Zeiger des neuen Knotens 

’ ... NdNew wird vor Nd eingefügt 


Insert = 1 


End Function 

19.10.2011


J 

Lösungen zu Sortieralgorithmen 

In diesem Abschnitt wird das 

Laufzeitverhalten der Sortieralgorithmen 

SelectSort, BubbleSort 

und QuickSort verglichen. 

Mit der Schaltfläche Zufallszahlen 

werden Zufallszahlen im Bereich 

des vorgegebenen Zahlenintervalls 

erzeugt. 

Mit den weiteren Schaltflächen 

werden die drei verschiedenen 

Sortieralgorithmen aufgerufen. 

Die generierten Zufallszahlen 

werden nach Größe aufsteigend 

sortiert. Es wird jeweils die Anzahl 

der erfolgten Vertauschungen 

ausgegeben. 

Der erforderliche Aufwand der 

hier betrachteten Sortierverfahren 

SelectSort, BubbleSort und 

QuickSort ergibt sich zu 

Abbildung 52: Vergleich dreier Sortieralgorithmen 

• SelectSort benötigt n 2 /2 Vergleiche und n Vertauschungen. 

• BubbleSort benötigt im ungünstigsten Fall n 2 /2 Vergleiche und n 2 /2 Vertauschungen. 

• Quicksort benötigt im Mittel 2 · n · Ln(n) Vergleiche. 

Der Aufwand der Vergleiche bei elementaren Sortierverfahren ist ca. von gleicher Größenordnung. 

Dem gegenüber liegt der Aufwand der Vergleiche bei der QuickSort-Sortierung bei Orndung 

n · Log(n). 

Bei beispielsweise 300 Zufallszahlen 35 aus dem Intervall 1 bis 1000 benötigen SelectSort und 

BubbleSort 44850 Vergleiche (siehe Abbildung 52). Demgegenüber benötigt Quicksort 605 Vergleiche. 

36 

35 Die für die Sortierung erzeugten Reihen von Zufallszahlen sind in den vorliegenden Sortierungen unterschiedlich. 

Das Laufzeitverhalten ist jedoch annähernd unabhängig von der gewählten Zufallszahlenreihe. 

36 Quicksort benötigt ca. n · Log(n) Vergleiche, die beiden anderen Sortierungen benötigen ca. n 2 /2 Vergleiche. 

Bei n = 1000 ergibt sich ein Leistungsquotient von (n · Log(n))/n 2 /2 = 2 · Log(n)/n = 2 · 3/1000 = 0, 6%, d.h. 

der Aufwand für Quicksort im Vergleich zu den beiden anderen Sortierverfahren liegt bei 1000 zu sortierenden 

Elementen demnach unter 1%. 

E. Baeck

J. LÖSUNGEN ZU SORTIERALGORITHMEN Seite 101 

J.1 Die Ereignisfunktionen 

Die Ereignisfunktionen werden aus dem Modul Sortieren aufgerufen. Als Parameter werden die 

Offsets des Bereichs der Tabelle übergeben, in der die Zufallszahlen ausgegeben werden. Zudem 

wird die Anzahl der generierten Zufallszahlen aus dem Eingabebereich der Tabelle mit Range 

gelesen und übergeben. 


Call Sortieren.Zufallszahlen(9, 0, Range("SORTANZ")) 

End Sub 


Call Sortieren.SelectSortieren(9, 0, Range("SORTANZ")) 

End Sub 


Call Sortieren.QuickSortieren(9, 0, Range("SORTANZ")) 

End Sub 


Call Sortieren.BubbleSortieren(9, 0, Range("SORTANZ")) 

End Sub 

J.2 Generierung der Zufallszahlen 

Die Zufallszahlen können in VBA mit der Funktion Rnd 37 erzeugt werden. Rnd liefert hierfür 

eine Zufallszahl 38 . 

Die genierten Zufallszahlen werden wie folgt in das vorgegebene Intervall skaliert. 

Z = (Z bis − Z von ) · Z rnd + Z von (74) 

Das Intervall der Zufallszahlen wird aus der Tabelle über Range abgegriffen. Bevor die Zufallszahlen 

generiert und die Tabelle geschrieben werden, wird diese im Ausgabebereich zunächst von 

Altdaten befreit, d.h. es wird die Hilfsfunktion Loeschen aufgerufen. Es wird die erste Spalte 

nach Einträgen untersucht. Falls ein Eintrag gefunden wird, wird die Anzahl der vorgegebenen 

Spalten gelöscht. Falls kein Eintrag gefunden wird, geht das Programm davon aus, dass das 

Ende des zu löschenden Bereichs erreicht wurde. 

37 Reihen von Zufallszahlen sind dann reproduzierbar, wenn der Zufallszahlengenerator nicht mit einer zufälligen 

Information vorbesetzt wird. Dies erfolgt durch Aufruf der Routine Randomize 

38 Ein Zufallszahlen-Generator erzeugt Pseudo-Zufallszahlen. Pseudo-Zufallszahl bedeutet, dass bei exakt identischen 

Eingangsdaten (Zeitwerte etc.) der Zufallszahlen-Generators Zahlen reproduzierbar erzeugt. Da die Eingangsdaten 

des Zufallszahlen-Generators kaum reproduzierbar und somit zufällig sind, die Algorithmen jedoch 

deterministisch, werden die generierten Zahlen nicht als Zufallszahlen sondern als Pseudo-Zufallszahlen bezeichnet. 

Der Einfachheit halber sind hier Zufallszahlen generell als Pseudo-Zufallszahlen zu verstehe. 

19.10.2011


’ Erzeugen von Zufallszahlen 

Sub Zufallszahlen(i0 As Integer, j0 As Integer, nAnz As Integer) 

Dim dVon As Double 

Dim dBis As Double 

dVon = Range("S_VON") 

dBis = Range("S_BIS") 

’ Tabelle löschen 

i = Util.Loeschen(i0, j0, 2) 

’ Zufallszahlen generieren 

call Randomize 

For i = 1 To nAnz 

Cells(i0 + i, 1) = i 

Cells(i0 + i, 2) = (dBis - dVon) * Rnd + dVon 

Next 

End Sub 

Nachfolgend das Hilfsprogramm Loeschen, dass einen Tabellenbereich löscht unter Vorgabe des 

Zeilen- und Spaltenoffset sowie der Spaltenanzahl. 

’ Löschen eines Tabellenbereichs 

Public Function Loeschen(i0 As Integer, j0 As Integer, nSpalten As Integer) _ 

As Integer 

Dim nZeile As Integer 


’ Zeilenzähler 

nZeile = 1 

’ erste Zeile ’lokal’ 

’ über alle Zeilen 

Do Until Cells(i0 + nZeile, j0 + 1) = "" 

’ über die Spalten 

For i = 1 To nSpalten 

Cells(i0 + nZeile, j0 + i) = "" 

Next 

nZeile = nZeile + 1 

Loop 

Loeschen = nZeile 

End Function 

E. Baeck


J.3 Sortieralgorithmen 

In diesem Abschnitt wird eine VBA-Implementierung der Sortieralgorithmen SelectSort (siehe 

6.1), BubbleSort (siehe 6.2) und QuickSort (siehe 10.1) dargestellt. 

Um die Leistungsfähigkeit der Algorithmen darzustellen werden die globalen Variablen nT ausch 

und nV ergleich als Zähler für Vertauschungen und Vergleiche eingeführt. Die Zähler werden 

jeweils vor der Sortierung zurückgesetzt. Die Vertauschung der Zufallszahlen erfolgt in folgender 

Routine, die von allen implementierten Sortierverfahren aufgerufen wird. 

’ Datensätze tauschen 

Sub tausche(i, j) 

For k = 1 To 2 

s = Cells(i, k) 

Cells(i, k) = Cells(j, k) 

Cells(j, k) = s 

Next 

nTausch = nTausch + 1 

End Sub 

J.3.1 

Implementierung von SelectSort 

’ Hauptprogramm: Selectsort 

Sub SelectSortieren(i0 As Integer, j0 As Integer, nAnz As Integer) 

nTausch = 0 

nVergleich = 0 

’ Protokoll 

Cells(i0 + 1, j0 + 3) = "Sortierung in Arbeit..." 

’ über alle Auswahlpositionen 

For i = 1 To nAnz - 1 

x = i 

’ extremale Größe aus Intervall ermitteln 

For j = i + 1 To nAnz 

dvj = Cells(i0 + j, 2) 

dvx = Cells(i0 + x, 2) 

If dvj < dvx Then x = j 

nVergleich = nVergleich + 1 

Next 

’ extremale Größe an aktuelle Spitzenposition tauschen 

Call tausche(i0 + i, i0 + x) 

Next 

19.10.2011


’ Protokoll 

Cells(i0 + 1, j0 + 3) = Format(nVergleich, "0") + " Vergleiche und " + _ 

Format(nTausch, "0") + " Vertauschungen (SelectSort)" 

End Sub 

J.3.2 

Implementierung von BubbleSort 

’ Hauptprogramm: Bubblesort 

Sub BubbleSortieren(i0 As Integer, j0 As Integer, nAnz As Integer) 

nTausch = 0 


’ Protokoll 


’ über alle Auswahlpositionen 

For i = nAnz To 1 Step -1 

’ Auswahlgebiet 

For j = 2 To i 

dV1 = Cells(i0 + j - 1, j0 + 2) 

dv2 = Cells(i0 + j, j0 + 2) 


If dV1 > dv2 Then 

Call tausche(i0 + j - 1, i0 + j) 

End If 

Next 

Next 

’ Protokoll 


Format(nTausch, "0") + " Vertauschungen (BubbleSort)" 

End Sub 

E. Baeck


J.3.3 

Implementierung von QuickSort 

’ Hauptprogramm: Quicksort 

Sub QuickSortieren(i0 As Integer, j0 As Integer, nAnz As Integer) 

nTausch = 0 


’ Protokoll 


’ Sortierung 

Call qsort(i0 + 1, i0 + nAnz) 

’ Protokoll 


Format(nTausch, "0") + " Vertauschungen (QuickSort)" 

End Sub 

Im folgenden wird das Programm qsort dargestellt, das rekursiv ein Intervall der zu sortierenden 

Menge bezogen auf einen Teiler vorsortiert. 39 ausgeschaltet würde. 

’ Vorsortierung des Bereichs von l (links) bis r (rechts) 

Sub qsort(l, r) 

’ Teilfeld enthält nur ein Element 

If r


’ mit j von rechts nach links 

Do 

j = j - 1 

w = Cells(j, 2) 


Loop While w > v and j > l 

’ bereits vorsortiert 

If i >= j Then Exit Do 

Call tausche(i, j) 

Loop 

’ Setze r an endgültige Position 

Call tausche(i, r) 

’ das ganze dann auf Teilgebiete anwenden 

’ - linkes Teilgebiet 

Call qsort(l, i - 1) 

’ - linkes Teilgebiet 

Call qsort(i + 1, r) 

End Sub 

E. Baeck

K. LÖSUNG ZUR BRENDT’SCHEN FORMEL Seite 107 

K 

Lösung zur Brendt’schen Formel 

In diesem Abschnitt eine Implementierung 

der Brendt’schen Formel 

(Gleichung 12) gegeben. 

Mit der ersten Schaltfläche wird 

die einzulesende Datei, die die 

Profildaten enthält, festgelegt. 

Mit der zweiten Schaltfläche wird Abbildung 53: Einlesen einer sequentiellen Datei 

das Einlesen der Profildaten aus 

der vorgegebenen Datei und die Berechnung des Torsionsträgheitsmomentes nach 2. Brendt’scher 

Formel angestoßen. 

K.1 Die Ereignisfunktion zur Festlegung des Dateinamens 

Um den Dateinamen der einzulesenden Datei festzulegen wird in der Ereignisfunktion die Methode 

GetOpenFilename des EXCEL-Application-Objekts eingesetzt. 


datei$ = Application.GetOpenFilename( _ 

filefilter:="Textdatei (*.txt),*.txt") 

If Not datei$ = "Falsch" Then 

Range("DNAME") = datei$ 

Abbildung 54: Dateinamen festlegen 

End If 

End Sub 

K.2 Die Ereignisfunktion zu Datenimport und Berechnung 

Wurde der Dateinamen vereinbart, kann die zweite Funktion 

Lesen aus dem Modul Brendt gestartet werden. 

Sie importiert die Daten aus der vereinbarten Textdatei 

und berechnet die gewünschten Größen nach der 2. 

Brendt’schen Formel. Im Beispiel der Abbildung 55 wird 

ein rechteckiges Kastenprofil mit koinstanter Blechdicke 

beschrieben. 

Abbildung 55: Eingabedaten 


Call Brendt.Lesen 

End Sub 

19.10.2011


K.3 Die Datenstruktur 

Die Konturknoten des Profils, d.h. je ein Datensatz der Datei, werden in Datenstrukturen (Type) 

gespeichert. Da mehrere Knoten zu speichern sind, wird ein Feld als globale Variable des Typs 

KKNOTEN angelegt. Die Anzahl der Knoten soll dynamisch zur Laufzeit des Programms vereinbart 

werden, d.h. der Indexbereich des Feldes wird zunächst leer gelassen (K()). 

’ Knoten der Kontur 

Type KKNOTEN 

y As Double 

z As Double 

t As Double 

End Type 

’ Variable der Kontur 

Dim K() As KKNOTEN 

K.4 Einlesen der Daten aus der Profil-Textdatei 

Das Hauptprogramm der Verarbeitung Lesen wird aus dem Modul Brendt gestartet, somit ist 

es als Public zu vereinbaren. 

1. In einem ersten Schritt wird zunächst die Anzahl der Konturknoten ermittelt. Ein Knoten 

wird im Knotenfeld angelegt (Redim K(1 to 1)). 

2. In einem zweiten Schritt wird die Datei geöffnet. Es werden die Datensätze, d.h. die Anzahl 

der Knoten in der Datei ermittelt. Für diese und den gedoppelten 1. Knoten, da zyklisches 

Problem, wird der Speicherplatz angelegt. 

3. Im dritten Schritt wird die Datei erneut geöffnet. Nun werden die Daten in die Datenstruktur 

gelesen. Nach Ende des Einlesens wird die Datei geschlossen und der erste Knoten als 

Kopie in den Speicher des N+1-ten geschrieben. 

4. Die Ausgabetabelle wird von Altdaten befreit. Die in der Datenstruktur gespeicherten 

Daten werden in die Tabelle geschrieben. 

5. Die Berechnung nach der 2. Brendt-schen Formel wird gestartet. 

’ Einlesen der Daten 

Public Sub Lesen() 

Dim datei As String 

Dim nAnz As Integer 


’ Dateiname 

’ Anzahl der Knoten 

datei = Range("DNAME") 

nAnz = 0 

’ Dateinamen aus Tabelle holen 

’ Konturknotenanzahl bestimmen 

’ Datei öffnen 

E. Baeck


ReDim K(1 To 1) 

Open datei For Input As #1 

’ Datei zum Lesen öffnen 

’ über alle Datensätze 

Do Until EOF(1) 

’ Lesen bis zum Dateiende 

Input #1, K(1).y, K(1).z, K(1).t 

nAnz = nAnz + 1 ’ ... und Datensätze zählen, 

Loop 

’ Datei schließen 

Close #1 

’ dann Datei wieder schließen 

’ Konturknotendatenstruktur 

ReDim K(1 To nAnz + 1) 

Open datei For Input As #1 

’ Jetzt Speicher für Knoten anlegen 

’ und Datei erneut öffnen 

’ über alle Datensätze 

For i = 1 To nAnz 

’ Einlesen und speichern aller Knotendaten 

Input #1, K(i).y, K(i).z, K(i).t 

Next 

K(nAnz + 1) = K(1) 

’ Datei schließen 

Close #1 

’ 1. Knoten als Knoten N+1 doppeln, 

’ da zyklisches Problem 

’ Ausgaber der Daten in Tabelle 

Call Loeschen("KKTAB", 3) 

For i = 1 To nAnz + 1 

Range("KKTAB")(i, 1) = K(i).y 

Range("KKTAB")(i, 2) = K(i).z 

Range("KKTAB")(i, 3) = K(i).t 

Next 

’ Berechnung durchführen und Werte ausgeben 

Call Berechnung 

’ Starten der Berechnung 

End Sub 

Das Löschen der Tabelle erfolgte mit folgendem Programm. Der erste Paramter ist die Bezeichnung 

des ersten Tabellenfeldes, d.h. des Tabellenfeldes der ersten Zeile und der ersten Spalte. 

Der zweite Parameter gibt an, wieviele Spalten gelöscht werden sollen, wenn in der ersten Spalte 

der betrachteten Teiltabelle kein Leertext gefunden wird. Der Vorgang des Löschens beginnt in 

der ersten Tabellenzeile und wird solange in einer nächsten Zeile fortgesetzt, bis in dieser ein 

Leertext gefunden wird. 

’ Löschen eines Tabellenbereichs 

Sub Loeschen(z0 As String, nSpa As Integer) 

Dim iz As Integer 

19.10.2011


Dim j As Integer 

iz = 1 

Do While Range(z0)(iz, 1) "" 

For j = 1 To nSpa 

Range(z0)(iz, j) = "" 

Next 

Loop 

End Sub 

K.5 Hilfsfunktionen der Berechnung 

Um das Berechnungsprogramm übersichtlicher zu gestalten, werden allgemeine Rechenoperationen, 

wie die Bestimmung einer mittleren Dicke zwischen zwei Knoten, die Berechnung des 

Abstandes zweier Knoten und die Berechnung der Polygonfläche in Unterprogrammen ausgelagert. 

K.5.1 

Berechnung der mittlerern Blechdicke 

Die Funktion berechnet die mittlere Dicke der Verbindung zwischen den Konturknoten i und 

i+1. 

’ Gestimmt die Dicke 

Public Function GetDicke(i As Integer) As Double 

GetDicke = (K(i).t + K(i + 1).t) / 2 

End Function 

K.5.2 

Berechnung des Knotenabstandes 

Die Funktion berechnet den Abstand zwischen den Knoten i und i+1. 

’ Gestimmt die Länge 

Public Function GetLaenge(i As Integer) As Double 

GetLaenge = Sqr((K(i).y - K(i + 1).y) ^ 2 + (K(i).z - K(i + 1).z) ^ 2) 

End Function 

E. Baeck


K.5.3 

Berechnung der Polygonfläche 

Die Funktion berechnet den Flächeninhalt der durch die Konturknoten aufgespannten Fläche. 

Es wird vorausgesetzt, dass der 1. Konturknoten als n+1 -Knoten in der Knotenliste ergänzt 

wurde. 

’ Gestimmt die Fläche eines Polygons 

Public Function GetFlaeche() As Double 


Dim A As Double 

A = 0 

For i = 1 To UBound(K) - 1 ’ über alle Knoten 

A = A + K(i).y * K(i + 1).z - K(i).z * K(i + 1).y 

Next 

GetFlaeche = A / 2 

End Function 

19.10.2011


Literatur 

[1] H. Rubin, K.-J. Schneider 

Baustatik, Theorie I. und II. Ordnung 

Werner Verlag, 2002 

[2] H. R. Schwarz 

Methode der finiten Elemente 

Teubner Studienbücher Mathematik, B.G. Teubner, Stuttgart 1984 

[3] R. Sedgewick 

Algorithmen in C++ 

(auch für VBA-Programmierung als Vorlage zu empfehlen!) 

Addison-Wesley, 1992 

[4] Peter Fröhlich (Hrsg.) 

Berechnungsbibliothek Bauwesen 

Vieweg & Sohn Verlagsgesellschaft mbH, Braunschweig/Wiesbaden, 1998 

E. Baeck

Bauinformatik Teil 1 - Baustatik-Info-Server

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?