Wikibooks
dewikibooks
https://de.wikibooks.org/wiki/Hauptseite
MediaWiki 1.47.0-wmf.24
first-letter
Medium
Spezial
Diskussion
Benutzer
Benutzer Diskussion
Wikibooks
Wikibooks Diskussion
Datei
Datei Diskussion
MediaWiki
MediaWiki Diskussion
Vorlage
Vorlage Diskussion
Hilfe
Hilfe Diskussion
Kategorie
Kategorie Diskussion
Regal
Regal Diskussion
TimedText
TimedText talk
Modul
Modul Diskussion
Veranstaltung
Veranstaltung Diskussion
Pseudoprimzahlen: Tabelle Absolute eulersche Pseudoprimzahlen
0
12881
1092405
761636
2026-10-23T14:00:55Z
Hardy42
1911
/* Absolute eulersche Pseudoprimzahlen */ Inhalt korrigiert
1092405
wikitext
text/x-wiki
{{Navigation_Buch|Pseudoprimzahlen|Pseudoprimzahlen}}
{{:Pseudoprimzahlen:Vorlage Tabellen}}
== [[Pseudoprimzahlen: Absolute Fermatsche Pseudoprimzahlen#Absolute eulersche Pseudoprimzahlen|Absolute eulersche Pseudoprimzahlen]] ==
1.729 = 7 ∙ 13 ∙ 19
2.465 = 5 ∙ 17 ∙ 29
15.841 = 7 ∙ 31 ∙ 73
41.041 = 7 ∙ 11 ∙ 13 ∙ 41
46.657 = 13 ∙ 37 ∙ 97
75.361 = 11 ∙ 13 ∙ 17 ∙ 31
162.401 = 17 ∙ 41 ∙ 233
172.081 = 7 ∙ 13 ∙ 31 ∙ 61
399.001 = 31 ∙ 61 ∙ 211
449.065 = 5 ∙ 19 ∙ 29 ∙ 163
488.881 = 37 ∙ 73 ∙ 181
530.881 = 13 ∙ 97 ∙ 421
656.601 = 3 ∙ 11 ∙ 101 ∙ 197
670.033 = 7 ∙ 13 ∙ 37 ∙ 199
838.201 = 7 ∙ 13 ∙ 61 ∙ 151
997.633 = 7 ∙ 13 ∙ 19 ∙ 577
[[OEIS:A033181]]
ediaqcbebpcl5l8g4uxvvp053qdq144
Benutzer:Ralf Roletschek
2
58362
1092412
1092311
2026-10-24T11:41:15Z
Ralf Roletschek
9340
1092412
wikitext
text/x-wiki
<table>
<tr>
</td>
<td style="width:550px" valign="top">
;typische Gerichte:
*[[File:Flag of Catalonia.svg|24px]] [https://ca.wikibooks.org/wiki/Llibre_de_cuina/Receptes/Escalivada Llibre de cuina/Receptes/Escalivada]
*[[File:Flag of the Czech Republic.svg|24px]] [https://cs.wikibooks.org/wiki/Wikikucha%C5%99ka/Sma%C5%BEen%C3%BD_s%C3%BDr Wikikuchařka/Smažený sýr]
*[[File:Flag of Spain.svg|24px]] [https://es.wikibooks.org/wiki/Artes_culinarias/Recetas/Gazpacho_andaluz Artes culinarias/Recetas/Gazpacho andaluz]
*[[File:Flag of Finland.svg|24px]] [https://fi.wikibooks.org/wiki/Keittokirja/M%C3%A4mmi Keittokirja/Mämmi]
*[[File:Flag of Ukraine.svg|24px]] [https://uk.wikibooks.org/wiki/%D0%A0%D0%B5%D1%86%D0%B5%D0%BF%D1%82:%D0%91%D0%BE%D1%80%D1%89_%D1%83%D0%BA%D1%80%D0%B0%D1%97%D0%BD%D1%81%D1%8C%D0%BA%D0%B8%D0%B9_%D0%B7_%D0%BF%D0%B0%D0%BC%D0%BF%D1%83%D1%88%D0%BA%D0%B0%D0%BC%D0%B8 Рецепт:Борщ український з пампушками]
*[[File:Flag of Russia.svg|24px]] [https://ru.wikibooks.org/wiki/%D0%A0%D0%B5%D1%86%D0%B5%D0%BF%D1%82:%D0%A3%D0%BA%D1%80%D0%B0%D0%B8%D0%BD%D1%81%D0%BA%D0%B8%D0%B9_%D0%B1%D0%BE%D1%80%D1%89 Рецепт:Украинский борщ]
... und alle kommen ohne führende Leerzeichen im Lemma aus
</td>
</tr>
</table>
anon2meohgr1kz1kemf7xbqeqxjgkud
Internet: Basics: Hausanschluss
0
69609
1092404
552701
2026-10-23T13:43:15Z
Netzikon
116920
1092404
wikitext
text/x-wiki
<noinclude><div class="noprint">{{:Internet/ NAV/ Basics}}</div>
<div style="float:right; margin-left:20px; margin-bottom:20px; font-size:0.9em;"> __TOC__ </div>
<div class="noprint">
Unterkapitel:
{{sub|CIX|CIX}} ·
----
</div></noinclude>
Wenn Sie weder ein eigenes Rechenzentrum besitzen noch ein paar tausend Euro monatlich für die Standleitung, brauchen Sie eine Alternative:
* Einen Provider. So wird ein Dienstleister bezeichnet, der ein Rechenzentrum und eine Standleitung zum Internet hat, um Ihnen den Zugang zum Internet zu ermöglichen.
* Eine Leitung, die vom Provider in Ihr Haus führt.
* An beiden Enden der Leitung einen Umsetzer (ein Modem), einen beim Provider und einen bei Ihnen zu Hause, der die digitalen Internetsignale an die Eigenschaften der Leitung anpasst.
;Die Leitung:
Jedes Haus hat mindestens eine der Anschlussmöglichkeiten: Die Telefonleitung, der Kabelfernseh-Anschluss, die Satellitenantenne und den 230 Volt Stromanschluss. Der technische Aufwand für die Ankopplung des Internets, die Gebühren sowie die Datenübertragungsrate sind recht unterschiedlich.
;Das Modem:
Keine der genannten Leitungen ist imstande, die Einsen und Nullen eines digitalen Signals zu übertragen. Deshalb muss das Digitalsignal in eine analoge Form umgewandelt werden, die über die gewünschte Leitung übertragen werden kann. Diese Umwandlung wird durch ein „Modem“ des Providers vorgenommen. Ein weiteres Modem beim Kunden wandelt das Analogsignal zurück in das ursprüngliche digitale Signal.
Da öffentliche Telefonleitungen heute in fast jeden Winkel der Welt führen, kann man eine Fernverbindung über jede Telefonleitung herstellen. Es kostet meist weniger als einen Cent pro Minute, allerdings erreicht die Übertragungsrate nur bescheidene 0,052 Mbit.
Falls man sich eine teurere '''ISDN'''-Leitung (digitale Telefonleitung) schalten lässt, hat man die Wahl: Entweder man überträgt Daten mit 0,064 Mbit über den einen Kanal und hat den zweiten Kanal für Telefonate frei, oder man benutzt beide Kanäle für Daten. Durch diese „Kanalbündelung“ verdoppelt sich die Bandbreite auf 0,128 Mbit. Der Minutenpreis verdoppelt sich ebenfalls. Telefonisch ist man nicht mehr erreichbar, die Anrufer hören ein Besetztzeichen.
In weiten Teilen Deutschlands ist DSL ('''D'''igital '''S'''ubscriber '''L'''ine) verfügbar: Daten können mit 1, 2, 6, 16 oder neuerdings bis 50 Mbit übertragen werden, bei einem Preis von etwa 20 bis 30 Euro pro Monat. Welche Geschwindigkeit am konkreten Ort verfügbar ist, hängt von der Qualität der Leitung und der Entfernung zum nächsten Verstärker der Telekom ab. Eine Übertragung mit 16 MBit funktioniert maximal bis etwa fünf Kilometer, bei größeren Entfernungen zwischen Telekom und Kunde verringert sich die Datenübertragungsrate. Daher sind höhere Geschwindigkeiten an manchen Standorten nicht erreichbar.
Arcor und andere TK-Anbieter (TK = Tele-Kommunikation) haben in einigen Großstädten begonnen, ein eigenes Leitungsnetz einzugraben, um nicht länger die Leitungen bei der Telekom mieten zu müssen.
Trotzdem gibt es noch immer Gegenden ohne DSL. Die meisten Telefonkabel wurden vor mehreren Jahrzehnten verlegt, als noch niemand an Datenübertragungen dachte. Die Qualität der älteren Kabel reicht oft nicht aus, um neben der Telefonie größere Datenmengen zu übertragen. Andererseits zahlen die meisten Internetnutzer weniger als einen Euro pro Tag für einen DSL-Zugang. Da kommt nicht genug Geld zusammen, um die Straße aufzubaggern und neue Kabel zu verlegen.
In Gegenden ohne DSL gibt es mehrere Möglichkeiten.
* Daten lassen sich „Huckepack“ über Stromleitungen übertragen. Zahlreiche Stadtwerke bieten ihre Starkstromleitungen für Datenübertragungen an. Allerdings ist der Aufwand groß, die Daten am Kundenanschluss vom Hochspannungsnetz zu trennen. Deshalb sind diese Angebote meist auf Firmenkunden beschränkt.
* Kabel Deutschland und andere Kabelnetzbetreiber haben ungenutzte Bandbreite, um außer dem Fernsehbild und Videotext noch zusätzliche Daten übertragen zu können.
* Mit dem Übertragungsverfahren „UMTS“ können Daten über das gut ausgebaute Handy-Netz übertragen werden.
* Mit einer Satellitenschüssel ist der Internetzugang fast überall möglich.
{{clear}}
{{:Internet/ Vorlage/ Links|die Struktur des Internets|
* {{w|Internetdienstanbieter#Bekannte_Anbieter|Internetdienstanbieter im deutschsprachigen Raum}}
}}
<noinclude>
<references />
</noinclude>
qzf5oawqzy211de94sydt15cebdjl5n
Musterentwürfe zum gerichtlichen Mahnverfahren/ Zusatzhinweise zum gerichtlichen Mahnverfahren
0
102119
1092402
1092364
2026-10-23T11:59:38Z
Raimund Barkam
58500
1092402
wikitext
text/x-wiki
Die hier angegebenen Zusatzhinweise beziehen sich auf das gerichtliche Mahnverfahren und wurden den Büchern "BGB = 79. Auflage 2017" und "ZPO = 57. Auflage 2016" / "ZPO = 58. Auflage 2017" entnommen. Ebenso werden hier mit Unterstützung der genannten Bücher, die hier genannten Paragraphen durch Angabe aktueller Paragraphen geändert oder ergänzt und somit den gesetzgeberischen Regelungen angepasst und vervollständigt. Die Nachfolgend aufgeführten Zusatzhinweise wurden den beiden genannten Büchern entnommen und sollen die Paragraphen mit den Angaben lt. Gesetzestexten ergänzen:
:''' Paragraphen und Text lt. Buch ZPO - Zivilprozessordnung'''
ISBN 978-3-423-53106-1 (dtv) / ISBN 978-3-406-77913-8 (C. H. Beck)
::::::<Font Size="5"> '''1 Zivilprozessordnung'''</Font>
::::::In der Fassung der Bekanntmachung vom Dezember2005<sup>1)</sup>
:::::::(BGB1. I S.3202, ber. 2006 I S. 431 und 2007 I S. 1781)
<Font Size="3">                                                                  '''FNA 310-4'''
zuletzt geänd. durch Art. 14 G zur Modernisierung des notariellen Berufsrechts und zur Änd. weiterer<br>
Vorschriften v. 25.6.2021 (BGB1. I S. 2154)
<Font Size="4">                                                           '''Inhaltsübersicht'''
:::::::'''Buch 1. Allgemeine Vorschriften'''
::::::::: Abschnitt 1. Gerichte
:::::: Titel 1. Sachliche Zuständigkeit der Gerichte und Wertvorschriften
§   1        Sachliche Zuständigkeit<br>
§   2        Bedeutung des Wertes<br>
§   3        Wertfestsetzung nach freiem Ermessen<br>
§   4        Wertberechnung Nebenforderungen<br>
§   5        Mehrere Ansprüche<br>
§   6        Besitz; Sicherstellung; Pfandrecht<br>
§   7        Grunddienstbarkeit<br>
§   8        Pacht- oder Mietverhältnis<br>
§   9        Wiederkehrende Nutzungen oder Leistungen<br>
§   10        (weggefallen)<br>
§   11        Bindende Entscheidung über Unzuständigkeit<br>
:::::: Titel 2. Gerichtsstand
§   12        Allgemeiner Gerichtsstand; Begriff<br>
§   13        Allgemeiner Gerichtsstand des Wohnsitzes<br>
§   14        (weggefallen)<br>
§   15        Allgemeiner Gerichtsstand für exterritoriale Deutsche<br>
§   16        Allgemeiner Gerichtsstand wohnungsloser Personen<br>
§   17        Allgemeiner Gerichtsstand juristischer Personen<br>
§   18        Allgemeiner Gerichtsstand des Fiskus<br>
§   19        Mehrere Gerichtsbezirke am Behördensitz<br>
§   19a      Allgemeiner Gerichtsstand des Insolvenzverwalters<br>
§   19b      Ausschließlicher Gerichtsstand bei restrukturierungsbezogenen Klagen;            Verordnungsermächtigung<br>
§   20        Besonderer Gerichtsstand des Aufenthaltsorts<br>
§   21        Besonderer Gerichtsstand der Niederlassung<br>
§   22        Besonderer Gerichtsstand der Mitgliedschaft<br>
§   23        Besonderer Gerichtsstand des Vermögens und des Gegenstands<br>
§   24        Ausschließlicher dringlicher Gerichtsstand<br>
§   25        Dinglicher Gerichtsstand des Sachzusammenhanges<br>
§   26        Dinglicher Gerichtsstand für persönliche Klagen<br>
§   27        Besonderer Gerichtsstand der Erbschaft<br>
§   28        Erweiterter Gerichtsstand der Erbschaft<br>
§   29        Besonderer Gerichtsstand des Erfüllungsorts<br>
§   29a      Ausschließlicher Gerichtsstand bei Miet- und Pachträumen<br>
§   29b      (weggefallen)<br>
§   29c      Besonderer Gerichtsstand für Haustürgeschäfte<br>
§   30        Besonderer Gerichtsstand bei Beförderungen <br>
§   30a      Gerichtsstand bei Bergungsansprüchen<br>
§   31        Besonderer Gerichtsstand der Vermögensverwaltung<br>
§   32        Besonderer Gerichtsstand der unerlaubten Handlung<br>
§   32a      Ausschließlicher Gerichtsstand der Umwelteinwirkung<br>
§   32b      Ausschließlicher Gerichtsstand bei falschen, irreführenden oder unterlassenen öffentlichen Kapitalmarktinformationen<br>
§   32c      Ausschließlicher Gerichtsstand bei Musterfeststellungsverfahren<br>
§   33        Besonderer Gerichtsstand der Widerlege<br>
§   34        Besonderer Gerichtsstand des Hauptprozesses<br>
§   35        Wahl unter mehreren Gerichtsständen<br>
$   36        Gerichtliche Bestimmung der Zuständigkeit<br>
§   37        Verfahren bei gerichtlicher Bestimmung<br>
:::::: Titel 3. Vereinbarung über die Zuständigkeit der Gerichte
§   38        Zugelassene Gerichtsstandsvereinbarung<br>
§   39        Zuständigkeit infolge regenloser Verhandlung<br>
§   40        Unwirksame und unzulässige Gerichtsstandsvereinbarung<br>
:::::: Titel 4. Ausschließung und Ablehnung der Gerichtspersonen
§   41        Ausschluss von der Ausübung des Richteramtes<br>
§   42        Ablehnung eines Richters<br>
§   43        Verlust des Ablehnungsrechts<br>
§   44        Ablehnungsgesuch<br>
§   45        Entscheidung über das Ablehnungsgesuch<br>
§   46        Entscheidung des Rechtsmittel<br>
§   47        Unaufschiebbare Amtshandlungen<br>
§   48        Selbstablehnung: Ablehnung von Amts wegen<br>
§   49        Urkundsbeamte <br>
::::::: Abschnitt 2. Parteien
:::::: Titel 1. Parteifähigkeit; Prozessfähigkeit
§   50        Parteifähigkeit<br>
§   51        Prozessfähigkeit; gesetzliche Vertretung, Prozessführung<br>
§   52        Umfang der Prozessfähigkeit<br>
'''[bis 31.12.2022:]'''<br>
§   53         Prozessunfähigkeit bei Betreuung oder Pflegeschaft<br>
'''[bis 1.1.2023:]'''<br>
<i>§   53        Prozessfähigkeit bei rechtlicher Betreuung</i><br>
§   54        Besondere Ermächtigung zu Prozesshandlungen<br>
§   55        Prozessfähigkeit von Ausländern<br>
§   56        Prüfung von Amts wegen<br>
§   57        Prozesspfleger<br>
§   58        Prozesspfleger bei herrenlosem Grundstück oder Schiff<br>
:::::: Titel 2. Streitgenossenschaft
§   59        Streitgenossenschaft bei Rechtsgemeinschaft oder Identität des Grundes<br>
§   60        Streitgenossenschaft bei Gleichartigkeit der Ansprüche<br>
§   61        Wirkung der Streitgenossenschaft<br>
§   62        Notwendige Streitgenossenschaft<br>
§   63        Prozessbetrieb; Ladungen<br>
:::::: Titel 3. Beteiligung Dritter am Rechtsstreit
§   64        Hauptintervention<br>
§   65        Aussetzung des Hauptprozesses<br>
§   66        Nebenintervention<br>
§   67        Rechtsstellung des Nebenintervenienten<br>
§   68        Wirkung der Nebenintervention<br>
§   69        Streitgenössische Nebenintervention<br>
§   70        Beitritt des Nebenintervenienten<br>
§   71        Zwischenstreit über Nebenintervention<br>
§   72        Zulässigkeit der Streitverkündung<br>
§   73        Form der Streitverkündung<br>
§   74        Wirkung der Streitverkündung<br>
§   75        Gläubigerstreit<br>
§   76        Urheberbenennung bei Besitz<br>
§   77        Urheberbenennung bei Eigentumsbeeinträchtigung<br>
:::::: Titel 4. Prozessbevollmächtigte und Beistände
§   78        Anwaltsprozess<br>
§   78a     (weggefallen)<br>
§   78b     Notanwalt<br>
§   78c     Auswahl des Rechtsanwalts<br>
§   79        Parteiprozess<br>
§   80        Prozessvollmacht<br>
§   81        Umfang der Prozessvollmacht<br>
§   82        Geltung für Nebenverfahren<br>
§   83        Beschränkung der Prozessvollmacht<br>
§   84        Mehrere Prozessbevollmächtigte<br>
§   85        Wirkung der Prozessvollmacht<br>
§   86        Fortbestand der Prozessvollmacht<br>
§   87        Erlöschen der vollmacht<br>
§   88        Mangel der Vollmacht<br>
§   89        vollmachtloser Vertreter<br>
§   90        Beistand<br>
:::::: Titel 5. Prozesskosten
§   91        Grundsatz und Umsatz der Kostenpflicht<br>
§   91a     Kosten bei Erledigung der Hauptsache<br>
§   92        Kosten bei teilweisen Obsiegen<br>
§   93        Kosten bei sofortigem Anerkenntnis<br>
§   93a     (weggefallen)<br>
§   93b     Kosten bei Räumungsklagen<br>
§   94        Kosten bei übergegangenem Anspruch<br>
§   95        Kosten bei Säumnis oder Verschulden<br>
§   96        Kosten erfolgloser Angriffs- oder Verteidigungsmittel<br>
§   97        Rechtsmittelkosten<br>
§   98        Vergleichskosten<br>
§   99        Anfechtung von Kostenentscheidungen<br>
§ 100        Kosten bei Streitgenossen<br>
§ 101        Kosten einer Nebenintervention<br>
§ 102       (weggefallen)<br>
§ 103        Kostenfestsetzungsgrundlage; Kostenfestsetzungsantrag<br>
§ 104        Kostenfestsetzungsverfahren<br>
§ 105        Vereinfachter Kostenfestsetzungsbeschluss<br>
§ 106        Verteilung nach Quoten<br>
§ 107        Änderung nach Streitwertfestsetzung<br>
:::::: Titel 6. Sicherheitsleistung
§ 108        Art und Höhe der Sicherheit<br>
§ 109        Rückgabe der Sicherheit<br>
§ 110        Prozesskostensicherheit<br>
§ 111        Nachhaltige Prozesskostensicherheit<br>
§ 112        Höhe der Prozesskostensicherheit<br>
§ 113        Fristbestimmung für Prozesskostensicherheit<br>
:::::: Titel 7. Prozesskostenhilfe
§ 114        Voraussetzungen<br>
§ 115        Einsatz von Einkommen und Vermögen<br>
§ 116        Partei kraft Amtes; juristische Person; parteifähige Vereinigung<br>
§ 117        Antrag<br>
§ 118        Bewilligungsverfahren<br>
§ 119        Bewilligung<br>
§ 120        Festsetzung von Zahlungen<br>
§ 120a     Änderung der Bewilligung<br>
§ 121        Beiordnung eines Rechtsanwalts<br>
§ 122        Wirkung der Prozesskostenhilfe<br>
§ 123        Kostenerstattung<br>
§ 124        Aufhebung der Bewilligung<br>
§ 125        Einbeziehung der Kosten<br>
§ 126        Beitreibung der Rechtsanwaltskosten<br>
§ 127        Entscheidungen<br>
::::::: Abschnitt 3. Verfahren
:::::: Titel 1. Mündliche Verhandlung
§ 128        Grundsatz der Mündlichkeit; schriftliches Verfahren<br>
§ 128a      Verhandlung im Wege der Bild- und Tonübertragung<br>
§ 129        Vorbereitende Schriftsätze<br>
§ 129a     Anträge und Erklärungen zu Protokoll<br>
§ 130        Inhalt der Schriftsätze<br>
§ 130a      Elektronisches Dokument<br>
§ 130b      Gerichtliches elektronisches Instrument<br>
§ 130c      Formulare: Verordnungsermächtigung<br>
'''''[ab 1.1.2022:]'''''<br>
§ 130d      ''Nutzungspflicht für Rechtsanwälte und Behörden''<br>
§ 131        Beifügung von Urkunden<br>
§ 132        Fristen für Schriftsätze<br>
§ 133        Abschriften<br>
§ 134        Einsicht von Urkunden<br>
§ 135        Mitteilung von Urkunden unter Rechtsanwälten<br>
§ 136        Prozessleistung durch Vorsitzenden<br>
§ 137        Gang der mündlichen Verhandlung<br>
§ 138        Erklärungspflicht über Tatsachen; Wahrheitspflicht<br>
§ 139        Materielle Prozessleistung<br>
§ 140        Beanstandung von Prozessleistung oder Fragen<br>
§ 141        Anordnung des persönlichen Erscheinens<br>
§ 142        Anordnung der Urkundenvorlegung<br>
§ 143        Anordnung der Aktenübermittlung<br>
§ 144        Augenschein; Sachverständige<br>
§ 145        Prozesstrennung<br>
§ 146        Beschränkung auf einzelne Angriffs- und Verteidigungsmittel<br>
§ 147        Prozessverbindung<br>
§ 148        Aussetzung bei Vortrefflichkeit<br>
§ 149        Aussetzung bei Verdacht einer Straftat<br>
§ 150        Aufhebung von Trennung, Verbindung oder Aussetzung<br>
§ 151        (weggefallen)<br>
§ 152        Aussetzung bei Eheaufhebungsantrag<br>
§ 153        Aussetzung bei Vaterschaftsanfechtungsklage<br>
§ 154        Aussetzung bei Ehe- oder Kindschaftsstreit<br>
§ 155        Aufhebung der Aussetzung bei Verzögerung<br>
§ 156        Wiedereröffnung der Verhandlung<br>
§ 157        Untervertretung in der Verhandlung<br>
§ 158        Entfernung infolge Prozessleitungsanordnung<br>
§ 159        Protokollaufnahme<br>
§ 160        Inhalt des Protokolls<br>
§ 160a      Vorläufige Protokollaufzeichnung<br>
§ 161        Entbehrliche Feststellungen<br>
§ 162        Genehmigung des Protokolls<br>
§ 163        Wiedereröffnung der Verhandlung<br>
§ 164        Protokollberechtigung<br>
§ 165        Beweiskraft des Protokolls<br>
:::::::::Titel 2. Verfahren bei Zustellungen
:::::::Untertitel 1. Zustellungen von Amts wegen
§ 166        Zustellung<br>
§ 167        Rückwirkung der Zustellung<br>
§ 168        Aufgaben der Geschäftsstelle<br>
§ 169        Bescheinigung des Zeitpunktes der Zustellung; Beglaubigung<br>
§ 170        Zustellung an Vertreter<br>
'''''[ab 1.1.2023:]'''''<br>
§ 170a      ''Zustellung bei rechtlicher Betreuung''<br>
§ 171        Zustellung an Bevollmächtigte<br>
§ 172        Zustellung an Prozessbevollmächtigte<br>
§ 173        Zustellung durch Aushändigung an der Amtsstelle<br>
§ 174        Zustellung gegen Empfangsbekenntnis oder automatisierte Eingangsbestätigung<br>
§ 175        Zustellung durch Einschreiben mit Rückschein<br>
§ 176        Zustellungsauftrag<br>
§ 177        Ort der Zustellung<br>
§ 178        Ersatzzustellung in der Wohnung, in Geschäftsräumen oder Einrichtungen<br>
§ 179        Zustellung bei verweigerter Annahme<br>
§ 180        Ersatzzustellung durch Einlegen in den Briefkasten<br>
§ 181        Ersatzzustellung durch Niederlegung<br>
§ 182        Zustellungsurkunde<br>
§ 183        Zustellung im Ausland<br>
§ 184        Zustellungsbevollmächtigter: Zustellung durch Aufgabe zur Post<br>
§ 185        Öffentliche Zustellung<br>
§ 186        Bewilligung und Ausführung der öffentlichen Zustellung<br>
§ 187        Veröffentlichung der Benachrichtigung<br>
§ 188        Zeitpunkt der öffentlichen Zustellung<br>
§ 189        Heilung von Zustellungsmängeln<br>
§ 190        Einheitliche Zustellungsformulare<br>
:::::::Untertitel 2. Zustellungen auf Betreiben der Parteien
§ 191        Zustellung<br>
§ 192        Zustellung durch Gerichtsvollzieher<br>
§ 193        Ausführung der Zustellung<br>
§ 194        Zustellungsauftrag<br>
§ 195        Zustellung von Anwalt zu Anwalt<br>
§§ 195a-213a      weggefallen<br>
:::::::::Titel 3. Ladungen, Termine und Fristen
§ 214        Ladung zum Termin<br>
§ 215        Notwendiger Inhalt der Ladung zur mündlichen Verhandlung<br>
§ 216        Terminbestimmung<br>
§ 217        Ladungsfrist<br>
§ 218        Entbehrlichkeit der Ladung<br>
§ 219        Terminsort<br>
§ 220        Aufruf der Sache; versäumter Termin<br>
§ 221        Fristbeginn<br>
§ 222        Fristberechnung<br>
§ 223        (weggefallen)<br>
§ 224        Fristkürzung: Fristverlängerung<br>
§ 225        Verfahren bei Friständerung<br>
§ 226        Abkürzung von Zwischenfristen<br>
§ 227        Terminsänderung<br>
§ 228        (weggefallen)<br>
§ 229        Terminsänderung<br>
:::::::::Titel 4. Folgen der Versäumnis Rechtsbehelfsbelehrung: Wiedereinsetzung in den vorigen Stand
§ 230        Allgemeine Versäumungserfolge<br>
§ 231        Keine Androhung: Nachholung der Prozesshandlung<br>
§ 232        Behelfsbelehrung<br>
§ 233        Terminsänderung<br>
§ 234        Wiedereinsetzungsfrist<br>
§ 235        (weggefallen)<br>
§ 236        Wiedereinsetzungsantrag<br>
§ 237        Zuständigkeit für Wiedereinsetzung<br>
§ 238        Wiedereinsetzungsantrag<br>
:::::::::Titel 5. Unterbrechung und Aussetzung des Verfahrens
§ 239        Unterbrechung durch Tod der Partei<br>
§ 240        Unterbrechung durch Insolvenzverfahren<br>
§ 241        Unterbrechung durch Prozessunfähigkeit<br>
§ 242        Unterbrechung durch Nachfolge<br>
§ 243        Aufnahme bei Nachlasspflegschaft und Testamentsvollstreckung<br>
§ 244        Unterbrechung durch Anwaltsverlust<br>
§ 245        Unterbrechung durch Stillstand der Rechtspflege<br>
§ 246        Aussetzung bei Vertretung durch Prozessbevollmächtigten<br>
§ 247        Aussetzung bei abgeschnittenen Verkehr<br>
§ 248        Verfahren bei Aussetzung<br>
§ 249        Wirkung von Unterbrechung und Aussetzung<br>
§ 250        Form von Aufnahme und Anzeige<br>
§ 251        Ruhen des Verfahrens<br>
§ 251a      Säumnis beider Parteien; Entscheidung nach Lage der Akten<br>
§ 252        Rechtsmittel bei Aussetzung<br>
:::::::'''Buch 2. Verfahren im ersten Rechtszug'''
::::::::: Abschnitt 1. Verfahren vor den Landgerichten
:::::::::Titel 1. Verfahren bis zum Urteil
§ 253        Klageschrift<br>
§ 254        Stufenklage<br>
§ 255        Fristbestimmung im Urteil<br>
§ 256        Feststellungsklage<br>
§ 257        Klage auf künftige Zahlung oder Räumung<br>
§ 258        Klage auf wiederkehrende Leistungen<br>
§ 259        Klage wegen Besorgnis nicht rechtzeitigen Leistung<br>
§ 260        Anspruchshäufung<br>
§ 261        Rechtshängigkeit<br>
§ 262        Sonstige Wirkungen der Rechtshängigkeit<br>
§ 263        Klageänderung<br>
§ 264        Keine Klageänderung<br>
§ 265        Veräußerung oder Abtretung der Streitsache<br>
§ 266        Veräußerung eines Grundstücks<br>
§ 267        Vermutete Einwilligung in die Klageänderung<br>
§ 268        Unanfechtbarkeit der Entscheidung<br>
§ 269        Klagerücknahme<br>
§ 270        Zustellung; formlose Mitteilung<br>
§ 271        Zustellung der Klageschrift<br>
§ 272        Bestimmung der Verfahrensweise<br>
§ 273        Vorbereitung des Termins<br>
§ 274        Ladung der Parteien; Einlassungsfrist<br>
§ 275        Früher erster Termin<br>
§ 276        Schriftliches Vorverfahren<br>
§ 277        Klageerwiderung: Replik<br>
§ 278        Gütliche Streitbeilegung, Güterverhandlung, Vergleich<br>
§ 278a      Mediation, außergerichtliche Konfliktbeilegung<br>
§ 279        Mündliche Verhandlung<br>
§ 280        Abgesonderte Verhandlung über Zuverlässigkeit der Klage<br>
§ 281        Verweisung bei Unzuständigkeit<br>
§ 282        Rechtzeitigkeit des Vorbringen<br>
§ 283        Schriftsatzfrist für Erklärungen zur Vorbringen des Gegners<br>
§ 283a      Sicherungsanordnung<br>
§ 284        Schriftsatzfrist für Erklärungen zum Vorbringen des Gegners<br>
§ 285        Verhandlung nach Beweisaufnahme<br>
§ 286        Freie Beweiswürdigung<br>
§ 287        Schadensermittlung; Höhe der Forderung<br>
§ 288        Gerichtliches Geständnis<br>
§ 289        Zusätze beim Geständnis<br>
§ 290        Widerruf des Geständnisses<br>
§ 291        Offenkundige Tatsachen<br>
§ 292        Gesetzliche Vermutungen<br>
§ 292a      (weggefallen)<br>
§ 293        Fremdes Recht; Gewohnheitsrecht; Statuten<br>
§ 294        Glaubhaftmachung<br>
§ 295        Verfahrensrügen<br>
§ 296        Zurückweisung verspäteten Vorbringens<br>
§ 296a      Vorbringen nach Schluss der mündlichen Verhandlung<br>
§ 297        Form der Antragstellung<br>
§ 298        Aktenausdruck<br>
§ 298a      Elektronische Akte; Verordnungsermächtigung<br>
§ 299        Akteneinsicht; Abschriften<br>
§ 299a      Datenträgerarchiv<br>
:::::::::Titel 2. Urteil
§ 300        Endurteil<br>
§ 301        Teilurteil<br>
§ 302        Vorbehaltsurteil<br>
§ 303        Zwischenurteil<br>
§ 304        Zwischenurteil über den Grund<br>
§ 305        Urteil unter Vorbehalt erbrechtlich beschränkter Haftung<br>
§ 305a      Urteil unter Vorbehalt seerechtlich beschränkter Haftung<br>
§ 306        Verzicht<br>
§ 307        Anerkenntnis<br>
§ 308        Bindung an die Parteianträge<br>
§ 309        Erkennende Richter<br>
§ 310        Termin der Urteilsverkündung<br>
§ 311        Form der Urteilsverkündung<br>
§ 312        Anwesenheit der Parteien<br>
§ 313        Form und Inhalt des Urteils<br>
§ 313a      Weglassen von Tatbestand und Entscheidungsgründen<br>
§ 313b      Versäumnis-, Anerkenntnis- und Verzichtsurteil<br>
§ 314        Beweiskraft des Tatbestandes<br>
§ 315        Unterschrift des Richters<br>
§ 316        (weggefallen)<br>
§ 317        Urteilszustellung und -ausfertigung<br>
§ 318        Bindung des Gerichts<br>
§ 319        Berichtigung des Urteils<br>
§ 320        Berichtigung des Tatbestands<br>
§ 321        Ergänzung des Urteils<br>
§ 321a      Abhilfe bei Verletzung des Anspruchs auf rechtliches Gehör<br>
§ 322        Materielle Rechtskraft<br>
§ 323        Abänderung von Urteilen<br>
§ 323a      Abänderung von Vergleichen und Urkunden<br>
§ 323b      Verschärfte Haftung<br>
§ 324        Nachforderungsklage zur Sicherheitsleistung<br>
§ 325        Subjektive Rechtskraftwirkung<br>
§ 325a      Feststellungswirkung des Musterentscheids<br>
§ 326        Rechtskraft bei Nacherbfolge<br>
§ 327        Rechtskraft bei Testamentsvollstreckung<br>
§ 328        Anerkennung ausländischer Urteile-<br>
§ 329        Beschlüsse und Verfügungen<br>
:::::::::Titel 3. Versäumnisurteil
§ 330        Versäumnisurteil gegen den Kläger<br>
§ 331        Versäumnisurteil gegen den Beklagten<br>
§ 331a      Entscheidung nach Aktenlage<br>
§ 332        Begriff des Verhandlungstermins<br>
§ 333        Nichtverhandeln der erscheinenden Partei<br>
§ 334        Unvollständiges Verhandeln<br>
§ 335        Unzulässigkeit einer Versäumniserscheinung<br>
§ 336        Rechtsmittel bei Zurückweisung<br>
§ 337        Vertagung von Amts wegen<br>
§ 338        Einspruch<br>
§ 339        Einspruchsfrist<br>
§ 340        Einspruchsschrift<br>
§ 340a      Zustellung der Einspruchsschrift<br>
§ 341        Einspruchsprüfungbr>
§ 341a      Einspruchstermin<br>
§ 342        Wirkungen des zulässigen Einspruchs<br>
§ 343        Entscheidung nach Einspruch<br>
§ 344        Versäumniskosten<br>
§ 345        Zweites Versäumnisurteil<br>
§ 346        Verzicht und Zurücknahme des Einspruchs<br>
§ 347        Verfahren bei Widerklage und Zwischenstreit<br>
:::::::::Titel 4. Verfahren vor dem Einzelrichter
§ 348        Originärer Einzelrichter<br>
§ 348a      Obligatorischer Einzelrichter<br>
§ 349        Vorsitzender der Kammer für Handelssachen<br>
§ 350        Rechtsmittel<br>
§ 351-354 (weggefallen)<br>
:::::::::Titel 5. Allgemeine Vorschriften über die Beweisaufnahme
§ 355        Unmittelbarkeit der Beweisaufnahme<br>
§ 356        Beibringungsfrist<br>
§ 357        Parteiöffentlichkeit<br>
§ 357a      (weggefallen)<br>
§ 358        Notwendigkeit eines Beweisschlusses<br>
§ 358a      Beschwerdeschluss und Beweisaufnahme vor mündlicher Verhandlung<br>
§ 359        Inhalt des Beweisschlussses<br>
§ 360        Änderung des Beweisschlusses<br>
§ 361        Beweisaufnahme durch beauftragten Richter<br>
§ 362        Beweisaufnahme durch ersuchten Richter<br>
§ 363        Beweisaufnahme im Ausland<br>
§ 364        Parteimitwirkung bei Beweisaufnahme im Ausland<br>
§ 365        Abgabe durch beauftragten oder ersuchten Richter<br>
§ 366        Zwischenstreit<br>
§ 367        Ausbleiben der Partei<br>
§ 368        Neuer Beweistermin<br>
§ 369        Ausländische Beweisaufnahme<br>
§ 370        Fortsetzung der mündlichen Verhandlung<br>
:::::::::Titel 6. Beweis durch Augenschein
§ 371        Beweis durch Augenschein<br>
§ 371a      Beweiskraft elektronischer Dokumente<br>
§ 371b      Beweiskraft gescannter öffentlicher Urkunden<br>
§ 372        Beweisaufnahme
§ 372a      Untersuchungen zur Feststellung der Abstammung<br>
:::::::::Titel 7. Zeugenbeweis
§ 373        Beweisantritt<br>
§ 374        (weggefallen)<br>
§ 375        Beweisaufnahme durch beauftragten oder ersuchten Richter<br>
§ 376        Vernehmung bei Amtsverschwiegenheit<br>
§ 377        Zeugenladung<br>
§ 378        Aussageerleichternde Unterlagen<br>
§ 379        Auslagenvorschuss<br>
§ 380        Folgen des Ausbleiben des Zeugen<br>
§ 381        Genügende Entschuldigung des Ausbleibens<br>
§ 382        Vernehmung an bestimmten Orten<br>
§ 383        Zeugnisverweigerung aus persönlichen Gründen<br>
§ 384        Zeugnisverweigerung aus sachlichen Gründen<br>
§ 385        Ausnahmen vom Zeugnisverweigerungsrecht<br>
§ 386        Erklärung der Zeugnisverweigerung<br>
§ 387        Zwischenstreit über Zeugnisverweigerung<br>
§ 388        Zwischenstreit über schriftliche Zeugnisverweigerung<br>
§ 389        Zeugnisverweigerung vor beauftragtem oder ersuchtem Richer<br>
§ 390        Folgen der Zeugnisverweigerung<br>
§ 391        Zeugenbeeidigung<br>
§ 392        Nacheid; Eidesnorm<br>
§ 393        Uneidliche Wahrnehmung<br>
§ 394        Einzelvernehmung<br>
§ 395        Wahrheitsermahnung, Vernehmung zur Person<br>
§ 396        Vernehmung zur Sache<br>
§ 397        Fragerecht der Parteien<br>
§ 398        Wiederholte und nachträgliche Vernehmung<br>
§ 399        Verzicht auf Zeugen<br>
§ 400        Befugnisse des mit der Beweisaufnahme betrauten Richters<br>
§ 401        Zeugenentschädigung<br>
:::::: Titel 8. Beweis durch Sachverständige
§ 402        Anwendbarkeit der Vorschriften für Zeugen<br>
§ 403        Beweisantritt<br>
§ 404        Sachverständigenauswahl<br>
§ 404a      Vorläufige Leitung der Tätigkeit des Sachverständigen<br>
§ 405        Auswahl durch den mit der Beweisaufnahme betrauten Richter<br>
§ 406        Ablehnung eines Sachverständigen<br>
§ 407        Pflicht zur Erstattung des Gutachtens<br>
§ 407a      Weitere Pflichten des Sachverständigen<br>
§ 408        Gutachtenverweigerungsrecht<br>
§ 409        Folgen des Ausbleibens oder der Gutachterverweigerung<br>
§ 410        Sachverständigenbeeidigung<br>
§ 411        Schriftliches Gutachten<br>
§ 411a      Verwertung von Sachverständigengutachten aus anderen Verfahren<br>
§ 412        Neues Gutachten<br>
§ 413        Sachverständigenvergütung<br>
§ 414        Sachverständige Zeugen<br>
:::::: Titel 9. Beweis durch Urkunden
§ 415        Beweiskraft öffentliche Urkunden über Erklärungen<br>
§ 416        Beweiskraft von Privaturkunden<br>
§ 417        Beweiskraft öffentlicher Urkunden über amtliche Anordnung, Verfügung oder Entscheidung<br>
§ 418        Beweiskraft öffentlicher Urkunden mit anderem Inhalt<br>
§ 419        Beweiskraft mangelbehafteter Urkunden<br>
§ 420        Vorlegung durch Beweisführer; Beweisantritt<br>
§ 421        Vorlegung durch den Gegner; Beweisantritt<br>
§ 422        Vorlegungspflicht des Gegners nach bürgerlichem Recht<br>
§ 423        Vorlegungspflicht des Gegners bei Bezugnahme<br>
§ 424        Antrag bei Vorlegung durch<br>
§ 425        Anordnung durch Vorlegung durch Gegner<br>
§ 426        Vernehmung des Gegners über den Verbleib<br>
§ 427        Folgen der Nichtvorlegung durch Gegner<br>
§ 428        Vorlegung durch Dritte; Beweisantriss<br>
§ 429        Vorlegungspflicht Dritter
§ 430        Antrag bei Vorlegung durch Dritte<br>
§ 431        Vorlegungsfrist bei Vorlegung durch Dritte<br>
§ 432        Vorlegung durch Behörden oder Beamte: Beweisantritt<br>
§ 433        (weggefallen)<br>
§ 434        Vorlegung vor beauftragtem oder ersuchtem Richter<br>
§ 435        Vorlegung öffentlicher Urkunden in Urschrift oder beglaubigter Abschrift<br>
§ 436        Verzicht nach Vorlegung<br>
§ 437        Echtheit inländischer öffentlicher Urkunden<br>
§ 438        Echtheit ausländischer öffentlicher Urkunden<br>
§ 439        Erklärung über Echtheit von Pribaturkunden<br>
§ 440        Beweis der Echtheit von Pribaturkunden<br>
§ 441        Schriftvergleichung<br>
§ 442        Würdigung der Schriftvergleichung<br>
§ 443        Verwahrung verdächtiger Urkunden<br>
§ 444        Folgen der Bereitung einer Urkunde<br>
:::::: Titel 10. Beweis durch Urkunden
§ 445        Vernehmung des Gegners: Beweisantritt<br>
§ 446        Weigerung des Gegners<br>
§ 447        Vernehmung der Beweispflichtigen Partei auf Antrag<br>
§ 448        Vernehmung von Amts wegen<br>
§ 449        Vernehmung von Streitgenossen<br>
§ 450        Besweisschluss<br>
§ 451        Ausführung der Vernehmung<br>
§ 452        Beeidigung der Partei<br>
§ 453        Beweiswürdigung bei Parteivernehmung <br>
§ 454        Ausbleiben der Partei <br>
§ 455        Prozessunfähige <br>
§§ 456-477 (weggefallen) <br>
:::::: Titel 11. Abnahme von Eiden und Bekräftigungen
§ 478        Eidesleistung in Person <br>
§ 479        Eidesleistung vor beauftragtem oder ersuchtem Richter <br>
§ 480        Eidesbelehrung <br>
§ 481        Eidesleistung: Eidesformel <br>
§ 482        (weggefallen) <br>
§ 483        Eidesleistung sprach- oder hörbehinderter Personen <br>
§ 484        Eidesgleiche Bekräftigung <br>
:::::: Titel 12. Selbständiges Beweisverfahren
§ 485        Zulässigkeit <br>
§ 486        Zuständiges Gericht <br>
§ 487        Inhalt des Antrages <br>
§§ 488,489 (weggefallen) <br>
§ 490        Entscheidung über den Antrag <br>
§ 491        Ladung des Gegners <br>
§ 492        Beweisaufnahme <br>
§ 493        Benutzung im Prozess <br>
§ 494        Unbekannter Gegner <br>
§ 494a      Frist zur Klageerhebung<br>
::::::::: Abschnitt 2. Verfahren vor den Amtsgerichten
§ 495        Anzuwendende Vorschriften <br>
§ 496        Einrichtung von Schriftsätzen; Erklärungen zu Protokoll <br>
§ 497        Ladungen <br>
§ 498        Zustellung des Protokolls über die Klage <br>
§ 499        Belehrungen <br>
§§ 499a-503 (weggefallen) <br>
§ 504        Hinweis bei Unzuständigkeit des Amtsgerichts <br>
§ 505        (weggefallen) <br>
§ 506        Nachträgliche sachliche Unzuständigkeit <br>
§§ 507-509 (weggefallen) <br>
§ 510        Erklärung über Urkunden <br>
§ 510a      Inhalt des Protokolls <br>
§ 510b      Urteil und Vornahme einer Handlung <br>
§ 510c      (weggefallen) <br>
:::::::'''Buch 3. Rechtsmittel'''
:::::::Abschnitt 1. Berufung
§ 511        Standhaftigkeit der Berufung <br>
§ 512        Vorentscheidungen im ersten Rechtszug <br>
§ 513        Berufungsgründe <br>
§ 514        Versäumnisurteile <br>
§ 515        Verzicht auf Berufung <br>
§ 516        Zurücknahme der Berufung <br>
§ 517        Berufungsfrist <br>
§ 518        Berufungsfrist bei Urteilsergänzung <br>
§ 519        Berufungsschrift <br>
§ 520        Berufungsbegründung <br>
§ 521        Zustellung der Berufungsschrift und -begründung <br>
§ 522        Zulässigkeitsprüfung; Zurückweisungsbeschluss <br>
§ 523        Terminsbestimmung <br>
§ 524        Anschlussberufung <br>
§ 525        Allgemeine Verfahrensgrundsätze <br>
§ 526        Entscheidender Richter <br>
§ 527        Vorbereitender Einzelrichter <br>
§ 528        Bindung an die Berufungsanträge <br>
§ 529        Prüfungsumfang des Berufungsgerichts <br>
§ 530        Verspätet vorgebrachte Angriffs- und Verteidigungsmittel <br>
§ 531        Zurückgewiesene und neue Angriffs- und Verteidigungsmittel <br>
§ 532        Rügen der Unzulässigkeit der Klage <br>
§ 533        Klageänderung ; Aufrechtserklärung; Widerlege <br>
§ 534        Verlust des Rügerechts <br>
§ 535        Gerichtliches Geständnis <br>
§ 536        Parteivernehmung <br>
§ 537        Vorläufige Vollstreckbarkeit <br>
§ 538        Zurückweisung <br>
§ 539        Versäumnisverfahren <br>
§ 540        Inhalt des Berufungsurteils <br>
§ 541        Prozessakten <br>
:::::::Abschnitt 2. Revision
§ 542        Standhaftigkeit der Revision <br>
§ 543        Zulassungsrevision <br>
§ 544        Nichtzulassungsbeschwerde <br>
§ 545        Revisionsgründe <br>
§ 546        Begriff der Rechtsverletzung <br>
§ 547        Absolute Revisionsgründe <br>
§ 548        Revisionsfrist <br>
§ 549        Revisionseinlegung <br>
§ 550        Zustellung der Revisionsschrift <br>
§ 551        Revisionsbegründung <br>
§ 552        Zulässigkeitsprüfung <br>
§ 552a      Zurückweisungsbeschluß <br>
§ 553        Terminbestimmung: Einlassungsfrist <br>
§ 554        Anschlußrevision <br>
§ 555        Allgemeine Verfahrensgrundsätze <br>
§ 556        Verlust des Rügerechts <br>
§ 557        Umfang der Revisionsprüfung <br>
§ 558        Vorläufige Vollstreckbarkeit <br>
§ 559        Beschränkte Nachprüfung tatsächlicher Feststellungen <br>
§ 560        Nicht reversible Gesetze <br>
§ 561        Revisionszurückweisung <br>
§ 562        Aufhebung des angefochtenen Urteils <br>
§ 563        Zurückverweisung; eigene Sachentscheidung<br>
§ 564        Keine Begründung der Entscheidung bei Rügen von Verfahrensmängeln <br>
§ 565        Anzuwendende Vorschriften des Berufungsverfahrens <br>
§ 566        Sprungrevision <br>
::::::::: Abschnitt 3. Beschwerde
:::::::: Titel 1. Sofortige Beschwerde
§ 567        Sofortige Beschwerde; Anschlussbeschwerde <br>
§ 568        Originärer Einzelrichter <br>
§ 569        Frist und Form <br>
§ 570        Aufschiebende Wirkung; einstweilige Anordnungen <br>
§ 571        Begründung, Präklusion, Ausnahmen vom Anwaltszwang <br>
§ 572        Gang des Beschwerdeverfahrens <br>
§ 573        Erinnerung <br>
:::::::: Titel 2. Rechtsbeschwerde
§ 574        Rechtsbeschwerde; Anschlussbeschwerde <br>
§ 575        Frist, Form und Begründung der Rechtsbeschwerde <br>
§ 576        Gründe der Rechtsbeschwerde <br>
§ 577        Prüfung und Entscheidung der Rechtsbeschwerde <br>
:::::::'''Buch 4. Wiederaufnahme des Verfahrens'''
§ 578        Arten der Wiederaufnahme <br>
§ 579        Nichtigkeitsklage <br>
§ 580        Restitutionsklage <br>
§ 581        Besondere Voraussetzungen der Restitutionsklage <br>
§ 582        Hilfsnatur der Restitutionsklage <br>
§ 583        Vorentscheidungen <br>
§ 584        Ausschließliche Zuständigkeit für Nichtigkeit- und Restitutionsklagen <br>
§ 585        Allgemeine Verfahrensgrundsätze <br>
§ 586        Klagefrist <br>
§ 587        Klageschrift <br>
§ 588        Inhalt der Klageschrift <br>
§ 589        Zulässigkeitsprüfung <br>
§ 590        Neue Verhandlung <br>
§ 591        Rechtsmittel <br>
:::::::'''Buch 5. Urkunden und Wechselprozess'''
§ 592        Zulässigkeit <br>
§ 593        Klageinhalt; Urkunden <br>
§ 594        (weggefallen) <br>
§ 595        Keine Widerklage; Beweismittel <br>
§ 596        Abstehen vom Urkundenprozess <br>
§ 597        Klageabweisung <br>
§ 598        Zurückweisung von Einwendungen <br>
§ 599        Vorbehaltsurteil <br>
§ 600        Nachverfahren <br>
§ 601        (weggefallen) <br>
§ 602        Wechselprozess <br>
§ 603        Gerichtsstand <br>
§ 604        Klageinhalt; Ladungsfrist <br>
§ 605        Beweisvorschriften <br>
§ 605a      Scheckprozess <br>
:::::::'''Buch 6. Musterfeststellungsverfahren'''
§ 606        Musterfeststellungsklage <br>
§ 607        Bekanntmachung der Musterfeststellungsklage <br>
§ 608        Anmeldung von Ansprüchen oder Rechtsverhältnissen <br>
§ 609        Klageregister; Verordnungsermächtigung <br>
§ 610        Besonderheiten der Musterfeststellungsklage <br>
§ 611        Vergleich <br>
§ 612        Bekanntmachungen zum Musterfeststellungsurteil <br>
§ 613        Bindungswirkung des Musterfeststellungsurteils; Aussetzung <br>
§ 614        Rechtsmittel <br>
§§ 615-687 (weggefallen) <br>
:::::::'''Buch 7. Mahnverfahren'''
§ 688        Zulässigkeit <br>
§ 689        Zuständigkeit; maschinelle Bearbeitung <br>
§ 690        Mahnantrag <br>
§ 691        Zurückweisung des Mahnantrags <br>
§ 692        Mahnbescheid <br>
§ 693        Zurückstellung des Mahnbescheids <br>
§ 694        Widerspruch gegen den Mahnbescheid <br>
§ 695        Mitteilung des Widerspruchs; Abschriften <br>
§ 696        Verfahren nach Widerspruch <br>
§ 697        Einleitung des Streitverfahrens <br>
§ 698        Abgabe des Vefahrens am selben Gericht <br>
§ 699        Vollstreckungsbescheid <br>
§ 700        Einspruch gegen den Vollstreckungsbescheid <br>
§ 701        Wegfall der Wirkung des Mahnbescheids <br>
§ 702        Form von Anträgen und Erkläriungen <br>
§ 703        Kein Nachweis der Vollmacht <br>
§ 703a      Urkunden Wechsel- und Scheckverfahren <br>
§ 703b      Sonderregelungen für maschinelle Bearbeitung <br>
§ 703c      Formulare; Einführung der maschinellen Bearbeitung <br>
§ 703d      Formulare; Antragsgegner ohne allgemeinen inländischen Gerichtsstand <br>
:::::::'''Buch 8. Zwangsvollstreckung'''
::::::::: Abschnitt 1. Allgemeine Vorschriften
§ 704        Vollstreckbare Endurteile <br>
§ 705        Formelle Rechtskraft <br>
§ 706        Rechtskraft- und Notfristzeugnis <br>
§ 707        Einstweilige Einstellung der Zwangsvollstreckung <br>
§ 708        Vorläufige Vollstreckbarkeit ohne Sicherheitsleistung <br>
§ 709        Vorläufige Vollstreckbarkeit gegen Sicherheitsleistung <br>
§ 710        Ausnahmen von der Sicherheitsleistung des Gläubigers <br>
§ 711        Abwendungsbefugnis <br>
§ 712        Schutzantrag des Schuldners <br>
§ 713        Unterbleiben von Schuldnerschutzanordnungen <br>
§ 714        Antrag zur vorläufigen Vollstreckbarkeit <br>
§ 715        Rückgabe der Sicherheits <br>
§ 716        Ergänzung des Urteils <br>
§ 717        Wirkungen eines aufhebenden oder abändernden Urteils <br>
§ 718        Vorentscheidung über vorläufige Vollstreckbarkeit <br>
§ 719        Einstweilig Einstellung bei Rechtsmittel und Einspruch <br>
§ 720        Hinterlegung bei Abwendung der Vollstreckung <br>
§ 720a      Sicherungsvollstreckung <br>
§ 721        Räumungsfrist <br>
§ 722        Vollstreckbarkeit ausländischer Urteile <br>
§ 723        Vollstreckungsurteil <br>
§ 724        Vollstreckbare Ausfertigung <br>
§ 725        Vollstreckungsklausel <br>
§ 726        Vollstreckbare Ausfertigung bei bedingten Leistungen <br>
§ 727        Vollstreckbare Ausfertigung für und gegen Rechtsnachfolger <br>
§ 728        Vollstreckbare Ausfertigung bei Nacherbe und Testamentsvollstrecker <br>
§ 729        Vollstreckbare Ausfertigung gegen Vermögens- und Firmenübernehmer <br>
§ 730        Anhörung des Schuldners <br>
§ 731        Klage auf Erteilung der Vollstreckungsklausel <br>
§ 732        Erinnerung gegen Erteilung der Vollstreckungsklausel <br>
§ 733        Weitere vollstreckbare Ausfertigung <br>
§ 734        Vermerk über Ausfertigungserteilung auf der Urteilsschrift <br>
§ 735        Hinterlegung bei Abwendung der Vollstreckung <br>
§ 736        Zwangsvollstreckung gegen BGB-Gesellschaft <br>
§ 737        Zwangsvollstreckung bei Vermögens- oder Erbschaftsnießbrauch <br>
§ 738        Vollstreckbare Ausfertigung gegen Nießbraucher <br>
§ 739        Gewahrsamsvermutung bei Zwangsvollstreckung gegen Ehepartner und Lebensgatten <br>
§ 740        Zwangsvollstreckung in das Gesamtgut <br>
§ 741        Zwangsvollstreckung in das Gesamtgut bei Erwerbsgeschäft <br>
§ 742        Vollstreckbare Ausfertigung bei Gütergemeinschaft während des Rechtsstreits <br>
§ 743        Beendete Gütergemeinschaft <br>
§ 744        Vollstreckbare Ausfertigung bei beendeter Gütergemeinschaft <br>
§ 744a      Zwangsvollstreckung bei Eigentums und Vermögensgemeinschaft <br>
§ 745        Zwangsvollstreckung bei fortgesetzter Gütergemeinschaft <br>
§ 746        (weggefallen) <br>
§ 747        Zwangsvollstreckung in ungeteilten Nachlass <br>
§ 748        Zwangsvollstreckung bei Testamentsvollstrecker <br>
§ 749        Vollstreckbare Ausfertigung für und gegen Testamentsvollstrecker <br>
§ 750        Voraussetzunge der Zwangsvollstreckung <br>
§ 751        Bedingungen für Vollstreckungsbeginn <br>
§ 752        Sicherheitsleistung bei Teilvollstreckung <br>
§ 753        Vollstreckung durch Gerichtsvollzieher; Verordnungsermächtigung <br>
§ 753a      Vollstreckungsnachweis <br>
§ 754        Vollstreckungsauftrag und vollstreckbare Ausfertigung <br>
§ 754a      Vereinfachter Vollstreckungsauftrag bei Vollstreckungsbescheiden <br>
§ 755        Ermittlung des Aufenthaltsorts des Schuldners <br>
§ 756        Zwangsvollstreckung bei Leistung Zug um Zug <br>
§ 757        Übergabe des Titels und Quittung <br>
'''''[ab 1.1.2022:]''''' <br>
§ 757a      Auskunft- und Unterstützungsersuchen <br>
§ 758        Durchsuchung; Gewaltanwendung <br>
§ 759        Zuziehung von Zeugen <br>
§ 760        Akteneinsicht; Aktenabschrift <br>
§ 761        (weggefallen) <br>
§ 762        Protokoll über Vollstreckungshandlungen <br>
§ 763        Aufforderungen und Mitteilungen <br>
§ 764        Vollstreckungsgericht <br>
§ 765        Vollstreckungsgerichtliche Anordnungen bei Leistung Zug um Zug <br>
§ 765a      Vollstreckungsschutz <br>
§ 766        Erinnerung gegen Art und Weise der Zwangsvollstreckung <br>
§ 767        Vollstreckungsabwehrklage <br>
§ 768        Klage gegen Vollstreckungsklausel <br>
§ 769        Einstweilige Anordnungen <br>
§ 770        Einstweilige Anordnungen im Urteil <br>
§ 771        Drittwiderspruchsklage <br>
§ 772        Drittwiderspruchsklage bei Veräußerungsverbot <br>
§ 773        Drittwiderspruchsklage des Nacherben <br>
§ 774        Drittwiderspruchsklage des Ehegatten oder Lebenspartners <br>
§ 775        Einstellung oder Beschränkung der Zwangsvollstreckung <br>
§ 776        Aufhebung von Vollstreckungsmaßregeln <br>
§ 777        Erinnerung bei genügender Sicherung des Gläubigers<br>
§ 778        Zwangsvollstreckung vor Erbschaftsannahme <br>
§ 779        Fortsetzung der Zwangsvollstreckung nach dem Tod des Schuldners <br>
§ 780        Vorbehalt der beschränkten Erbenhaftung <br>
§ 781        Beschränkte Erbenhaftung in der Zwangsvollstreckung <br>
§ 782        Einreden des Erben gegen Nachlassgläubiger <br>
§ 783        Einreden des Erben gegen persönliche Gläubiger <br>
§ 784        Zwangsvollstreckung bei Nachlassverwaltung und Insolvenzverfahren <br>
§ 785        Vollstreckungsabwehrklage des Erben <br>
§ 786        Vollstreckungsabwehrklage bei beschränkter Haftung <br>
§ 786a      See- und binnenschifffahrtsrechtliche Haftungsbeschränkung <br>
§ 787        Zwangsvollstreckung bei herrenlosem Grundstück oder Schiff <br>
§ 788        Kosten der Zwangsvollstreckung <br>
§ 789        Einschreiten von Behörden <br>
§ 790        (weggefallen) <br>
§ 791        (weggefallen) <br>
§ 792        Erteilung von Urkunden an Gläubiger <br>
§ 793        Sofortige Beschwerde <br>
§ 794        Weitere Vollstreckungstitel <br>
§ 794a      Zwangsvollstreckung aus Räumungsverkauf <br>
§ 795        Anwendung der allgemeinen Vorschriften auf die weiteren Vollstreckungstitel<br>
§ 795a      Zwangsvollstreckung aus Kostenfestsetzungsbeschluss <br>
§ 795b      Vollstreckbarerklärung des gerichtlichen Vergleichs <br>
§ 796        Zwangsvollstreckung aus Vollstreckungsbescheiden<br>
§ 796a      Voraussetzungen für die Vollstreckbarerklärung des Anwaltsvergleichs <br>
§ 797        Verfahren bei vollsteckbaren Urkunden<br>
§ 798        Wartefrist <br>
§ 798a      (weggefallen) <br>
§ 799        Vollstreckbare Urkunde bei Rechtsnachfolge <br>
§ 799a      Schadensersatzpflicht bei der Vollstrecking aus Urkunden durch andere Gläubiger <br>
§ 800        Vollstreckbare Urkunde gegen den jeweiligen Grundstückseigentümer <br>
§ 800a      Vollstreckbare Urkunde bei Schiffshypothek <br>
§ 801        Landesrechtliche Vollstreckungstitel <br>
§ 802        Auschließlichkeit der Gerichtsstände <br>
::::::::: Abschnitt 2. Zwangsvollstreckung wegen Geldforderungen
:::::::::::::Titel 1. Allgemeine Vorschriften
§ 802a      Grundsätze der Vollstreckung; Regelbefugnisse des Gerichtsvollziehers <br>
§ 802b      Gütliche Erledigung; Vollstreckungsaufschub bei Zahlungsvereinbarung <br>
§ 802c      Vermögensauskunft des Schuldners <br>
'''''[bis 31.12.2021:]''''' <br>
§ 802d      Erneute Vermögensauskunft <br>
'''''[ab 1.1.2022:]''''' <br>
§ 802e      Zuständigkeit <br>
§ 802f      Verfahren zur Abnahme der Vermögensauskunft <br>
§ 802g      Erzwingungshaft <br>
§ 802h      Unzulässigkeit der Haftvollstreckung <br>
§ 802i      Vermögensauskunft des verhafteten Schuldners <br>
§ 802j      Dauer der Haft; erneute Haft <br>
§ 802k      Zentrale Verwaltung der Vermögensverhzeichnisse <br>
§ 802l      Auskunftsrechte des Gerichtsvollziehers <br>
:::::::::::::Titel 2. Zwangsvollstreckung in das bewegliche Vermögen
:::::::::::::::::Untertitel 1. Allgemeine Vorschriften
§ 803        Pfändung <br>
§ 804        Pfändungspfandrecht <br>
§ 805        Klage auf Vorzugsweise Befriedigung <br>
§ 806        Keine Gewährleistung der Pfandveräusserung <br>
§ 806a      Mitteilungen und Befragung durch den Gerichtsvollzieher <br>
§ 807        Abnahme der Vermögensauskunft nach Pfandversuch <br>
:::::::::::::Untertitel 2. Zwangsvollstreckung in körperliche Sachen
§ 808        Pfändung beim Schuldner <br>
§ 809        Pfändung beim Gläubiger oder bei Dritten <br>
§ 810        Pfändung ungetrennter Früchte <br>
'''''[ab 31.12.2021:]''''' <br>
§ 811        Unpfändbare Sachen <br>
'''''[ab 1.1.2022:]''''' <br>
§ 811        ''Unpfändbare Sachen und Tiere ''<br>
§ 811a      Austauschpfändung<br>
§ 811b      Vorläufige Austauschpfändung<br>
'''''[ab 31.12.2021:]''''' <br>
§ 811c      Unpfändbarkeit von Haustieren<br>
§ 811d      Vorwegpfändung<br>
§ 812        Pfändung von Hausrat<br>
§ 813        Schätzung<br>
§ 814        Öffentliche Versteigerung<br>
§ 815        Gepfändetes Geld<br>
§ 816        Zeit und Ort der Versteigerung<br>
§ 817        Zuschlag und Ablieferung<br>
§ 817a      Mindestgebot<br>
§ 818        Einstellung der Versteigerungt<br>
§ 819        Wirkung des Erlösempfängers<br>
§ 820        (weggefallen)<br>
§ 821        Verwertung von Werkpapieren<br>
§ 822        Umschreibung von Namenspapieren<br>
§ 823        Außer Kurs gesetzte Inhaberpapiere<br>
§ 824        Pfändung von Hausrat<br>
§ 825        Andere Verwertungsart<br>
§ 826        Anschlussprüfung<br>
§ 827        Verfahren bei mehrfacher Pfändung<br>
:Untertitel 3. Zwangsvollstreckung in Forderungen und anderen Vermögensrechte
§ 828        Zuständigkeit des Vollstreckungsgerichts<br>
§ 829        Pfändung einer Geldforderung<br>
§ 830        Pfändung einer Hypothekenforderung<br>
§ 831        Pfändung indossabler Papiere<br>
§ 832        Pfändungsumfang bei fortlaufenden Bezügen<br>
§ 833        Pfändungsumfang bei Arbeits- oder Diensteinkommen<br>
§ 833a      Pfändungsumfang bei Kontoguthaben<br>
§ 834        Keine Anhörung des Schuldners<br>
§ 835        Überweisung einer Geldforderung<br>
§ 836        Wirkung der Überweisung<br>
§ 837        Überweisung einer Hypothekenforderung<br>
§ 837a      Überweisung einer Schiffshypothekenforderung<br>
§ 838        Einrede des Schuldners bei Faustpfand<br>
§ 839        Überweisung bei Anwendungsbefugnis<br>
§ 840        Erklärungspflicht des Drittschuldners<br>
§ 841        Pflicht zur Streitverkündungs<br>
§ 842        Schadensersatz bei verzögerter Beitreibung<br>
§ 843        Verzicht des Pfandgläubigers<br>
§ 844        Andere Verwendungen<br>
§ 845        Vorpfändung<br>
§ 846        Zwangsvollstreckung in Herausgabeansprüche<br>
§ 847        Herausgabeanspruch auf eine bewegliche Sache<br>
§ 848        Herausgabeanspruch auf eine unbewegliche Sache<br>
§ 849        Keine Überweisung an Zahlungs statt<br>
§ 850        Pfändungsschutz für Arbeitseinkommen<br>
§ 850a      Unpfändbare Bezüge<br>
§ 850b      Bedingt pfändbare Bezüge<br>
§ 850c      Pfändungsgrenzen für Arbeitseinkommen<br>
§ 850d      Pfändbarkeit bei Unterhaltsansprüchen<br>
§ 850e      Berechnung des pfändbaren Arbeitseinkommen<br>
§ 850f       Änderung des unpfändbare Betrages<br>
§ 850g      Änderung der Unpfändbarkeitsvoraussetzungen<br>
§ 850h      Verschleiertes Arbeitseinkommen<br>
§ 850i       Pfändungsschutz für sonstige Einkünfte<br>
'''''[ab 30.11.2021:]''''' <br>
§ 850k       Pfändungsschutzkonto<br>
§ 850l       Anordnung der Unpfändbarkeit von Kontoguthaben auf dem Pfändungsschutzkonto<br>
'''''[ab 01.12.2021:]''''' <br>
§ ''850k''       ''Einrichtung und Beendigung des Pfandschutzkontos''<br>
§ ''850l''       ''Pfändung des Gemeinschaftskontos''<br>
§ 851        Nicht übertragbare Forderungen<br>
§ 851a       Pfändungsschutz für Landwirte<br>
§ 851b       Pfändungsschutz bei Miet- und Pachtzinsen<br>
§ 851c       Pfändungsschutz bei Altersrenten<br>
§ 851d       Pfändungsschutz bei steuerlich gefördertem Altersvorsorgevermögen<br>
§ 852        Beschränkt pfändbare Forderungen<br>
§ 853        Mehrfache Pfändung einer Geldforderung<br>
§ 854        Mehrfache Pfändung eines Anspruchs auf bewegliche Sachen<br>
§ 855        Mehrfache Pfändung eines Anspruchs auf unbewegliche Sachen<br>
§ 855a      Mehrfache Pfändung eines Anspruchs auf ein Schiff<br>
§ 856        Klage bei mehrfacher Pfändung<br>
§ 857        Zwangsvollstreckung in andere Vermögensrechte<br>
§ 858        Zwangsvollstreckung in Schiffspart<br>
§ 859        Pfändung von Gesamthandanteilen<br>
§ 860        Pfändung von Gesamtgutanteilen<br>
§§ 861, 862 (weggefallen)<br>
§ 863        Pfändungsbeschränkungen bei Erbschaftsnutzungen<br>
:::::::::::::Titel 3. Zwangsvollstreckung in das unbewegliche Vermögen<br>
§ 864        Gegenstand der Immobiliarvollstreckung<br>
§ 865        Verhältnis zur Mobiliarvollstreckung<br>
§ 866        Arten der Vollstreckung<br>
§ 867        Zwangshypothek<br>
§ 868        Erwerb der Zwangshypothek durch den Eigentümer<br>
§ 869        Erwerb der Zwangsversteigerung und Zwangsverwaltung<br>
§ 870        Grundstücksgleiche Rechte<br>
§ 870a      Zwangsvollstreckung in ein Schiff oder Schiffsbauwerk<br>
§ 871        Landesrechtlicher Vorbehalt bei Eisenbahnen<br>
:::::::::::::Titel 4. Verteilungsverfahren
§ 872        Voraussetzungen<br>
§ 873        Aufforderung des Verteilungsgerichts<br>
§ 874        Teilungsplan<br>
§ 875        Terminsbestimmung<br>
§ 876        Termin zur Erklärung und Ausführung<br>
§ 877        Säumnisfolgen<br>
§ 878        Widerspruchsklage<br>
§ 879        Zuständigkeit für die Widerspruchsklage<br>
§ 880        Inhalt des Urteils<br>
§ 881        Versäumnisurteil<br>
§ 882        Verfahren nach dem Urteil<br>
::::::Titel 5. ''[bis 30.11.2021: Zwangsvollstreckung gegen juristische Personen des öffentlichen Rechts''']<br>
:::::[ab 1.12.20211: Zwangsvollstreckung in Sachen, die der Erfüllung öffentlicher Aufgaben dienen]
§ 882a       Zwangsvollstreckung wegen einer Geldforderung<br>
:::::::::::::Titel 6. Schuldnerverzeichnbis
§ 882b       Inhalt des Schuldnerverzeichnisses<br>
§ 882c       Eintragungsanordnung<br>
§ 882d       Vollziehung der Eintragungsanordnung<br>
§ 882e       Löschung<br>
§ 882f       Einsicht in das Schuldnerverzeichnis<br>
§ 882g       Erteilung von Abdrucken<br>
§ 882h       Zuständigkeit; Ausgestaltung des Schuldnerverzeichnisses<br>
§ 882i       Rechte der Betroffenen<br>
Abschnitt 3. Zwangsvollstreckung zur Erwirkung der Herausgabe von Sachen und zur Erwirkung von<br>
::::::::::::Handlungen oder Unterlassungen
§ 883        Herausgabe bestimmter beweglicher Sachen<br>
§ 884        Leistung einer bestimmten Menge vertretbarer Sachen<br>
§ 885        Herausgabe von Grundstücken oder Schiffen<br>
§ 886        Herausgabe bei Gewahrsam eines Dritten<br>
§ 887        Vertretbare Handlungen<br>
§ 888        Nicht vertretbare Handlungen<br>
§ 888a      Keine Handlungsvollstreckung bei Entschädigungspflicht<br>
§ 889        Eidesstattliche Versicherung nach bürgerlichem Recht<br>
§ 890        Erzwingung von Unterlassungen und Duldungen<br>
§ 891        Verfahren; Anhörung des Schuldners; Kostenentscheidung<br>
§ 892        Widerstand des Schuldners<br>
§ 893        Klage auf Leistung des Interesses<br>
§ 894        Fiktion der Abgabe einer Willenserklärung<br>
§ 895        Willenserklärung zwecks Eintragung bei vorläufig vollstreckbarem Urteil<br>
§ 896        Erteilung von Urkunden an Gläubiger<br>
§ 897        Übereignung; Verschiffung von Grundpfandrechten<br>
§ 898        Gutgläubiger Erwerb<br>
'''''[bis 30.11.2021:]''''' <br>
§§ 899 - 915h (aufgehoben)
'''''[ab 1.12.2021:]''''' <br>
::::::::: Abschnitt 4. Wirkungen des Pfändungsschutzkontos
§ 899        Pfändungsfreier Betrag; Übertragung<br>
§ 900        Moratorium bei Überweisung an den Gläubiger<br>
§ 901        Verbot der Aufrechnung und Verrechnung<br>
§ 902        Erhöhungsbeträge<br>
§ 903        Nachweise über Erhöhungsbeträge<br>
§ 904        Nachzahlung von Leistungen<br>
§ 905        Festsetzung der Erhöhungsbeträge durch das Vollstreckungsgericht<br>
§ 906        Festsetzung eines abweichenden pfändungsfreien Betrages durch das Vollstreckungsgericht<br>
§ 907        Festsetzung der Unpfändbarkeit von Kontoguthaben auf dem Pfändungskonto<br>
§ 908        Aufgaben des Kreditinstituts<br>
§ 909        Datenweitergabe; Löschungspflicht<br>
§ 910        Verwaltungsvollsteckung<br>
§. 911 bis 915h (weggefallen)<br>
::::::::: Abschnitt 5. Arrest und einstweilige Verfügung<br>
§ 916        Arrestanspruch<br>
§ 917        Arrestgrund bei dinglichem Arrest<br>
§ 918        Arrestgrund bei persönlichem Arrest<br>
§ 919        Arrestgericht<br>
§ 920        Arrestgesuch<br>
§ 921        Entscheidung über das Arrestgesuch<br>
§ 922        Arresturteil und Arrestbeschluss<br>
§ 923        Anwendungsbefugnis<br>
§ 924        Widerspruch<br>
§ 925        Entscheidung nach Widerspruch<br>
§ 926        Anordnung der Klageerhebung<br>
§ 927        Aufhebung wegen veränderter Umstände<br>
§ 928        Vollziehung des Arrestes<br>
§ 929        Vollstrechungsklausel; Vollziehungsfrist<br>
§ 930        Vollziehung in bewegliches Vermögen und Forderungen<br>
§ 931        Vollziehung in eingetragenes Schiff oder Schiffsbauwerk<br>
§ 932        Arresthypothek<br>
§ 933        Vollziehung des persönlichen Arrestes<br>
§ 934        Aufhebung der Arrestvollziehung<br>
§ 935        Einstweilige Verfügung bezüglich Streitgegenstand<br>
§ 936        Anwendung der Arrestvorschriften<br>
§ 937        Zuständiges Gericht<br>
§ 938        Inhalt der Einstweiligen Verfügung<br>
§ 939        Aufhebung gegen Sicherheitsleistung<br>
§ 940        Einstweilige Verfügung zur Regelung eines weiteren Zustandes<br>
§ 940a      Räumung von Wohnraum<br>
§ 941        Ersuchen um Eintragungen ins Grundbuch usw.<br>
§ 942        Zuständigkeit des Amtsgerichts der belegenen Sache<br>
§ 943        Gericht der Hauptsache<br>
§ 944        Entscheidung des Vorsitzenden bei Dringlichkeit<br>
§ 945        Schadensersatzprlicht<br>
§ 945a      Einreichung von Schutzvorschriften<br>
§ 945b      Verordnungsermächtigung<br>
::::::::: Abschnitt 6. Grenzüberschreitende vorläufige Kontenpfändung<br>
::::::::: Titel 1. Erlass des Beschlusses zur vorläufigen Kontenpfändung<br>
§ 946        Zuständigkeit<br>
§ 947        Verfahren<br>
§ 948        Ersuchen um Einholen von Konteninformationen<br>
§ 949        Nicht rechtzeitige Einleitung des Hauptverfahrens<br>
::::::::: Titel 2. Vollziehung des Beschlusses zur vorläufigen Kontenpfändung<br>
§ 950        Anwendbare Vorschriften<br>
§ 951        Vollziehung von im Inland erlassenen Beschlüssen<br>
§ 952        Vollziehung von einem anderen Mitgliedstaat erlassenen Beschlüssen<br>
::::::::: Titel 3. Rechtsbehelfe
§ 953        Rechtsbehelfe des Gläubigers<br>
§ 954        Rechtsbehelfe nach den Artikeln 33 bis 35 der Verordnung (EU) Nr. 655/2014<br>
§ 955        Sicherheitsleistung nach Artikel 38 der Verordnung (EU) Nr. 655/2014<br>
§ 956        Rechtsmittel gegen die Entscheidungen nach § 954 Absatz 1 bis 3 und § 955<br>
§ 957        Ausschluss der Rechtsbeschwerde<br>
::::::::: Titel 4. Schadensersatz, Verordnungsermächtigung
§ 958        Schadensersatz<br>
§ 959        Verordnungsermächtigung<br>
:::::::::::: '''Buch 9.''' (weggefallen)
§§ 960 - 1024        (aufgehoben)<br>
::::::::: '''Buch 10. Schiedsrichterliches Verfahren '''
:::::::::: Abschnitt 1. Allgemeine Vorschriften
§ 1025        Anwendungsbereich<br>
§ 1026        Umfang gerichtlicher Tätigkeit<br>
§ 1027        Verlust des Rügerechts<br>
§ 1028        Empfang schriftlicher Mitteilungen bei unbekanntem Aufenthalt<br>
:::::::::: Abschnitt 2. Schiedsvereinbarung
§ 1029        Begriffsbestimmung<br>
§ 1030        Schiedsfähigkeitimmung<br>
§ 1031        Form der Schiedsvereinbarung<br>
§ 1032        Schiedsvereinbarung und Klage vor Gericht<br>
§ 1033        Schiedsvereinbarung und einmalige gerichtliche Maßnahmen<br>
::::::::: Abschnitt 3. Bildung des Schiedsgerichts
§ 1034        Zusammensetzung des Schiedsgerichts<br>
§ 1035        Bestellung der Schiedsrichter<br>
§ 1036        Ablehnung eines Schiedsrichters<br>
§ 1037        Ablehnungsverfahren<br>
§ 1038        Untätigkeit oder Unmöglichkeit der Aufgabenerfüllung<br>
§ 1039        Bestellung eines Ersatzschiedsrichters<br>
::::::: Abschnitt 4. Zuständigkeit des Schiedsgerichts
§ 1040        Befugnis des Schiedsgerichts<br>
§ 1041        Maßnahmen des einstweiligen Rechtsschutzes<br>
::::: Abschnitt 5. Durchführung des Schiedsrichterlichen Verfahrens
§ 1042        Allgemeine Verfahrensregeln<br>
§ 1043        Ort des schiedsrichterlichen Verfahrens<br>
§ 1044        Beginn des schiedsrichterlichen Verfahrens<br>
§ 1045        Verfahrenssprache<br>
§ 1046        Klage und Klagebeantwortung<br>
§ 1047        Mündliche Verhandlung und schriftliche Verfahren<br>
§ 1048        Säumnis einer Partei<br>
§ 1049        Vom Schiedsgericht bestellter Sachverständiger<br>
§ 1050        Gerichtliche Unterstützung bei der Beweisaufnahme und sonstige richterliche Handlungen<br>
::::::: Abschnitt 6. Schiedsspruch und Beendigung des Verfahrens
§ 1051        Anwendbares Recht<br>
§ 1052        Entscheidung durch ein Schiedsrichterkollegium<br>
§ 1053        Vergleich<br>
§ 1054        Form und Inhalt des Schiedsspruchs<br>
§ 1055        Wirkungen des Schiedsspruchs<br>
§ 1056        Beendigung des schiedsrichterlichen Verfahrens<br>
§ 1057        Entscheidung über die Kosten<br>
§ 1058        Berichtigung, Auslegung und Ergänzung des Schiedsspruchs<br>
::::::: Abschnitt 7. Rechtsbehelf gegen den Schiedsspruch
§ 1059        Aufhebungsantrag<br>
::::: Abschnitt 8. Voraussetzungen der Anerkennung und Vollstreckung von Schiedssprüchen
§ 1060        Inländische Schiedssprüche<br>
§ 1061        Ausländische Schiedssprüche<br>
:::::::::: Abschnitt 9. Gerichtliches Verfahren
§ 1062        Zuständigkeit<br>
§ 1063        Allgemeine Vorschriften<br>
= § 1 (ZPO) Sachliche Zuständigkeit. =
Die sachliche Zuständigkeit der Gerichte wird durch das Gesetz über die Gerichtsverfassung 2) bestimmt. '''(Quellinfo = Buch "ZPO" S. 22 ff.)'''
= § 2 (ZPO) Bedeutung des Wertes. =
Kommt es nach den Vorschriften dieses Gesetztes oder des Gerichtsverfassungsgesetzes 2) auf den Wert des Streitgegenstandes des Beschwerdegegenstandes, der Beschwerde oder der Verurteilung an, so gelten die nachfolgenden Vorschriften. '''(Quellinfo = Buch "ZPO" S. 22 ff.)'''
= § 3 (ZPO) Wertfestsetzung nach freiem Ermessen. =
Der Wert wird von dem Gericht nach freiem Ermessen festgesetzt; es kann eine beantragte Beweisaufnahme sowie von Amts wegen die Einnahme des Augenscheins und die Begutachtung durch Sachverständige anordnen. '''(Quellinfo = Buch "ZPO" S. 22 ff.)'''
= § 4 (ZPO) Wertberechnung: Nebenforderungen. =
(1) Für die Wertberechnung 3) ist der Zeitpunkt der Einreichung der Klage, in der Rechtsmittelinstanz der Zeitpunkt der Einlegung des Rechtsmittels, bei der Verurteilung der Zeitpunkt des Schlusses der mündlichen Verhandlung, auf die das Urteil ergeht, entscheidend; Früchte, Nutzungen, Zinsen und Kosten bleiben unberücksichtigt, wenn sie als Nebenforderungen geltend gemacht werden. (2) Bei Ansprüchen aus Wechseln im Sinne des Wechselgesetzes sind Zinsen, Kosten und Provision, die außer der Wechselsumme gefordert werden, als Nebenforderungen anzusehen. '''(Quellinfo = Buch "ZPO" S. 22 ff.)'''
= § 5 (ZPO) Mehrere Ansprüche. =
Mehrere in einer Klage geltend gemachte Ansprüche werden zusammengerechnet; dies gilt nicht für den Gegenstand der Klage und der Widerklage. '''(Quellinfo = Buch "ZPO" S. 22 ff.)'''
= § 6 (ZPO) Besitz; Sicherstellung; Pfandrecht. =
<sup>1</sup> Der Wert wird bestimmt; durch den Wert einer Sache; wenn es auf deren Besitz und durch den Betrag einer Forderung, wenn es auf deren Sicherstellung oder ein Pfandrecht ankommt.<sup>2</sup> Hat der Gegenstand des Pfandrechts einen geringeren Wert, so ist dieser maßgebend. '''(Quellinfo = Buch "ZPO" S. 22 ff.)'''
= § 7 (ZPO) Grunddienstbarkeit. =
Der Wert einer Grunddienstbarkeit wird durch den Wert, den sie für das herrschende Grundstück hat, und wenn der Betrag, um den sich der Wert des dienenden Grundstücks durch die Dienstbarkeit mindert, größer ist, durch diesen Betrag bestimmt. '''(Quellinfo = Buch "ZPO" S. 22 ff.)'''
= § 8 (ZPO) <sup> 1) </sup> Pacht- oder Mietverhältnis. =
Ist das Bestehen oder die Dauer eines Pacht- oder Mietverhältnisses streitig, so ist der Betrag der auf die gesamte streitige Zeit entfallenden Pacht oder Miete und, wenn der 25fache Betrag des einjährigen Entgelts geringer ist, dieser Betrag für die Wertberechnung entscheidend. '''(Quellinfo = Buch "ZPO" S. 23 ff.)'''
= § 9 (ZPO) <sup> 2) </sup> Wiederkehrende Nutzungen oder Leistungen. =
1 Der Wert des Rechts auf wiederkehrende Nutzungen oder Leistungen wird nach dem dreieinhalbfachen Wert des einjährigen Bezuges berechnet. 2 Bei bestimmter Dauer des Bezugsrechts ist der Gesamtbetrag der künftigen Bezüge maßgebend, wenn er der geringere ist. '''(Quellinfo = Buch "ZPO" S. 23 ff.)'''
= § 10 (ZPO) (weggefallen) =
'''(Quellinfo = Buch "ZPO" S. 23 ff.)'''
= § 11 (ZPO) Bindende Entscheidung über Unzuständigkeit =
Ist die Unzuständigkeit eines Gerichts auf Grund der Vorschriften über die sachliche Zuständigkeit der Gerichte rechtskräftig ausgesprochen, so ist diese Entscheidung für das Gericht bindend, bei dem die Sache später anhängig wird. '''(Quellinfo = Buch "ZPO" S. 23 ff.)'''
:::'''Titel 2. Gerichtsstand'''
= § 12³) (ZPO) Allgemeiner Gerichtsstand; Begriff. =
Das Gericht, bei dem eine Person ihren allgemeinen Gerichtsstand hat, ist für alle gegen sie zu erhebenden Klagen zuständig, sofern nicht für eine klage ein ausschließlicher Gerichtsstand begründet ist. '''(Quellinfo = Buch "ZPO" S. 23 ff.)'''
= § 13) (ZPO) Allgemeiner Gerichtsstand des Wohnsitzes. =
Der allgemeine Gerichtsstand einer Person wird durch den Wohnsitz bestimmt '''(Quellinfo = Buch "ZPO" S. 23 ff.)'''
= § 14) (ZPO) (weggefallen) =
'''(Quellinfo = Buch "ZPO" S. 23 ff.)'''
= § 15 (ZPO) Allgemeiner Gerichtsstand für exterritoriale Deutsche =
(1)<sup>1</sup> Deutsche, die das Recht der Exterritorialität genießen, sowie die im Ausland beschäftigten deutschen Angehörigen des öffentlichen Diensts behalten den Gerichtsstand ihres letzten inländischen Wohnsitzes. <sup>2</sup> Wenn sie einen solchen Wohnsitz nicht hatten, habe sie ihren allgemeinen Gerichtsstand beim Amtsgericht Schöneberg in Berlin. (2) Auf Honorarkonsuln ist diese Vorschrift nicht anzuwenden.
'''(Quellinfo = Buch "ZPO" S. 23 ff.)'''
= § 16 (ZPO) Allgemeiner Gerichtsstand wohnsitzloser Personen =
Der allgemeine Gerichtstand einer Person, die keinen Wohnsitz hat, wird durch den Aufenthaltsort im Inland und, wenn ein solcher nicht bekannt ist, durch den letzten Wohnsitz bestimmt. '''(Quellinfo = Buch "ZPO" S. 23 ff.)'''
= § 17 (ZPO) Allgemeiner Gerichtsstand juristischer Personen =
(1) <sup> 1 </sup> Der allgemeine Gerichtsstand der Gemeinden, der Korporationen sowie derjenigen Gesellschaften, Genossenschaften oder anderen Vereine und derjenigen Stiftungen, Anstalten und Vermögensmassen, die als solche verklagt werden können, wird durch ihren Sitz bestimmt. <sup> 2 </sup> Als Sitz gilt, wenn sich nichts anderes ergibt, der Ort, wo die Verwaltung geführt wird. (2) Gewerkschaften haben den allgemeinen Gerichtstand bei dem Gericht, in dessen Bezirk das Bergwerk liegt, Behörden, wenn sie als solche verklagt werden können, bei dem Gericht ihres Amtssitzes. (3) Neben dem durch die Vorschriften dieses Paragraphen bestimmten Gerichtsstand ist ein durch Statut oder in anderer Weise besonders geregelter Gerichtsstand zulässig. '''(Quellinfo = Buch "ZPO" S. 24 ff.)'''
= § 18 Allgemeiner Gerichtsstand des Fiskus =
Der allgemeine Gerichtsstand des Fiskus wird durch den Sitz der Behörde bestimmt, die berufen ist, den Fiskus in dem Rechtsstreit zu vertreten. '''(Quellinfo = Buch "ZPO" S. 24 ff.)'''
= § 19 Mehrere Gerichtsbezirke am Behördensitz =
Ist der Ort, an dem eine Behörde ihren Sitz hat, in mehrere Gerichtsbezirke geteilt, so wird der Bezirk der im Sinne der §§ 17, 18 als Sitz der Behörde gilt, für die Bundesbehörden von dem Bundesministerium der Justiz und für Verbraucherschutz, im Übrigen von der Landesjustizverwaltung durch allgemeine Anordnung bestimmt. '''(Quellinfo = Buch "ZPO" S. 24 ff.)'''
= § 19 <sub> a </sub> Allgemeiner Gerichtsstand des Insolvenzverwalters. =
Der allgemeine Gerichtsstand eines Isolvenzverwalters für Klagen, die sich auf die Insolvenzmasse beziehen, wird durch den Sitz des Insolvenzgerichts bestimmt. '''(Quellinfo = Buch "ZPO" S. 24 ff.)'''
= § 19 <sub> b </sub> Allgemeiner Gerichtsstand bei restrukturierungsbezogene Klagen; Verordnungsermächtigung. =
(1) Für Klagen, die sich auf Restrukturierungssachen nach dem Unternehmensstabilisierungs- und -retrukturierungsgesetz beziehen, ist ausschließlich das Gericht zuständig, in dessen Bezirk das für die Restrukturierungssache zuständige Restrukturierungsgericht seinen Sitz hat.
<div style="text-indent: 38px;"> (2) <sup> 1 </sup>Die Landesregierungen werden ermächtigt, durch Rechtsverordnung die in Absatz 1 genannten Klagen einem Landgericht für die Bezirke mehrerer Oberlandesgerichte zuzuweisen, sofern dies der sachlichen Förderung oder schnelleren Erledigung der Verfahren dienlich ist. <sup>2</sup>Die Landesregierungen können die Ermächtigung durch Rechtsverordnung auf die Landesjustizverwaltungen übertragen. '''(Quellinfo = Buch "ZPO" S. 24 ff.)'''</div>
= § 20 Besonderer Gerichtsstand des Aufenthaltsorts. =
Wenn Personen an einem Ort unter Verhältnissen, die ihrer Natur nach auf einen Aufenthalt von längerer Dauer hinweisen, insbesondere als Hausgehilfen, Arbeiter, Gewerbehilfen, Studierende, Schüler oder Lehrlinge sich aufhalten, so ist das Gericht des Aufenthaltsortes für alle Klagen zuständig, die gegen dieser Personen wegen vermögensrechtlicher Ansprüche erhoben werden. '''(Quellinfo = Buch "ZPO" S. 24 ff.)'''
= § 21 Besonderer Gerichtsstand der Niederlassung. =
(1) hat jemand zum Betrieb einer Fabrik, einer Handlung oder eines anderen Gewerbes eine Niederlassung, von der aus unmittelbar Geschäfte geschlossen werden, so können gegen ihn alle Klagen, die auf den Geschäftsbetrieb der Niederlassung Bezug haben, bei dem Gericht des Ortes erhoben werden, wo die Niederlassung sich befindet. '''(Quellinfo = Buch "ZPO" S. 24 ff.)'''
= § 22 Besonderer Gerichtsstand der Mitgliedschaft. =
Das Gericht, bei dem Gemeinden, Korporationen, Gesellschaften, Genossenschaften oder andere Vereine den allgemeinen Gerichtsstand haben, ist für die Klagen zuständig, die von ihnen oder von dem Insolvenzverwalter gegen die Mitglieder als solche oder von den Mitgliedern in dieser Eigenschaft gegeneinander erhoben werden. '''(Quellinfo = Buch "ZPO" S. 25 ff.)'''
= § 23<sup>1)</sup>Besonderer Gerichtsstand des Vermögens und des Gegenstands. =
<sup>1</sup> Für Klagen wegen vermögensrechtlicher Ansprüche gegen eine Person, die im Inland keinen Wohnsitz hat, ist das Gericht zuständig, in dessen Bezirk sich Vermögen derselben oder der mit der Klage in Anspruch genommene Gegenstand befindet. <sup>2</sup> Bei Forderungen gilt als der Ort, wo das Vermögen sich befindet, der Wohnsitz des Schuldners und, wenn für die Forderungen eine Sache zur Sicherheit haftet, auch der Ort, wo die Sache sich befindet. '''(Quellinfo = Buch "ZPO" S. 25 ff.)'''
= § 23a (aufgehoben) =
= § 24 Ausschließlicher dinglicher Gerichtsstand. =
(1) Für Klagen, durch die das Eigentum, eine dingliche Belastung oder die Freiheit von einer solchen geltend gemacht wird, für Grenzscheidungs-, Teilung- und Besitzklagen ist, sofern es sich um unbewegliche Sachen handelt, das Gericht ausschließlich zuständig, in dessen Bezirk die Sache belegen ist. (2) Bei den eine Grunddienstbarkeit, eine Reallast oder ein Vorkaufsrecht betreffenden Klagen ist die Lage des dienenden oder belasteten Grundstücks entscheidend. '''(Quellinfo = Buch "ZPO" S. 25 ff.)'''
= § 25 Dinglicher Gerichtsstand des Sachzusammenhanges. =
In dem dinglichen Gerichtsstand kann mit der Klage aus einer Hypothek, Grundschuld oder Rentenschuld die Schuldklage, mit der Klage auf Umschreibung oder Löschung einer Hypothek, Grundschuld oder Rentenschuld die Klage auf Befreiung von der persönlichen Verbindlichkekt mit der Klage auf Anerkennung einer Reallast die Klage auf rückständige Leistungen erhoben werden, wenn die verbundenen Klagen gegen denselben Beklagten gerichtet sind. '''(Quellinfo = Buch "ZPO" S. 25 ff.)'''
= § 26 Dinglicher Gerichtsstand für persönliche Klagen. =
In dem dinglichen Gerichtsstand können persönliche Klagen, die gegen die Eigentümer oder Besitzer einer unbeweglichen Sache als solche gerichtet werden, sowie Klagen wegen Beschädigung eines Grundstücks oder hinsichtlich der Entschädigung wegen Enteignung eines Grundstücks erhoben werden. '''(Quellinfo = Buch "ZPO" S. 25 ff.)'''
= § 27 Besonderer Gerichtsstand der Erbschaft. =
(1) Kagen, welche die Feststellung des Erbrechts, Ansprüche des Erben gegen einen Erbschaftsbesitzer, Anprüche aus Vermächtnissen oder sonstigen Verfügungen von Todes wegen, Pflichtteilsansprüche oder die Teilung der Erbschaft zum Gegenstand haben, können vor dem Gericht erhoben werden, bei dem er Erblasser zur zeit seines Todes den allgemeinen Gerichtsstand gehabt hat. (2) Ist der Erblasser ein Deutscher und hatte er zur Zeit seines Todes im Inland keinen allgemeinen Gerichtsstand, so können die im Absatz 1 bezeichneten Klagen vor dem Gericht erhoben werden, in dessen Bezirk der Erblasser seinen letzten inländischen Wohnsitz hatte, wenn er einen solchen Wohnsitz nicht hatte, so gilt die Vorschrift des § 15 Abs., 1 Satz 2 entsprechend. '''(Quellinfo = Buch "ZPO" S. 26 ff.)'''
= § 28 Erweiterter Gerichtsstand der Erbschaft. =
In dem Gerichtsstand der Erbschaft können auch Klagen wegen anderer Nachlassverbindlichkeiten erhoben werden, solange sich der Nachlass noch ganz oder teilweise im Bezirk des Gerichts befindet oder die vorhandenen mehreren Erben noch als Gesamtschuldner haften. '''(Quellinfo = Buch "ZPO" S. 26 ff.)'''
= § 29 Besonderer Gerichtsstand des Erfüllungsorts. =
(1) Für Streitigkeiten aus einem Ertragsverhältnis und über deren Betehen ist das Gericht des Ortes zuständig, an dem die streitige Verpflichtung zu erfüllen ist. (2) Eine Vereinbarung über den Erfüllungsort begründet die Zuständigkeit nur, wenn die Vertragsparteien Kaufleute, juristische Personen des öffentlichen Rechts oder öffentlich-rechtliche Sondervermögen sind. '''(Quellinfo = Buch "ZPO" S. 26 ff.)'''
= § 29a Ausschließlicher Gerichtstand bei Miet- oder Pachträumen. =
(1) Für Streitigkeiten über Ansprüche aus Miet- oder Pachtverhältnissen über Räume oder über dessen Bestehen solcher Verhältnisse ist das Gericht ausschließlich zuständig, in dessen Bezirk sich die Räume befinden. (2) Absatz 1 ist nicht anzuwenden, wenn es sich um Wohnraum der in § 549 Abs. 2 Nr. 1 bis 3 des Bürgerlichen Gesetzbuchs genannten Art handelt. '''(Quellinfo = Buch "ZPO" S. 26 ff.)'''
= § 29b (aufgehoben) =
= § 29c Besonderer Gerichtsstand für Haustürgeschäfte. =
(1)<sup>1</sup>Für Klagen aus außerhalb von Geschäftsräumen geschlossenen Verträgen (§312b des Bürgerlichen Gesetzbuchs) ist das Gericht zuständig, in dessen Bezirk der Verbraucher zur Zeit der Klageerhebung seinen Wohnsitz, in Ermangelung eines solchen seinen gewöhnlichen Aufenthalt hat. <sup>2</sup> Für Klagen gegen den Verbraucher ist dieses Gericht ausschließlich zuständig. (2) Verbraucher ist jede natürliche Person, die bei dem Erwerb des Anspruchs oder der Begründung des Rechtsverhältnisses nicht überwiegend im Rahmen ihrer gewerblichen oder selbständigen beruflichen Tätigkeit handelt. (3) § 33 Abs. 2 findet auf Widerklagen der anderen Vertragspartei keine Anwendung. (4) Eine von Absatz 1 abweichende Vereinbarung ist zulässig für den Fall, dass der Verbraucher nach Vertragsschluss seinen Wohnsitz oder gewöhnlicher Aufenthalt im Zeitpunkt der Klageerhebung nicht bekannt ist.
'''(Quellinfo = Buch "ZPO" S. 26 ff.)'''
= § 30 Gerichtsstand bei Beförderungen. =
(1)<sup>1</sup>Für Rechtsstreitigkeiten aus einer Güterbeförderung ist auch das Gericht zuständig, in dessen Bezirk der Ort der Übernahme des Gutes oder der für die Ablieferung des Gutes vorgegebene Ort liegt. <sup>2</sup>Eine Klage gegen den ausführenden Frachtführer oder ausführenden Verfrachter kann auch in dem Gerichtstand des Frachtführers oder Verfrachtete erhoben werden. <sup>3</sup> Eine Klage gegen den Frachtführer oder ausführenden Verfrachter kann auch in dem Gerichtsstand des ausführenden Frachtführers oder ausführenden Verfrachtete erhoben werden. (2)<sup>1</sup> Für Rechtsstreitigkeiten wegen einer Beförderung von Fahrgästen und ihrem Gepäck auf Schiffen ist auch das Gericht zuständig, in dessen Bezirk sich der im Beförderungsvertrag bestimmte Abgangs- oder Bestimmungsort befindet. <sup>2</sup>Eine von Satz 1 abweichende Vereinbarung ist unwirksam, wenn sie vor Eintritt des Ereignisses getroffen wird, das den Tod oder die Körperverletzung des Fahrgasts oder den Verlust, die Beschädigung oder die verspätete Aushändigung des Gepäcks verursacht hat.'''(Quellinfo = Buch "ZPO" S. 26 ff.)'''
= § 30a Gerichtsstand bei Bergungsansprüchen. =
Für Klagen wegen Ansprüchen aus Bergung von Schiffen oder sonstigen Vermögensgegenständen in einem Gewässer gegen eine Person, die im Inland keinen Gerichtsstand hat, ist das Gericht zuständig, bei dem der Kläger im Inland seinen allgemeinen Gerichtstand hat. '''(Quellinfo = Buch "ZPO" S. 27 ff.)'''
= § 31 Besonderer Gerichtstand der Vermögensverwaltung. =
Für Klagen, die aus einer Vermögensverwaltung von dem Geschäftsherrn gegen den Verwalter oder von dem Verwalter gegen den Geschätsherrn erhoben werden, ist das Gericht des Ortes zuständig, wo die Verwaltung geführt ist. '''(Quellinfo = Buch "ZPO" S. 276 ff.)'''
= § 32 Besonderer Gerichtsstand der unerlaubten Handlung. =
Für Klagen aus unerlaubten Handlungen ist das Gericht zuständig, in dessen Bezirk die Handlung begangen ist. '''(Quellinfo = Buch "ZPO" S. 27 ff.)'''
= § 32a Ausschließlicher Gerichtsstand der Umwelteinwirkung. =
<sup>1</sup>Für Klagen gegen den Inhaber einer im Anhang 1 des Umwelthaftungsgesetzes genannten Anlage, mit denen der Ersatz eines durch eine Umwelteinwirkungverursachten Schadens geltend gemacht wird, ist das Gericht ausschließlich zuständig, in dessen Bezirk die Umwelteinwirkung von der Anlage ausgegangen ist. <sup>2</sup>Dies gilt nicht, wenn die Anlage im Ausland belegen ist.
= § 32b<sup>1)</sup> Ausschließlicher Gerichtsstand bei falschen, irreführenden oder unterlassenen öffentlichen Kapitalmarktinformationen. =
(1) Für Klagen, in denen 1. ein Schadensersatzanspruch wegen falscher, irreführender oder unterlassener öffentlicher Kapitalmarktinformation, 2. ein Schadensersatzanpruch wegen Verwendung einer falschen oder irreführenden öffentlichen Kapitalmarktinformation oder wegen Unterlassung der gebotenen Aufklärung darüber das eine öffentliche Kapitalmarktinformation falsch oder irreführend ist, oder 3. ein Erfüllunganspruch aus Vertrag, der auf einem Angebot nach dem Wertpapiererwerbs- und Übernahmegesetz beruht, geltend gemacht wird, ist das Gericht ausschließlich am Sitz des betroffenen Emittenten, des betroffenen Anbieters von sonstigen Vermögensanlagen oder der Zielgesellschaft zuständig, wenn sich dieser Sitz im Inland befindend und die Klage zumindest auch gegen den Emittenten, den Anbieter oder die Zielgesellschaft gerichtet wird. (2)<sup>1</sup> Die Landesregierungen werden ermächtigt, durch Rechtsverordnung, die im Absatz 1 genannten Klagen einem Landgericht für die Bezirke mehrerer Landgerichte zuzuweisen, sofern dies der sachlichen Forderung oder schnelleren Erledigung der Verfahren dienlich ist. <sup>2</sup>Die Landesregierungen können diese Ermächtigung auf die Landesjustizverwaltungen übertragen.
: <sup>1)</sup> Beachte hierzu Übergangsvorschrift in § 31 EGZPO (Nr. 1a).
= § 32c Ausschließlicher Gerichtsstand bei Musterfeststellungsverfahren. =
Für Klagen in Musterfeststellungsverfahren nach Buch 6 ist das Gericht des allgemeinen Gerichtsstands des Beklagten ausschließlich zuständig, sofern sich dieser im Inland befindet.
'''(Quellinfo = Buch "ZPO" S. 28 ff.)'''
= § 33 Besonderer Gerichtsstand der Widerklage. =
(1) Bei dem Gericht der Klage kann eine Widerklage erhoben werden, wenn der Gegenanspruch mit dem in der Klage geltend gemachten Anspruch oder mit den gegen ihn vorgebrachten Verteidigungsmitteln in Zusammenhang steht. (2) Dies gilt nicht, wenn für eine Klage wegen des Gegenanspruchs die Vereinbarung der Zuständigkeit des Gerichts nach § 40 Abs. 2 unzulässig ist. '''(Quellinfo = Buch "ZPO" S. 28 ff.)'''
= § 34 Besonderer Gerichtsstand des Hauptprozesses. =
Für Klagen der Prozessbevollmächtigten, der Beistände, der Zustellungsbevollmächtigten und der Gerichtsvollzieher wegen Gebühren und Auslagen ist das Gericht des Hauptrozesses zuständig. '''(Quellinfo = Buch "ZPO" S. 28 ff.)'''
= § 35 Wahl unter mehreren Gerichtsständen. =
Unter mehreren zuständigen Gerichten hat der Kläger die Wahl. '''(Quellinfo = Buch "ZPO" S. 28 ff.)'''
= § 35a (aufgehoben) =
= § 36 Gerichtliche Bestimmung der Zuständigkeit.=
(1) Das zuständige Gericht wird durch das im Rechtszug zunächst höhere Gericht bestimmt:1. wenn das an sich zuständige Gericht in einem Einzelnen Fall an der Ausübung des Richteramtes rechtlich oder tatsächlich verhindert ist; 2. wenn es mit Rücksicht auf die Grenzen verschiedener Gerichtsbezirke ungewiss ist, welches Gericht für den Rechtsstreit zuständig sei; 3. wenn mehrere Personen, die bei verschiedenen Gerichten ihren allgemeinen Gerichtsstand haben als Streitgenossen im allgemeinen Gerichtstand verklagt werden sollen und für den Rechtsstreit ein gemeinschaftlicher besonderer Gerichtstand nicht begründet ist; 4. wenn die Klage in den dinglichen Gerichtsstand erhoben werden soll und die Sache in den Bezirken verschiedener Gerichte belegen ist; 5. wenn in einem Rechtsstreit verschiedene Gerichte sich rechtskräftig für zuständig erklärt haben; 6. wenn verschiedene Gerichte, von denen eines für den Rechtsstreit zuständig ist, sich rechtskräftig für unzuständig erklärt haben,
(2) Ist das zunächst höhere gemeinschaftliche Gericht der Bundesgerichtshof, so wird das zuständige Gericht durch das Oberlandesgericht bestimmt, zu dessen Bezirk das zuerst mit der Sache befasste Gericht gehört. '''(Quellinfo = Buch "ZPO" S. 28 ff.)'''
= § 37 Verfahren bei gerichtlicher Bestimmung. =
(1) Die Entscheidung über das Gesuch um Bestimmung des zuständigen Gerichts ergeht durch Beschluss. (2) Der Beschluss, der das zuständige Gericht bestimmt, ist nicht anfechtbar.
'''(Quellinfo = Buch "ZPO" S. 29 ff.)'''
:::'''Titel 3. Vereinbarung über die Zuständigkeit des Gerichts'''
= § 38 Zugelassene Gerichtsstandsvereinbarung =
(1) Ein an sich unzuständiges Gericht des ersten Rechtszuges wird durch ausdrückliche oder stillschweigende Vereinbarung der Parteien zuständig, wenn die Vertragsparteien Kaufleute, juristische Personen des öffentlichen Rechts oder öffentlich-rechtliche Sondervermögen sind. (2)<sup>1)</sup> <sup>1</sup> Die Zuständigkeit eines Gerichts des ersten Rechtszuges kann ferner vereinbart werden, wenn mindestens eine der Vertragsparteien keinen allgemeinen Gerichtsstand in Inland hat. <sup>2</sup> Die Vereinbarung muss schriftlich abschlossen oder, falls sie mündlich getroffen wird, schriftlich bestätigt werden.<sup>3</sup>Hat eine der Parteien einen inländischen allgemeinen Gerichtsstand, so kann für das Inland nur ein Gericht gewählt werden, bei dem diese Partei ihren allgemeinen Gerichtstand hat oder ein besonderer Gerichtstand begründet ist.(3) Im Übrigen ist eine Gerichtsstandsvereinbarung nur zulässig, wenn sie ausdrücklich und schriftlich 1. nach dem Entstehen der Streitigkeit oder 2. für den Fall geschlossen wird, das die im Klageweg in Anspruch zu nehmende Partei nach Vertragsschluss ihren Wohnsitz oder gewöhnlichen Aufenthaltsort aus dem Geltungsbereich dieses Gesetztes verlegt oder ihr Wohnsitz oder gewöhnlicher Aufenthalt im Zeitpunkt der Klageerhebung nicht bekannt ist. '''(Quellinfo = Buch "ZPO" S. 29 ff.)'''
= § 39 Zuständigkeit infolge rügeloser Verhandlung. =
<sup>1</sup>Die Zuständigkeit eines Gericht des ersten Rechtszuges wird ferner dadurch begründet, dass der Beklagte, ohne die Unzuständigkeit geltend zu machen, zur Hauptsache mündlich verhandelt. <sup>2</sup>Dies gilt nicht, wenn die Belehrung nach § 504 unterblieben ist. '''(Quellinfo = Buch "ZPO" S. 29 ff.)'''
= § 40 Unwirksame und unzulässige Gerichtsstandsvereinbarung. =
(1) Die Vereinbarung hat keine rechtliche Wirkung, wenn sie nicht auf ein bestimmtes Rechtsverhältnis und die aus ihm entspringenden Rechtsstreitigkeiten sich bezieht. (2) Eine Vereinbarung is unzulässig, wenn 1. der Rechtsstreit nichtvermögensrechtliche Ansprüche betrifft, die den Amtsgerichten ohne Rücksicht auf den Wert des Streitgegenstandes zugewiesen sind, oder 2. für de Klage ein ausschließlicher Gerichtsstand begründet ist. <sup>2</sup> In diesen Fällen wird die Zuständigkeit eines Gerichts auch nicht durch rügeloses Verhandeln zur Hauptsache begründet. '''(Quellinfo = Buch "ZPO" S. 29 ff.)'''
:::'''Titel 4. Ausschließung und Ablehnung der Gerichtspersonen'''
= § 41 Ausschluss von der Ausübung des Richteramtes. =
Ein Richter ist von der Ausübung des Richteramtes kraft Gesetzes ausgeschlossen; 1. in Sachen, in denen er selbst Partei ist oder bei denen er zu einer Partei in dem Verhältnis eines Mitberechtigten, Mitverpflichteten oder Regresspflichtigen steht;2. in Sachen eines Ehegatten, auch wenn die Ehe nicht mehr besteht; 2a. in Sachen seines Lebenspartners, auch wenn die Lebenspartnerschaft nicht mehr besteht. 3. in Sachen einer Person, mit der er in gerader Linie verwandt oder verschwägert, in der Seitenlinie bis zum dritten Grad verwandt oder bis zum zweiten Grad verschwägert ist oder war; 4. in Sachen, in denen er als Prozessbevollmächtigter oder Beistand einer Partei bestellt oder als gesetzlicher Vertreter einer Partei aufzutreten berechtigt ist oder gewesen ist; 5. in Sachen, in denen er als Zeuge oder Sachverständiger vernommen ist; 6. in Sachen, in denen er in einem früheren Rechtszug oder im schiedsrichterlichen Verfahren bei dem Erlass der angefochtenen Entscheidung mitgewirkt hat, sofern er sich nicht um die Tätigkeit eines beauftragten oder ersuchten Richters handelt; 7. in Sachen wegen überlanger Gerichtsverfahren, wenn er in dem beanstandeten Verfahren in einem Rechtszug mitgewirkt hat, auf dessen Dauer der Entschädigungsanspruch gestützt wird; 8. in Sachen, in denen er an einem Meditationsverfahren oder einem anderen Verfahren der außergerichtlichen Konlikbeilegung mitgewirkt hat.
= § 42 Ablehnung eines Richters. =
(1) Ein Richter kann sowohl in den Fällen, in denen er von der Ausübung des Richteramts kraft Gesetzes ausgeschlossen ist, als auch wegen Besorgnis der Befangenheit abgelehnt werden. (2) Wegen Besorgnis der Befangenheit findet die Ablehnung statt, wenn ein Grund vorliegt, der geeignet ist, Misstrauen gegen die Un parteilichkeit eines Richters zu rechtfertigen. (3) Das Ablehnungsrecht steht in jedem Fall beiden Parteien zu. '''(Quellinfo = Buch "ZPO" S. 29 ff.)'''
= § 43 Verlust des Ablehnungsrechts. =
Eine Partei kann einen Richter wegen Besorgnis der Befangenheit nicht mehr ablehnen, wenn sie sich bei ihm, ohne den ihr bekannten Ablehnungsgrund geltend zu machen, in eine Verhandlung eingelassen oder Anträge gestellt hat. '''(Quellinfo = Buch "ZPO" S. 31 ff.)'''
= § 44 Ablehnungsgesuch. =
(1) Das Ablehnungsgesuch ist bei dem Gericht, dem der Richter angehört, anzubringen; es kann vor der Geschäftsstelle zu Protokoll erklärt werden. (2)<sup>1</sup>Der Ablehnungsgrund ist glaubhaft zu machen, zur Versicherung an Eides statt darf die Partei nicht zugelassen werden. <sup>2</sup>Zur Glaubhaftmachung kann auf das Zeugnis des abgelehnten Richters Bezug genommen werden. (3) Der abgelehnte Richter hat sich über den Ablehnungsgrund dienstlich zu äußern. (4)<sup>1</sup>Wird ein Richter, bei dem die Partei sich in eine Verhandlung eingelassen oder Anträge gestellt hat, wegen Besorgnis der Befangenheit abgelehnt, so ist glaubhaft zu machen, dass der Ablehnungsgrund erst später entstanden oder der Partei bekannt geworden sei.<sup>2</sup>Das Ablehnungsgesuch ist unverzüglich anzubringen. '''(Quellinfo = Buch "ZPO" S. 31 ff.)'''
= § 45 Entscheidung über das Ablehnungsgesuch. =
(1)Über das Ablehnungsgesuch entscheidet das Gericht, dem der Abgelehnte angehört, ohne dessen Mitwirkung. (2)<sup>1</sup>Wird ein Richter beim Amtsgericht abgelehnt, so entscheidet ein anderer Richter des Amtsgerichts über das Gesuch.<sup>2</sup>Einer Entscheidung bedarf es nicht, wenn der abgelehnte Richter das Ablehnungsgesuch für begründet hält. (3)Wird das zur Entscheidung berufene Gericht durch Ausscheiden des abgelehnten Mitglieds beschlussunfähig, so entscheidet das im Rechtszug zunächst höhere Gericht. '''(Quellinfo = Buch "ZPO" S. 31 ff.)'''
= § 46 Entscheidung und Rechtsmittel. =
(1)Die Entscheidung über das Ablehnungsgesuch ergeht durch Beschluss. (2)Gegen den Beschluss, durch den das Gesuch für begründet erklärt wird findet kein Rechtsmittel, gegen den Beschluss, durch den das Gesuch für unbegründet erklärt wird, findet sofortige Beschwerde statt. '''(Quellinfo = Buch "ZPO" S. 31 ff.)'''
= § 47 Unaufschiebbare Amtshandlungen. =
(1) Ein abgelehnter Richter hat vor Erledigung des Ablehnungsgesuchs nur solche Handlungen vorzunehmen, die keinen Aufschub gestatten. (2)<sup>1</sup>Wird ein Richter während der Verhandlung abgelehnt und würde die Entscheidung über die Ablehnung eine Vertagung der Verhandlung erfordern, so kann der Termin unter Mitwirkung des abgelehnten Richters fortgesetzt werden.<sup>2</sup>Wird die Ablehnung für begründet erklärt, so ist der nach Anbringung des Ablehnungsgesuchs liegende Teil der Verhandlung zu wiederholen. '''(Quellinfo = Buch "ZPO" S. 31 ff.)'''
= § 48 Selbstablehnung: Ablehnung von Amts wegen. =
Das für die Erledigung eines Ablehnungsgesuchs zuständige Gericht hat auch dann zu entscheiden, wenn ein solches Gesuch nicht angebracht ist, ein Richter aber von einem Verhältnis Anzeige macht, das eine Ablehnung rechtfertigen könnte, oder wenn aus anderer Veranlassung Zweifel darüber entstehen, ob ein Richter kraft Gesetzes ausgeschlossen sei. '''(Quellinfo = Buch "ZPO" S. 31 ff.)'''
= § 49 Urkundsbeamte. =
Die Vorschriften dieses Titels sind auf den Urkundsbeamten der Geschäftsstelle entsprechend anzuwenden; die Entscheidung ergeht durch das Gericht, bei dem er angestellt ist.
:::::::'''Abschnitt 2 Parteien'''
::::'''Titel 1. Parteifähigkeit: Prozessfähigkeit'''
= § 50 Parteifähigkeit. =
(1) Parteifähig ist, wer rechtsfähig ist. (2) Ein Verein, der nicht rechtsfähig ist, kann klagen und verklagt werden; in dem Rechtsstreit hat der Verein die Stellung eines rechtsfähigen Vereins.
= § 51 Prozessfähigkeit; gesetzliche Vertretung; Prozessführung. =
(1) Die Fähigkeit einer Partei, vor Gericht zu stehen, die Vertretung nicht prozessfähiger Parteien durch andere Personen (gesetzliche Vertreter) und die Notwendigkeit einer besonderen Ermächtigung zur Prozessführung bestimmt sich nach den Vorschriften des bürgerlichen Rechts, soweit nicht die nachfolgenden Paragraphen abweichende Vorschriften enthalten. (2) Das Verschulden eines gesetzlichen Vertreters steht dem Verschulden der Partei gleich. (3) Hat eine nicht prozessfähige Partei, die eine volljährige natürliche Person ist, wirksam eine andere natürliche Person schriftlich mit ihrer gerichtlichen Vertretung bevollmächtigt, so steht diese Person einem gesetzlichen Vertreter gleich, wenn die Bevollmächtigung geeignet ist, gemäß '''''[''bis 31.12.2022:'''§ 1896 Abs. 2 Satz 2 des Bürgerlichen Gesetzbuchs'']''''' [ab 1.1.2023:''' ''§ 1814 Absatz 3 Satz 2 Nummer 1 des Bürgerlichen Gesetzbuchs''']''''' die Erforderlichkeit einer Betreuung entfallen zu lassen.
= § 52 Umfang der Prozessfähigkeit. =
(1)<sup>1</sup> Eine Person ist insoweit prozessfähig, als sie sich durch Verträge verpflichten kann
= § 53 Prozessfähigkeit bei Betreuung oder Pflegschaft. =
''[§ 53 bis 31.12.2022:]''
Wird in einem Rechtsstreit eine prozessfähige Person durch einen Betreuer oder Pfleger vertreten, so steht sie für den Rechtsstreit einer nicht prozessfähigen Person gleich.
= § 53 Prozessfähigkeit bei rechtlicher Betreuung. =
''[§ 53 ab 1.1.2023:]''
(2) Bei Personen, für die ein Betreuer bestellt ist, richtet sich die Prozessfähigkeit nach den allgemeinen Vorschriften.(2)<sup>1</sup>Wird ein Betreuer in einem Rechtsstreit durch einen Betreuer vertreten, kann der Betreuer in jeder Lage des Verfahrens gegenüber dem Prozessgericht schriftlich oder zu Protokoll der Geschäftsstelle erklären, dass der Rechtsstreit fortan ausschließlich durch ihn geführt wird (Ausschließlichkeitserklärung).<sup>2</sup>Mit Eingang der Ausschließlichkeitserklärung steht der Betreute für den weiteren Rechtsstreit einer nicht prozessfähigen Person gleich.<sup>3</sup>Der Betreuer kann die Ausschließlichkeitserklärung jederzeit mit Wirkung für die Zukunft zurücknehmen.
= § 53a =
(aufgehoben)
= § 54 Besondere Ermächtigung zu Prozesshandlungen. =
Einzelne Prozesshandlungen, zu denen nach den Vorschriften des bürgerlichen Rechts eine besondere Ermächtigung erforderlich ist, sind ohne sie gültig, wenn die Ermächtigung zur Prozessführung im Allgemeinen erteilt oder die Prozessführung auch ohne eine solche Ermächtigung im Allgemeinen statthaft ist. '''(Quellinfo = Buch "ZPO" S. 32 ff.)'''
= § 55 Prozessfähigkeit von Ausländern. =
Ein Ausländer, dem nach dem Recht seines Landes die Prozessfähigkeit mangelt, gilt als prozessfähig, wenn ihm nach dem Recht des Prozessgerichts die Prozessfähigkeit zusteht. '''(Quellinfo = Buch "ZPO" S. 33 ff.)'''
= § 56 Prüfung von Amts wegen. =
(1) Das Gericht hat den Mangel der Parteifähigkeit, der Prozessfähigkeit, der Legitimation eines gesetzlchen Vetreters und der erforderlichen Ermächtigung zur Prozessführung von Amts wegen zu berücksichtigen. '''(Quellinfo = Buch "ZPO" S. 33 ff.)'''
= § 57 Prozesspfleger. =
(1) Soll eine nicht prozessfähige Partei verklagt werden, die ohne gesetzlichen Vertreter ist, so hat ihr der Vorsitzende des Prozess-Eintritt des gesetzten Vertreters einen besonderen Vertreter zu bestellen.
'''(Quellinfo = Buch "ZPO" S. 33 ff.)'''
= § 58 Prozesspfleger bei herrenlosem Grundstück oder Schiff. =
(1) Soll ein Recht an einem Grundstück, das von dem bisherigen Eigentümer nach § 928 des Bürgerlichen Gesetzbuchs aufgegeben und von dem Aneignungsberechtigten noch nicht erworben worden ist,im Wege der Klage geltend gemacht werden, so hat der Vorsitzende des Prozessgerichts auf Antrag einen Vertreter zu bestellen, dem bis zur Eintragung eines neuen Eigentümers die Wahrnehmung, der sich aus dem Eigentum ergebenden Rechte und Verpflichtungen im Rechtsstreit obliegt. (2) Absatz 1 gilt entsprechend, wenn im Wege der Klage ein Recht an einem eingetragenen Schiff oder Schiffsbauwerk geltend gemacht werden soll, da von dem bisherigen Eigentümer nach § 7 des Gesetztes über Rechte an eingetragenen Schiffen und Schiffsbauwwerken vom 15. November 1940 (RGB1. IS. 1499) aufgegeben und von Aneignungsberechtigten noch nicht erworben worden ist. '''(Quellinfo = Buch "ZPO" S. 33 ff.)'''
:::'''Titel 2. Streitgenossenschaft'''
= § 59 Streitgenossenschaft bei Rechtsgemeinschaft oder Identität des Grundes. =
Mehrere Personen können als Streitgenossen gemeinschaftlich klagen oder verklagt werden, wenn Sie hinsichtlich des Streitgegenstandes in Rechtsgemeinschaft stehen oder wenn sie aus demselben tatsächlichen und rechtlichen Grund berechtigt oder verpflichtet sind.
= § 60 Streitgenossenschaft bei Gleichartigkeit der Ansprüche. =
Mehrere Personen können auch dann als Streitgenossen gemeinschaftlich klagen oder verklagt werden, wenn gleichartige und auf einem im Wesentlichen gleichartigen tatsächlichen und rechtlichen Grund beruhende Ansprüche oder Verpflichtungen. den Gegenstand des Rechtsstreits bilden. '''(Quellinfo = Buch "ZPO" S. 34 ff.)'''
= § 61 Wirkung der Streitgenossenschaft. =
Streitgenossen stehen, soweit nicht aus den Vorschriften des bürgerlichen Rechts oder dieses Gesetzes sich ein anderes egibt, dem Gegner dergestallt als Einzelne <sup>1)</sup> gegenüber, dass die Handlungen des einen Streitgenossen dem anderen weder zum Vorteil noch zum Nachteil gereichen. '''(Quellinfo = Buch "ZPO" S. 34 ff.)'''
= § 62 Notwendige Streitgenossenschaft. =
(1) Kann das streitige Rechtsverhäntlnis allen Streigenossen gegenüber nur einheitlich festgestellt werden oder werden, wenn ein Termin oder eine Frist nur von einzelnen Streitgenosen versäumt wird, die säumigen Steitgenossen als durch die nicht säumigen vertreten angesehen. (2) Die säumigen Streitgenossen ind auch in dem späteren Verfahren zuzuziehen. '''(Quellinfo = Buch "ZPO" S. 34 ff.)'''
= § 63 Prozessbetrieb; Ladungen. =
Das Recht zur Betreibung des Prozesses steht jedem Streitgenossen zu; zu allen Terminen sind sämtliche Streitgenossen zu laden: '''(Quellinfo = Buch "ZPO" S. 34 ff.)'''
:::'''Titel 3. Beteiligung Dritter am Rechtsstreit'''
= § 64 Hauptintervention. =
Wer die Sache oder das Recht, worüber zwischen anderen Personen ein Rechtsstreit anhängig geworden ist, ganz oder teilweise für sich in Anspruch nimmt, ist bis zur rechtskräftigen Entscheidung dieses Rechtsstreits berechtigt, seinen Anspruch durch eine gegen beide Parteien gerichtete Klage bei dem Gericht geltend zu machen, vor dem der Rechtsstreit im ersten Rechtszug anhängig wurde. '''(Quellinfo = Buch "ZPO" S. 34 ff.)'''
= § 65 Aussetzung des Hauptprozesses. =
Der Hauptprozess kann auf Antrag einer Partei bis zur rechtskräfigten Entscheidung über die Hauptintervention ausgesetzt werden. '''(Quellinfo = Buch "ZPO" S. 34 ff.)'''
= § 66 Nebenintervention. =
(1) Wer ein rechtliches Interesse daran hat, dass in einem zwischen anderen Personen anhängigen Rechtsstreit die eine Partei obsiege, kann dieser Partei zum Zwecke ihrer Unterstützung beitreten. (2) Die Nebenintervention kann in jeder Lage des Rechtsstreits bis zur rechtskräftigen Entscheidung auch in Verbindung mit der Einlegung eines Rechtsmittels, erfolgen. '''(Quellinfo = Buch "ZPO" S. 34 ff.)'''
= § 67 Rechtsstellung des Nebenintervenienten. =
<sup>1</sup>Der Nebenintervenient muss den Rechtsstreit in der Lage annehmen, in der er sich zur Zeit seinss Beitritts befindet; er ist berechtigt, Angriffs- und Verteidigungsmittel geltend zu machen und alle Prozeesshanduungen wirksam vorzunehmen, insoweit nicht seine Erklärungen und Handlungen mit Erklärungen und Handlungen der Hauptpartei in Widerspruch stehen. <sup>2</sup>Für ihn gelten die §§ 141 und 278 Absatz 3 entsprechend.
= § 68 Wirkung der Nebenintervention. =
Der Nebenintervenient wird im Verhältnis zu der Hauptpartpartei mit der Behauptung nicht gehört, dass der Rechtsstreit, wie er dem Richter vorgelegt habe, unrichtig entscheiden sei; er wird mit der Behauptung, das die Hauptpartei den Rechtsstreit mangelhaft geführt habe, nur insoweit gehört, als er durchh die Lage des Rechtsstreits zur Zeit seines Beitritts oder durch Erklärungen und Handlungen der Hauptpartei verhindert worden ist, Angriffs- oder Verteidigungsmittel geltend zu machen, oder als Angriffs- oder Verteidigungsmittel, die ihm unbekannt waren, von der Hauptpartei absichtlich oder durch grobes Verschulden nicht geltend gemacht sind.
= § 69 Streitgenössische Nebenintervention. =
Insofern nach den Vorschriften des bürgerliches Rechts die Rechtskraft der in dem Hauptprozess erlassenen Entscheidung auf das Rechtsverhältnis des Nebenintervenienten zu dem Gegner von Wirksamkeit ist, gilt der Nebenintervenient im Sinne des § 61 als Streitgenosse de Hauptpartei.
= § 70 Beitritt des Nebenintervenienten. =
(1) <sup>1</sup> Der Beitritt des Nebenintervenienten erfolgt durch Einreichung eines Schriftsatzes bei dem Prozessgericht und, wenn er mit der Einlegung eines Rechtsmitels verbunden wird, durch Einreichung eines Schriftsatzes bei dem Rechtsmittelgericht. <sup>2</sup> Der Schriftsatz ist beiden Parteien zuzustellen und muss enthalten:<br> 1. die Bezeichnung der Parteien und des Rechtssteireits; <br> 2. die bestimmte Angabe des Interesses, das der Nebenintervenient hat; <br>3. die Erklärung des Beitritts.
:(2) Außerdem gelten die allgemeinen Vorschriften über die vorbereitenden Schriftsätze. ''(Quellinfo = Buch "ZPO" S. 35 ff.)'''
= § 71 Zwischenstreit über Nebenintervention. =
(1)<sup>1</sup> Über den Antrag auf Zurückweisung einer Nebenintervention wird nach mündlicher Verhandlung unter den Parteien und dem Nebenintervenienten entschieden.<sup>2</sup> Der Nebenintervenient ist zuzulassen, wenn er sei Interesse glaubhaft macht.<br> (2) Gegen das Zwischenurteil findet sofortige Beschwerde statt.<br> (3) Solange nicht die Unzulässigkeit der Intervention rechtskräftig ausgesprochen ist, wird der Intervenient im Hauptverfahren zugezogen. ''(Quellinfo = Buch "ZPO" S. 35 ff.)'''
= § 72 Zulässigkeit der Streitverkündigung. =
(1) Eine Partei, die für den Fall des ihr ungünstigen Ausganges des Rechtsstreits einen Anspruch auf Gewährleistung oder Schadloshaltung gegen einen Dritten erheben zu können glaubt oder den Anspruch eines Dritten besorgt, kann bis zur rechtskräftigen Entscheidung des Rechtsstreits dem Dritten gerichtlich den Streit verkünden.<br> (2)<sup>1</sup> Das Gericht und ein vom Gericht ernannter Sachverständiger sind nicht Dritter im Sinne dieser Vorschrift. <sup>2</sup>§73 Satz 2 ist nicht anzuwenden.<br> (3) Der Dritte ist zu einer weiteren Streitverkündung berechtigt. '''(Quellinfo = Buch "ZPO" S. 35 ff.)'''
= § 73 Form der Streitverkündigung. =
<sup>1</sup>Zum Zwecke der Streitverkündung hat die Partei einen Schriftsatz einzureichen, in dem der Grund der Streitverkündung und die Lage des Rechtsstreits anzugeben ist. <sup>2</sup>Der Schriftsatz ist dem Dritten zuzustellen und dem Gegner des Streitverkünders in Abschrift mitzuteilen. <sup>3</sup>Die Streitverkündung wird erst mit der Zustellung an den Dritten wirksam.'''(Quellinfo = Buch "ZPO" S. 35 ff.)'''
= § 74 Wirkung der Streitverkündigung. =
(1) Wenn der Dritte dem Streitverkünder beitritt, so bestimmt sich sein Verhältnis zu den Parteien nach den Grundsätzen über die Nebenintervention. <br> (2) Lehnt der Dritte den Beitritt ab oder erklärt er sich nicht, so wird der Rechtsstreit ohne Rücksicht auf ihn fortgesetzt. <br> (3) In allen Fällen dieses Paragraphen sind gegen den Dritten die Vorschriften des § 68 mit der Abweichung anzuwenden, dass statt der Zeit des Beitritts die Zeit entscheidet, zu welcher der Beitritt infolge der Streitverkündung möglich war. '''(Quellinfo = Buch "ZPO" S. 36 ff.)'''
= § 75 Gläubigerstreit. =
<sup>1</sup>Wird von dem verklagten Schuldner einem Dritten, der die geltend gemachte Forderung für sich in Anspruch nimmt, der Streit verkündet und tritt der Dritte in den Streit ein, so ist der Beklagte, wenn er den Betrag der Forderung zugunsten der streitenden Gläubiger unter Verzicht auf das Recht zur Rücknahme hinterlegt, auf seinen Antrag aus dem Rechtsstreit unter Verurteilung in die durch seinen unbegründeten Widerspruch veranlassten Kosten zu entlassen und der Rechtsstreit über die Berechtigung an der Forderung zwischen den streitenden Gläubigern allein fortzusetzen.<sup>2</sup>Dem Obsiegenden ist der hinterlegte Betrag zuzusprechen und der Unterliegende auch zur Erstattung der dem Beklagten entstandenen, nicht durch dessen unbegründeten Widerspruch veranlassten Kosten, einschließlich der Kosten der Hinterlegung zu verurteilen.
= § 76 Urheberbenennung bei Besitz. =
(1)<sup>1</sup>Wer als Besitzer einer Sache verklagt ist, die er auf Grund eines Rechtsverhältnisse der im § 868 des Bürgerlichen Gesetzbuchs bezeichneten Art zu besitzen behauptet, kann vor der Verhandlung zur Hauptsache unter Einreichung eines Schriftsatzes, in dem er den mittelbaren Besitzer benennt, und einer Streiverkündigungsschrift die Ladung des mittelbaren Besitzers zur Erklärung beantragen.<sup>2</sup> Bis zu dieser Erklärung oder bis zum Schluss des Termins, in dem sich der Benannte zu erklären hat, kann der Beklagte die Verhandlung zur Hauptsache verweigern. <br> (2) Bestreitet der Benannte die Behauptung des Beklagten oder erklärt er sich nicht, so ist der Beklagte berechtigt, dem Klageantrage zu genügen. <br> (3)<sup>1</sup>Wird die Behauptung des Beklagten von dem Benannten als richtig anerkannt, so ist dieser berechtigt, mit Zustimmung des Beklagten an dessen Stelle zu übernehmen.<sup>2</sup>Die Zustimmung des Klägers ist nur insoweit erforderlich, als er Ansprüche geltend macht, die unabhängig davon sind, dass der Beklagte auf Grund eines Rechtsverhältnisses der im Absatz 1 bezeichneten Art besitzt.<br>(4)<sup>1</sup>Hat der Benannte den Prozess übernommen, so ist der Beklagte auf seinen Antrag von der Klage zu entbinden.<sup>2</sup>Die Entscheidung ist in Ansehung der Sache selbst auch gegen den Beklagten wirksam und vollstreckbar.
= § 77 Urheberbenennung bei Eingentumsbeeinträchtigung. =
Ist von dem Eigentümer einer Sache oder von demjenigen, dem ein Recht an einer Sache zusteht, wegen einer Beeinträchtigung des Eigentums oder seines Rechts Klage auf Beseitigung der Beeinträchtigung oder auf Unterlassung weiter Beeinträchtigungen erhoben, so sind die Vorschriften des § 76 entsprechend an eines Dritten vorgenommen zu haben behauptet.
= § 78 Anwaltsprozess. =
= § 78a =
(weggefallen)
= § 78b Notanwalt. =
(1) Insoweit eine Vertretung durch Anwälte geboten ist, hat das Prozessgericht einer Partei auf ihren Antrag durch Beschluss für den Rechtszug einen Rechtsanwalt zur Wahrnehmung ihrer Rechte beizuordnen, wenn sie einen zu ihrer Vertretung bereiten Rechtsanwalt nicht findet und die Rechtsverfolgung oder Rechtsverteidigung nicht mutwillig oder aussichtslos erscheint. (2) Gegen den Beschluss, durch den die Beiordnung eines Rechtsanwalts abgelehnt wird, findet die sofortige Beschwerde statt.
= § 78c Auswahl des Rechtsanwalts. =
= § 79 Parteiprozess. =
= § 80 Prozessvollmacht. =
<sup>1</sup>Die Vollmacht ist schriftlich zu den Gerichtsakten einzureichen. <sup>2</sup>Sie kann nachgereicht werden; hierfür kann das Gericht eine Frist bestimmen.
= § 81 Umfang der Prozessvollmacht. =
= § 82 Geltung für Nebenverfahren. =
Die Vollmacht für den Hauptprozess umfasst die Vollmacht für das eine Hautintervention, einen Arrest oder eine einstweilige Verfügung betreffende Verfahren. '''(Quellinfo = Buch "ZPO" S. 39 ff.)'''
= § 83 Beschränkung der Prozessvollmacht. =
= § 84 Mehrere Prozessbevollmächtigte. =
<sup>1</sup>Mehrere Bevollmächtigte sind berechtigt, sowohl gemeinschaftlich als einzeln die Partei zu vertreten. <sup>2</sup>Eine abweichende Bestimmung der Vollmacht hat dem Gegner gegenüber keine rechtliche Wirkung
= § 85 Wirkung der Prozessvollmacht. =
= § 86 Fortbestand der Prozessvollmacht. =
= § 87 Erlöschen der Vollmacht. =
= § 88 Mangel der Vollmacht. =
= § 89 Vollmachtloser Vertreter. =
= § 90 Beistand. =
::::::::::::: '''Titel 5 Prozesskosten'''
= § 91 Grundsatz und Umfang der Kostenpflicht. =
= § 91a Kosten bei Erledigung der Hauptsache. =
= § 92 Kosten bei teilweisem Obsiegen. =
= § 93 Kosten bei sofortigem Anerkenntnis. =
= § 93a =
(aufgehoben)
= § 93b Kosten bei Räumungsklagen. =
= § 93c, 93d =
= § 94 Kosten bei übergegangenem Anspruch. =
= § 95 Kosten bei Säumnis oder Verschulden. =
= § 96 Kosten erfolgloser Angriff- oder Verteidigungsmittel. =
= § 97 Rechtsmittelkosten. =
= § 98 Vergleichtskosten. =
= § 99 Anfechtung von Kostenentscheidungen. =
= § 100 Kosten bei Streitgenossen. =
= § 101 Kosten einer Nebenintervention. =
= § 102 =
(weggefallen)
= § 103 Kostenfestsetzungsgrundlage: Kostenfestsetzungsantrag. =
= § 104 Kostenfestsetzungsverfahren =
= § 105 Vereinfachter Kostenfestsetzungsbeschluss. =
= § 106 Verteilung nach Quoten. =
= § 107 Änderung nach Streitwertfestsetzung. =
(1)<sup>1</sup> Ergeht nach der Kostenfestsezung eine Entscheidung, durch die der Wert des Streitgegenstandes festgesetzt wird, so ist, falls diese Entscheidung von der Wertberechnung abweicht, die der Kostenfestsetzung zugrunde liegt, auf Antrag die Kostengestsetzung entsprechend abzuändern.<sup>2</sup>Über den Antrag entscheidet das Gericht des ersten Rechtszuges. (2) <sup>1</sup> Der Antrag ist binnen der Frist von einem Monat bei der Geschäftsstelle anzubringen. <sup>2</sup>Die Frist beginnt mit der Zustellung und wenn es einer solchen nicht bedarf, mit der Verkündung des den Wert des Streitgegenstandes festsetzenden Beschlusses. (3) Die Vorschriften des § 104 Abs. 3 sind anzuwenden.'''(Quellinfo = Buch "ZPO" S. 45 ff.)'''
= § 108 Art und Höhe der Sicherheit. =
= § 109 Rückgabe der Sicherheit. =
= § 110<sup>1)</sup> Prozesskostensiocherheit. =
= § 111 Nachträgliche Prozesskostensicherheit. =
= § 112 Höhe der Prozesskostensicherheit. =
= § 113 Fristbestimmung für Prouesskostensicherheit. =
(1) <sup>1</sup>Das Gericht hat dem Kläger bei Anordnung der Sicherheitsleistung eine Frist zu bestimmen, binnen der die Sicherheit zu leisten ist. <sup>2</sup>Nach Ablauf der Frist ist auf Antrag des Beklagten, wenn die Sicherheit bis zur Entscheidung nicht geleistet ist. die Klage für zurückgenommen zu erklären oder, wenn über ein Rechtsmittel des Klägers zu verhandeln ist, dieses zu verwerfen.
::::::::::::: '''Titel 7 Prozesskostenhilfe<sup>1</sup> und Prozesskostenvorschuss'''
= § 115 Einsatz von Einkommen und Vermögen. =
(1) <sup>1</sup>Die Partei hat ihr Einkommen einzusetzen. <sup>2</sup>Zum Einkommen gehören alle Einkünfte in Geld oder Geldwert. <sup>3</sup>Von ihm sin abzusetzen: 1. a) die in §82 Abs. 2 des Zwölften Buches Sozialgesetzbuch<sup>2)</sup>bezeichneten Beträge: '''(Quellinfo = Buch "ZPO" S. 46 ff.)'''
=____________________________________________________________________=
<sup>1</sup>Vgl. Art. 220 bis 24 Haager Übereinkommen über den Zivilprozess v. 1.3.1954 (BGB1. 1958 II S 576, 577). Siehe ferner § 11 G über die Rechtsstellung heimatloser Ausländer im Bundesgebiet v. 25.4.1951 (BGB1 I.S. 269), zuletzt geänd. durch G v. 30.7.2004 (BGB1. I S. 1950) und für Mitglieder der in der Bundesrepublik stationierten ausländischen Truppen. vgl. Art. 31 Zusatzabkommen zum NATO-Truppenstatut v. 3.8.1959 (BGB1. 1961 II S. 1218), zuletzt geändert. durch Abk. v. 28.9.1994 (BGB1. II S. 2598).
<sup>2</sup>§ 82 Abs. 2 und 3 des Zwölften Buches Sozialgesetzbuch v. 27.12.2003 (BGB1, I S. 3022, 3023),"(2)<sup>1</sup>Von dem Einkommen sind abzusetzen <br> 1. auf die Einkommen entrichtete Steuern. <br> 2. Pflichtbeiträge zur Sozialversicherung einschließlich der Beiträge zur Arbeitsförderung. →</br>
(Fortsetzung der Anm. von voriger Seite)<br>
3. Beiträge zu öffentlichen oder privaten Versicherungen oder ähnlichen Einrichtungen, soweit diese Beiträge gesetzlich vorgeschrieben oder nach #grund und Höhe angemessen sind, sowie geförderte Altersvorsorgeverträge nach § 82 des Einkommensteuergesetzes, soweit sie den Mindeststeigenbetrag nach § 86 des Einkommensteuergesetzes nicht überschreiten, und <br>4. die mit der Erzielen des Einkommens verbundenen notwendigen Ausgaben.<br><sup>2</sup>Erhält eine leistungsberechtigte Person aus einer Tätigkeit Bezüge oder Einnahmen, die nach § 3 Nummer 12,26, 26a oder 26b des Einkommensteuergesetzes steuerfrei sind oder die als Taschengeld Jugendfreiwilligendienstegesetzes gezahlt werden, ist abweichend von Satz 1 Nummer 2 bis 4 und den Absätzen 3 und 6 ein Betrag von bis zu 250 Euro monatlich nicht als Einkommen zu berücksichtigen.<br><sup>3></sup>Soweit ein Betrag nach Satz 2 in Anspruch genommen wird, gelten die Beträge nach Absatz 3 Satz 1 zweiter Halbsatz und nach Absatz 6 Satz 1 zweiter Halbsatz insoweit als ausgeschöpft. <br>(3)<sup>1</sup>Bei der Hilfe zum Lebensunterhalt und Grundsicherung im Alter und bei Erwerbsminderung ist ferner ein Betrag in Höhe von 30 vom Hundert des Einkommens aus selbständiger und nichtselbständiger Tätigkeit der Leistungsberechtigten abzusetzen, höchstens jedoch 50 vom Hundert der Regelbedarfsstufe 1 nach der Anlage zu § 28. <sup>2</sup>Abweichend von Satz 1 ist bei einer Beschäftigung in einer Werkstatt für behinderte Menschen oder bei einem anderen Leistungsanbieter nach § 60 des Neunten Buches v. 23.12.2016 (BGB1. I S. 3234), zuletzt geändert. durch G. v 16.6.2021 (BGB1. I S. 1810) von dem Entgelt ein Achtel der Regelbedarfsstufe 1 nach der Anlage zu § 28 zuzüglich 50 vom Hundert des diesen Betrag übersteigenden Entgelts abzusetzen. <sup>3</sup>Im Übrigen kann in begründeten Fällen ein anderer als in Satz 1 festgelegter Betrag vom Einkommen abgesetzt werden."
Abschnitt 2. Parteien <br><br>
b) bei Parteien, die ein Einkommen aus Erwerbstätigkeit erzielen, ein Betrag in Höhe von 50 vom Hundert des Regelsatzes für den alleinstehenden oder alleinerziehenden Leistungsberechtigten vom Bund gemäß der Regelbedarfsstufe 1 nach der Anlage zu § 28 des Zwölften Buches Sozialgesetzbuch festgesetzt oder fortgeschrieben worden ist.<br>
2 a.) für die Partei und ihren Ehegatten oder ihren Lebenspartner jeweils ein Betrag in Höhe des um 10 vom Hundert erhöhten Regelsatzes, der für den alleinstehenden oder Alleinerziehenden Leistungsberechtigten vom Bund gemäß der Regelbedarsstufe 1 nach der Anlage zu § 28 des Zwölften Buches Sozialgesetzbuch festgesetzt oder fortgeschrieben worden ist;<br>
b) bei weiteren Unterhaltsleistungen auf Grund gesetzlicher Unterhaltspflicht für jede unterhaltsberechtigte Person jeweils ein Betrag in Höhe des um 10 vom Hundert erhöhten Regelsatzes, der für eine Person ihres Alters vom Bund gemäß den Regelbedarfsstufen 3 bis 6 nach der Anlage zu § 28 des Zwölften Buches Sozialgesetzbuch festgesetzt oder fortgeschrieben worden ist;<br>
3. die Kosten der Unterkunft und Heizung, soweit sie nicht in einem auffälligen Missverhältnis zu den Lebensverhältnissen der Partei stehen;<br>
4. Mehrbedarfe nach § 21 des Zweiten Buches Sozialgesetzbuch und nach § 30 des Zwölften Buches Sozialgesetzbuch; <br>
5. weitere Beträg, soweit dies mit Rücksicht auf besondere Belastungen angemessen ist; § 1610a dass Bürgerlichen Gesetzbuchs gilt entsprechend.<br></br>
<sup>4</sup>Maßgeblich sind die Beträge, die zum Zeitpunkt der Bewilligung der Prozesskostenhilfe gelten.<aup>5</sup>Soweit am Wohnsitz der Partei aufgrund einer Neufestsetzung oder jeder Fortschreibung nach § 20 Absatz 2 bis 4 des Zwölften Buches Sozialgesetzbuch höhere Regelsätze gelten, sind diese heranzuziehen. <sup>6</sup>Das Bundesministerium der Justiz und für Verberbraucherschutz gibt bei jeder Neufestsetzung oder jeder Fortschreibung die maßgebenden Beträge nach Satz 3 Nummer 1 Buchstabe b und Nummer 2 und nach Satz 5 im Bundesgesetzblatt bekannt. <sup>'''1)'''</sup> <sup>7</sup>Diese Beträge sind, soweit sie nicht volle Euro ergeben, bis zu 0,49 Euro abzurunden und von 0,50 Euro an aufzurunden. <sup>8</sup>Die Unterhaltsfreibeträge nach Satz 3 Nr. 2 vermindern sich um eigenes Einkommen der Unterhaltsberechtigten Person.<sup>9</sup>Wird eine Geldrente gezahlt, so ist sie anstelle des Freibetrages abzusetzen, soweit dies angemessen ist.
(2)<sup>1</sup>Von dem nach Abzügen verbleibenden Teil des monatlichen Einkommens (einzusetzendes Einkommen) sind Monatsraten in Höhe der Hälfte des einzusetzenden Einkommens festzusetzen; die Monatsraten sind auf volle Euro abzurunden. <sup>2</sup>Beträgt die Höhe einer Monatsrate weniger als 10 Euro, ist von der Festsetzung der Monatsraten abzusehen.<sup>3</sup>Bei einem einzusetzenden Einkommen von mehr als 600 Euro beträgt die Monatsrate 300 Euro zuzüglich des Teils des einzusetzenden Einkommens, der 600 Euro übersteigt.<sup>4</sup>Unabhängig von der Zahl der Rechtszüge sind höchstens 48 Monatsraten aufzubringen. (3)<sup>1</sup>Die Partei hat ihr Vermögen einzusetzen, soweit dies zumutbar ist. <sup>2</sup>§9 des Zwölften Buches Sozialgesetzbuch gilt entsprechend.(4) Prozesskostenhilfe wird nicht bewilligt, wenn die Kosten der Prozessführung der Partei vier Monatsraten und die aus dem Vermögen aufzubringenden Teilbeträge voraussichtlich nicht übersteigen.
=____________________________________________________________________=
{| class="wikitable" style="text-align: center; color: black;"
|
|Freibetrag <br> Bund <br></br>
|Freibetrag in <br>den Land-<br>kreisen Fürs-<br>tenfeldbruck<br>und<br>Starn-<br>berg</br>
|Freibetrag im <br>Landkreis<br>München<br>
|Freibetrag in <br>der Landes-<br>hauptstadt<br>München<br>
|-
|Parteien, die ein Einkommen aus Er-<br> werbtätigkeit erzielen (§ 115 Absatz 1 <br> Satz 3 Nummer 1 Buchstabe b der <br> Zivilprozessordnung)
|223 Euro
|235 Euro
|235 Euro
|234 Euro
|-
|Partei, Ehegatte oder Lebenspartner<br> (§ 115 Absatz 1 Satz 3 Nummer 2 <br> Buchstabe a der Zivilprozessverordnung) </br>
|491 Euro
|516 Euro
|517 Euro
|515 Euro
|-
|Freibetrag der unterhaltsberechtigte Er-<br> wachsene (§ 115 Absatz 1 Satz 3 Num- <br> mer 2 Buchstabe b der Zivilprozessord-<br> nungRegelbedarfsstufe 3) </br>
|393 Euro
|414 Euro
|414 Euro
|411 Euro
|-
|Freibetrag für unterhaltsberechtigte Ju- <br> endliche vom Beginn des 15. bis zur <br> Vollendung des 18. Lebensjahres (§ 115 <br> Absatz 1 Satz 3 Nummer 2 Buchstabe <br> b der Zivilprozessordnung Regelte- <br> darfstufe 4) </br>
|410 Euro
|430 Euro
|432 Euro
|429 Euro
|-
|Freibetrag für unterhaltsberechtigte <br> Kinder vom Beginn des siebten bis zur <br> Vollendung des 14. Lebensjahres (§ 115 <br> Absatz 1 Satz 3 Nummer 2 Buchstabe<br> b der Zivilprozessordnung Regel- <br> darfstufe 5) </br>
|340 Euro
|353 Euro
|359 Euro
|353 Euro
|-
|Freibetrag für unterhaltsberechtigte <br> Kinder bis zur Vollendung des sechsten <br> Lebensjahres (§ 115 Absatz 1 Satz 3<br>Nummer 2 Buchstabe b der Zivilpro- <br> zessordnung Regelbedarfsstufe 6) </br>
|311 Euro
|325 Euro
|328 Euro
|323 Euro"
|-
|}
= § 116 Partei kraft Amtes: juristische Person; parteifähige Vereinigung. =
<sup>1</sup> Prozesskostenhilfe erhalten auf Antrag 1. eine Partei kraft Amtes, wenn die Kosten aus der verwalteten Vermögensmasse nicht aufgebracht werden können und den am Gegenstand des Rechtsstreite wirtschaftlich Beteiligten nicht zuzumuten ist, die Kosten aufzubringen; 2. eine juristische Person oder parteifähige Vereinigung, die im Inland, in einem anderen Mitgliedstaat der Europäischen Union oder einem anderen Vertragsstaates des Abkommens über den Europäischen Wirtschaftsraum gegründet und dort ansässig ist, wenn die Kosten weder von ihr noch von den am Gegenstand des Rechtsstreits wirtschaftlich Beteiligten aufgebracht werden können und wenn die Unterlassung der Rechtsverfolgung oder Rechtsverteidigung allgemeinen Interessen zuwiderlaufen würde.
<sup>2</sup>§ 114 Absatz 1 Satz 1 letzter Halbsatz und Absatz 2 ist anzuwenden. <sup>3</sup> Können die Kosten nur zum Teil oder nur in Teilbeträgen aufgebracht werden, so sind die entsprechenden Beträge zu zahlen.
= § 117 Antrag. =
(1)<sup>1</sup>Der Antrag auf Bewilligung der Prozesskostenhilfe ist bei dem Prozessgericht zu stellen; er kann vor der Geschäftsstelle zu Protokoll erklärt werden. <sup>2</sup>In dem Antrag ist das Streitverhältnis unter Angabe der Beweismittel darzustellen. <sup>3</sup>Der Antrag auf Bewilligung von Prozesskostenhilfe für die Zwangsvollstreckung ist bei dem für die Zwangsvollstreckung zuständigen Gericht zu stellen.<br>(2)<sup>1</sup>Dem Antrag sind eine Erklärung der Partei über ihre persönlichen und wirtschaftlichen Verhältnisse (Familienverhältnisse, Beruf , Vermögen , Einkommen und Lasten) sowie entsprechende Belege beizufügen. <sup>2</sup>Die Erklärung und die Belege dürfen dem Gegner nur it Zustimmung der Partei zugänglich gemacht werden<sup>1)</sup>es sei denn, der Gegner hat gegen den Antragsteller nach den Vorschriften des bürgerlichen Rechts einen Anspruch auf Auskunft über Einkünfte und Vermögen des Antragstellers.<sup>3</sup>Dem Antragsteller ist vor der Übermittlung seiner Erklärung an den Gegner Gelegenheit zur Stellungnahme zu geben.<sup>4</sup>Er ist über die Übermittlung seiner Erklärung zu unterrichten.<br>(3)<sup>1</sup>Das Bundesministerium der Justiz und für Verbraucherschutz wird ermächtigt, zur Vereinfachung und Vereinheitlichung des Verfahrens durch Rechtsverordnung
<sup>2)</sup>mit Zustimmung des BundesratesFormulare für die Erklärung einzuführen.<sup>2</sup>die Formulare enthalten nach § 120a Absatz 2 Satz 4 erforderliche Belehrung.<br>(4)Soweit Formulare für die Erklärung eingeführt sind, muss sich die Partei ihrer bedienen.</br>
<sup>1)</sup>Zeichensetzung amtlich.<br>
<sup>2)</sup>Siehe die Prozesskostenhilfeformularverordnung - PKHFV v. 6.1.2014 (BGB1. I S. 34).</br>
= § 118 Bewilligungsverfahren. =
::Text folgt noch.
= § 119 Bewilligung. =
= § 120<sup>1</sup> Festsetzung von Zahlungen.=
= § 120a<sup>1</sup> Änderung der Bewilligung.=
= § 121 Beiordnung eines Rechtsanwalts.=
= § 122 Wirkung der Prozesskostenhilfe.=
= § 123 Kostenerstattung. =
Die Bewilligung der Prozesskostenhilfe hat auf die Verpflichtung, die dem Gegner entstandenen Kosten zur erstatten, keinen Einfluß.
= § 124 Aufhebung der Bewilligung.=
= § 125 Einziehung der Kosten. =
(1) Die Gerichtskosten und die Gerichtsvollzieherkosten können von dem Gegner erst eingezogen werden, wenn er rechtskräftig in die Prozesskosten verurteilt ist. (2) Die Gerichtskosten, vo deren Zahlung der Gegner einstweilen befreit ist, sind von ihm einzuziehen, soweit er rechtskräftig in die Prozesskosten verurteilt oder der Rechtsstreit ohne Urteil über die Kosten beendet ist.
= § 126 Beitreibung der Rechtsanwalskosten.=
= § 127 Entscheidungen.=
= § 140 Beanstanstandung von Prozessleitung oder Fragen. =
Wird eine auf die Sachleitung bezügliche Anordnung des Vorsitzenden oder eine von dem Vorsitzenden oder einem Gerichtsmitglied gestellte Frage von einer bei der Verhandlung beteiligten Person als unzulässig beanstandet, so entscheidet das Gericht
= § 141 Anordnung des persönlichen Erscheinens. =
(1) <sup>1</sup>Das Gericht soll das persönliche Erscheinen beider Parteien anordnen, wenn dies zur Aufklärung des Sachverhalts geboten erscheint. <sup>2</sup>Ist einer Partei wegen großer Entfernung oder aus sonstigem wichtigen Grund die persönliche Wahrnehmung des Termins nicht zuzumuten, so sieht das Gericht von der Anordnung ihres Erscheinens ab. (2)<sup>1</sup>Wird das Erscheinen angeordnet, so ist die Partei von Amts wegen zu laden. <sup>2</sup>Die Ladung ist der Partei selbst mitzuteilen, auch wenn sie einen Prozessbevollmächtigte bestellt hat; der Zustellung bedarf die Ladung nicht.(3)<sup>1</sup>Bleibt die Partei im Termin aus, so kann gegen sie Ordnungsgeld wie gegen einen im Vernehmungstermin nicht erschienen Zeugen festgesetzt werden. <sup>2</sup>Dies gilt nicht, wenn die Partei zur Verhandlung einen Vertreter entsendet, der zur Aufklärung des Tatbestandes in der Lage und zur Abgabe der gebotenen Erklärungen, insbesondere zu einem Vergleichsabschluss ermächtigt ist. <sup>3</sup>Die Partei ist auf die Folgen ihres Ausbleibens in der Ladung hinzuweisen
= § 184 Zustellungsbevollmächtigter; Zustellung durch Aufgabe zur Post. =
::Text folgt noch!
= § 185 Öffentliche Zustellung. =
Die Zustellung kann durch öffentliche Bekanntmachung (öffentliche Zustellung) erfolgen, wenn <br>1. der Aufenthaltsort einer Person unbekannt und eine Zustellung an einen Vertreter oder Zustellungsbevollmächtigten nicht möglich ist,</br> 2. bei juristischen Personen, die zur Anmeldung einer inländischen Geschäftsanschrift zum Handelsregister verpflichtet sind, eine Zustellung weder unter der eingetragenen Anschrift noch unter einer im Handelsregister eingetragenen Anschrift einer für Zustellungen empfangsberichtigten Person oder einer hohen Ermittlungen bekannten anderen inländischen Anschrift möglich ist. <br>3. eine Zustellung im Ausland nicht möglich ist oder keinen Erfolg verspricht oder </br>4. die Zustellung nicht erfolgen kann, weil der Ort der Zustellung die Wohnung einer Person ist, die nach den §§ 18 bis 20 des Gerichtsverfassungsgesetzes <sup>2)</sup> der Gerichtsbarkeit nicht unterliegt.
= § 186 Bewilligung und Ausführung der öffentlichen Zustellung. =
(1)<sup>1</sup>Über die Bewilligung der öffentlichen Zustellung entscheidet das Prozessgericht. <sup>2</sup> Die Entscheidung kann ohne mündliche Verhandlung ergehen.<br>(2)<sup>1</sup> Die öffentlichen Zustellung erfolgt durch Aushang einer Benachrichtigung an der Gerichtstafel oder durch Einstellung in ein elektronisches Informationssystem, das im Gericht öffentlich zugänglich ist <sup>2</sup> Die Benachrichtigung kann zusätzlich in einem von dem Gericht für Bekanntmachungen bestimmten elektronischen Informations- und Kommunikationssystem veröffentlicht werden. <sup>3</sup> Die Benachrichtigung muss erkennen lassen<br>1.die Person für die zugestellt wird.</br>3. das Datum, das Aktenzeichen des Schriftstücks und die Bezeichnung des Prozessgegenstandes sowie <br>4. die Stelle, wo das Schriftstück eingesehen werden kann.</br><sup>4</sup>Die Benachrichtigung muss den Hinweis enthalten, dass ein Schriftstück öffentlich zugestellt wird und Fristen in Gang gesetzt werden können, nach deren Ablauf Rechtsverluste drohen können. <sup>5</sup> Bei der Zustellung einer Ladung muss die Benachrichtigung den Hinweis enthalten, dass das Schrifstück eine Ladung zu einem Termin enthält, dessen Versäumung Rechtsnachteile zur Folgen haben kann.<br>(3)In den Akten ist zu vermerken, wann die Benachrichtigung ausgehängt und wann sie abgenommen wurde.
= § 307 Anerkenntnis. =
<sup>1</sup>Erkennt eine Partei den gegen sie geltend gemachten Anspruch ganz oder zum Teil an, so ist sie dem Anerkenntnis gemäß zu verurteilen.<sup>2</sup>Einer mündlichen Verhandlung bedarf es insoweit nicht.
= § 309 Erkennende Richter. =
Das Urteil kann nur von denjenigen Richtern gefällt werden, welche der dem Urteil zugrunde liegenden Verhandlungen beigewohnt haben.
= § 589 (ZPO) Zulässigkeitsprüfung =
= § 590 (ZPO) Neue Verhandlung =
= § 591 (ZPO) Rechtsmittel =
:'''Buch 5. Urkunden- und Wechselprozess'''
= § 592 (ZPO) Zulässigkeit. =
1 Ein Anspruch, welcher die Zahlung einer bestimmten Geldsumme oder die Leistung einer bestimmten Menge anderer vertretbarer Sachen oder Wertpapiere zum Gegenstand hat, kann im Urkundenprozess geltend gemacht werden, wenn die sämtlichen zur Begründung des Anspruchs erfolgreichen Tatsachen durch Urkunden bewiesen werden können. 2 Als ein Anspruch, welcher die Zahlung einer Geldsumme zum Gegenstand hat, gilt auch der Anspruch aus einer Hypothek, einer Grundschuld, einer Rentenschuld oder einer Schiffshypothek. '''(Quellinfo = Buch "ZPO" S. 155 ff.)'''
= § 593 (ZPO) Klageinhalt: Urkunden. =
(1) Die Klage muss die Erklärung enthalten, dass im Urkundenprozess geklagt werde. (2) 1 Die Urkunden müssen in Abschrift der Klage oder einem vorbereitenden Schriftsatz beigefügt werden. 2 Im letzteren Fall muss zwischen der Zustellung des Schriftsätze und dem Termin zur mündlichen Verhandlung ein der Einlassungfrist gleicher Zeitraum liegen. '''(Quellinfo = Buch "ZPO" S. 155 ff.)'''
= § 594 (ZPO) (weggefallen) =
'''(Quellinfo = Buch "ZPO" S. 156 ff.)'''
= § 595 (ZPO) Keine Widerklage; Beweismittel. =
(1) Widerklangen sind nicht statthaft. (2) Als Beweismittel sind bezüglich der Echtheit oder Unechtheit einer Urkunde sowie bezüglich anderer als der im § 592 erwähnten Tatsachen nur Urkunden und Antrag auf Parteivernehmung zulässig. (3) Der Urkundenbeweis kann nur durch Vorlegung der Urkunden angetreten werdenden.
'''(Quellinfo = Buch "ZPO" S. 156 ff.)'''
= § 596 (ZPO) Abstehen vom Urkundenprozess. =
Der Kläger kann, ohne dass es der Einwilligiung des Beklagten bedarf, bis zum Schluss der mündlichen Verhandlung von dem Urkundenprozess in der Weise abstehen, dass der Rechtsstreit im ordentlichen Verfahren anhängig bleibt. '''(Quellinfo = Buch "ZPO" S. 156 ff.)'''
= § 597 (ZPO) Klageabweisung =
(1) Insoweit der in der Klage geltend gemachte Anspruch an sich oder infolge einer Einrede des Beklagten als unbegründet sich darstellt, ist der Kläger mit dem Anspruch abzuweisen. (2) Ist der Urkundenprozess unstatthaft, ist insbesondere ein dem Kläger obliegender Beweis nicht mit den im Urkundenprozess zulässigen Beweismitteln angetreten oder mit solchen Beweismitteln nicht vollständig geführt, so wird die Klage als in der gewählten Prozessart unstatthaft abgewiesen, selbst wenn in dem Termin zur mündlichen Verhandlung der Beklagte nicht erschienen ist oder der Klage nur auf Grund von Einwendungen widersprochen hat, die rechtlich unbegründet oder im Urkundenprozess unstatthaft sind. '''(Quellinfo = Buch "ZPO" S. 157 ff.)'''
= § 598 (ZPO) Zurückweisung von Einwendungen =
Einwendungen des Beklagten sind, wenn der dem Beklagten obliegende Beweis nicht mit den im Urkundenprozess zulässigen Beweismitteln angetreten oder mit solchen Beweismitteln nicht vollständig geführt ist, als im Urkundenprozess unstatthaft zurückzuweisen. '''(Quellinfo = Buch "ZPO" S. 157 ff.)'''
= § 599 (ZPO) Vorbehaltsurteil =
(2) Dem Beklagten, welcher dem geltend gemachten Anspruch widersprochen hat, ist in allen Fällen, in denen er verurteilt wird, die Ausführung seiner Rechte vorzubehalten. (2) Enthält das Urteil keinen Vorbehalt so kann die Ergnuzugn des Urteils nach der Vorschrift des § 321 beantragt werden. (3) Das Urteil, das unter Vorbehalt der Rechte ergeht, ist für die Rechtsmittel und die Zwangsvollstreckung als Endurteil anzusehen. '''(Quellinfo = Buch "ZPO" S. 157 ff.)'''
= § 600 (ZPO) Nachverfahren. =
(1) Wird dem Beklagten die Ausführung seiner Rechte vorbehalten, so bleibt der Rechtsstreit im ordentlichen Verfahren anhängig. (2) Soweit sich in diesem Verfahren ergibt, dass der Anspruch des Klägers unbegründet war, gelten die Vorschriften des § 302 Abs. 4 Satz 2 bis 4. (3) Erscheint in diesem Verfahren eine Partei nicht, so sind die Vorschriften über das Versäumnisurteil entsprechend anzuwenden. '''(Quellinfo = Buch "ZPO" S. 156 ff.)'''
= § 601 (ZPO) (weggefallen) =
'''(Quellinfo = Buch "ZPO" S. 157 ff.)'''
= § 602 (ZPO) Wechselprozess. =
Werden im Urkundenprozess Ansprüche aus Wechseln im Sinne des Wechselgesetztes geltend gemacht (Wechselprozess), so sind die nachfolgenden besonderen Vorschriften anzuwenden. '''(Quellinfo = Buch "ZPO" S. 157 ff.)'''
::::: '''Buch 6. 1) (aufgehoben)'''
::::: '''§§ 606-687 1) (ZPO) (aufgehoben)'''
::::: '''(Quellinfo = Buch "ZPO" S. 157 ff.)'''
= § 603 (ZPO) Gerichtsstand. =
(1) Wechselklagen können sowohl bei dem Gericht des Zahlungsortes als bei dem Gericht angestellt werden, bei dem der Beklagte seinen allgemeinen Gerichtstand hat. (2) Wenn mehrere Wechselverpflichtete gemeinschaftlich verklagt werden, so ist außer dem Gericht des Zahlungsortes das Gericht zuständig, bei dem einer der Beklagten seinen allgemeinen Gerichtstand hat. '''(Quellinfo = Buch "ZPO" S. 17 ff.)'''
= § 604 (ZPO) Klageinhalt: Ladungsfrist. =
(1) Die Klage muss die Erklärung enthalten, dass im Wechselprozess geklagt werde. (2) <sup>1</sup> Die Ladungsfrist beträgt mindestens 24 Stunden , wenn die Ladung an dem Ort, der Sitz des Prozessgerichts ist, zugestellt wird. <sup>2</sup> In Anwaltsprozessen beträgt sie mindestens drei Tage, wenn die Ladung an einem anderen Ort zugestellt wird, der im Bezirk des Prozessgerichts liegt oder von dem ein Teil zu dessen Bezirk gehört. (3) In den höheren Instanzen beträgt die Ladungsfrist mindestens 24 Stunden, wenn die Zustellung der Berufungs- oder Revisionsschrift oder der Ladung an dem Ort erfolgt, der Sitz des höheren Gerichts ist; mindestens drei Tage, wenn die Zustellung an einem anderen Ort erfolgt, der ganz oder zum Teil in dem Landgerichtsbezirk liegt, in dem das höhere Gericht seinen Sitz hat, mindestens eine Woche, wenn die Zustellung sonst im Inland erfolgt. '''(Quellinfo = Buch "ZPO" S. 157 ff.)'''
= § 605 (ZPO) Beweisvorschriften. =
(1) Soweit es zur Erhaltung des wechselmäßigen Anspruch der rechtzeitigen Protesterhebung nicht bedarf, ist als Beweismittel bezüglich der Verlegung des Wechsels der Antrag auf Parteivernehmung zulässig. (2) Zur Berücksichtigung der Nebenforderung genügt, dass sie glaubhaft gemacht ist. '''(Quellinfo = Buch "ZPO" S. 158 ff.)'''
= § 605a (ZPO) Scheckprozess =
Werden im Urkundenprozess Ansprüche aus Schecks im Sinne des Scheckgesetzes geltend gemacht (Scheckprozess), so sind die §§ 602 bis 605 entsprechend anzuwenden. '''(Quellinfo = Buch "ZPO" S. 158 ff.)'''
::::: '''Buch 6.''' 1) (aufgehoben)
= §§ 606-687 1) (ZPO) (aufgehoben) =
::::: '''Buch 7. Mahnverfahren'''
= § 688 (ZPO) Zulässigkeit. =
(1) Wegen eines Anspruchs, der die Zahlung einer bestimmten Geldsumme in Euro zum Gegenstand hat, ist auf Antrag des Antragstellers ein Mahnbescheid zu erlassen. (2) Das Mahnverfahren findet nicht statt: <sup>1.</sup> für Ansprüche eines Unternehmers aus einem Vertrag gemäß den §§ 491 bis 508 des Bürgerlichen Gesetzbuchs, wenn der gemäß § 492 Abs. 2 des Gesetzbuchs anzugebende effektive Jahreszins den bei Vertragsschluss geltenden '''Basiszinssatz nach § 247''' des Bürgerlichen Gesetzbuchs um mehr als zwölf Prozentpunkt übersteigt; 2. wenn die Geltendmachung des Anspruch von einer noch nicht erbrachten Gegenleistung abhängig ist; 3. wenn die Zustellung des Mahnbescheids durch öffentliche Bekanntmachung erfolgen müsste. (3) Müsste der Mahnbescheid im Ausland zugestellt werden, findet das Mahnverfahren nur statt, soweit das Anerkennungs- und Vollstreckungsausführungsgesetz vom 19. Februar 2001 (BGB1. I S. 288) dies vorsieht. (4) 1 Die Vorschriften der Verordnung (EG) Nr. 1896/2006 des Europäischen Parlaments und des Rates vom 12. Dezember 2006 zur Einführung eines Europäischen Mahnverfahrens bleiben unberührt. 2 Für die Durchführung gelten die §§1087 bis 1096 '''(Quellinfo = Buch "ZPO" S. 157 ff.)'''
: '''§ 247 (BGB) 1)2) Basiszinssatz.'''(1) 1 Der Basiszinssatz beträgt 3,62 Prozent3). 2 Er verändert sich zum 1.Januar und 1. Juli eines jeden Jahres um die Prozentpunkte, um welche die Bezugsgröße seit der letzten Veränderung des Basiszinssatzes gestiegen oder gefallen ist. 3 Bezugsgröße ist der Zinssatz für die jüngste Hauptrefinanzierungsoperation der Europäischen Zentralbank vor dem ersten Kalendertag des betreffenden Halbjahrs. '''(Quellinfo = Buch "BGB" S. 47 ff.)'''
: 1) Amtl. Anm.L Diese Vorschrift dient der Umsetzung von Artikel 3 der Richtlinie 2000/35/EG des Europäischen Parlaments und des Rates vom 29. Juni 2000 zur Bekämpfung von Zahlungsverzug im Geschäftsverkehr (AB1. EG Nr. L 200 S. 35). Punkte 1-2)='''(Quellinfo = Buch "BGB S. 47 ff.)'''
: 2) Beachte hierzu Übergangsvorschrift in Art. 229 § 7 EGBGB (Nr. 2).
: - ab 1.1.2002 '''2,57%''' (Bek. v. 28.12.2001, BAnz. 2002 Nr. 3 S. 98);
: - ab 1.7.2002 '''2,47%''' (Bek. v. 25.06.2002, BAnz. Nr. 118 S. 14538);
: - ab 1.1.2003 '''1,97%''' (Bek. v. 30.12.2002, BAnz. 2003 Nr.2. S. 76);
: - ab 1.7.2003 '''1,22%''' (Bek. v. 24.06.2003, BAnz. Nr. 117 S. 13744);
: - ab 1.1.2004 '''1,14%''' (Bek. v. 30.12.2003, BAnz. Nr. 2 S. 69);
: - ab 1.7.2004 '''1,13%''' (Bek. v. 29.06.2004, BAnz. Nr. 122 S. 14246);
: - ab 1.1.2005 '''1,21%''' (Bek. v. 30.12.2004, BAnz. Nr. 1 S. 6);
: - ab 1.7.2005 '''1,17%''' (Bek. v. 28.06.2005, BAnz. Nr. 122 S. 10041);
: - ab 1.1.2006 '''1,37%''' (Bek. v. 29.12.2005, BAnz. Nr. 1 S. 2);
: - ab 1.7.2006 '''1,95%''' (Bek. v. 27.06.2006, BAnz. Nr. 191 S. 4754);
: - ab 1.1.2007 '''2,70%''' (Bek. v. 28.12.2006, BAnz. Nr. 245 S. 7463);
: - ab 1.7.2007 '''3,19%'''(Bek. v. 28.06.2007, BAnz. Nr. 117 S. 6530);
: - ab 1.1.2008 '''3,32%''' (Bek. v. 28.12.2007, BAnz. Nr. 242 S. 8415);
: - ab 1.7.2008 '''3,19%''' (Bek. v. 24.06.2008, BAnz. 94 Nr. 1 S. 2232);
: - ab 1.1.2009 '''1,62%''' (Bek. v. 30.12.2008, BAnz. 2009 Nr. 1 S. 6);
: - ab 1.7.2009 '''0,12%''' (Bek. v. 30.06.2009, BAnz. Nr. 95 S. 2302);
: - ab 1.1.2010 '''0,12%''' (Bek. v. 29.12.2009, BAnz. Nr. 198 S. 4582);
: - ab 1.7.2010 '''0,12%''' (Bek. v. 29.06.2010, BAnz.Nr. 96 S. 2264);
: - ab 1.1.2011 '''0,12%''' (Bek. v. 28.12.2010, BAnz. Nr. 199 S. 4388);
: - ab 1.7.2011 '''0,37%''' (Bek. v. 30.06.2011, BAnz. Nr. 96 S. 2314);
: - ab 1.1.2012 '''0,12%''' (Bek. v. 27.12.2011, BAnz. Nr. 197 S. 4659);
: - ab 1.7.2012 '''0,12%''' (Bek. v. 26.06.2012, BAnz. AT 28.06.2012 B3);
: - ab 1.1.2013 '''-0,13%''' (Bek. v. 28.12.2012, BAnz. AT 31.12.2012 B8);
: - ab 1.7.2013 '''-0,38%''' (Bek. v. 25.06.2013, BAnz. AT 27.06.2013 B4);
: - ab 1.1.2014 '''-0,63%''' (Bek. v. 30.12.2013, BAnz. AT 31.12.2013 B7);
: - ab 1.7.2014 '''-0,73%''' (Bek. v. 24.06.2014, BAnz. AT 26.06.2014 B5);
: - ab 1.1.2015 '''-0,83%''' (Bek. v. 30.12.2014, BAnz. AT 31.12.2014 B12);
: - ab 1.7.2015 '''-0,83%''' (Bek. v. 30.06.2015, BAnz. AT 01.07.2015 B6);
: - ab 1.1.2016 '''-0,83%''' (Bek. v. 29.12.2015, BAnz. AT 30.12.2015 B8);
: - ab 1.7.2016 '''-0,88%''' (Bek. v. 28.06.2016, BAnz. AT 29.06.2016 B4);
: - ab 1.1.2017 '''-0,88%''' (Bek. v. 27.12.2016, BAnz. AT 29.12.2016 B11); '''(Quellinfo der aufgeführten Angaben zu den entsprechenden Basiszinssätzen = Buch "BGB" S. 48 ff.)'''
(2) Die Deutsche Bundesbank gibt den geltenden Basiszinssatz unverzüglich nach den in Absatz 1 Satz 2 genannten Zeitpunkten im Bundesanzeiger bekannt. '''(Quellinfo = Buch "BGB" S. 48 ff.)'''
= § 689 (ZPO) Zuständigkeit; maschinelle Bearbeitung. =
(1) 1 Das Mahnverfahren wird von den Amtsgerichten durchgeführt. 2) 2 Eine maschinelle Bearbeitung ist zulässig. 3 Bei dieser Bearbeitung sollen Eingänge spätestens an dem Arbeitstag erledigt sein, der dem Tag des Eingangs folgt. 3 Die Akten können elektronisch geführt werden (§298 a9)
(2) 1 Ausschließlich zuständig ist das Amtsgericht, bei dem der Antragsteller seinen allgemeinen Gerichtsstand hat. 2 Hat der Antragsteller im Inland keinen allgemeinen Gerichtsstand, sonst das Amtsgericht Wedding in Berlin ausschlie´loch zuständig. 3. Sätze 1 und 2 gelten auch, soweit in anderen Vorschriften eine andere ausschließliche Zuständigkeit bestimmt ist.
(3) 1) 1 Die Landesregierungen wären ermächtigt, durch Rechtsverordnung Mahnverfahren einem Amtsgericht für die Bezirke mehrerer Amtsgerichte zuzuweisen, wenn dies ihrer schnelleren und rationelleren Erledigung dient. 2 Die Zuweisung kann auf Mahnverfahren beschränkt werden, die maschinell bearbeitet werden. 3 Die Landesregierungen können die Ermächtigung durch Rechtsverordnung auf die Landesjustizverwaltungen übertragen. 4 Mehrere Länder können die Zuständigkeit eines Amtsgerichts über die Landesgrenzen hinaus vereinbaren. '''(Quellinfo = Buch "ZPO" S. 158 ff.)'''
= § 690 (ZPO) Mahnantrag. =
(1) Der Antrag muss auf den Erlass eines Mahnbescheids gerichtet sein und enthalten: 1. die Bezeichnung der Parteien, ihrer gesetzlichen Vertreter und der Prozessbevollmächtigten; 2. die Bezeichnung des Gerichts, bei dem der Antrag gestellt wird; 3. die Bezeichnung des Anspruchs unter bestimmter Angabe der verlangten Leistung; Haupt - und Nebenforderungen sind gesondert und einzeln zu bezeichnen. Ansprüche aus Verträgen gemäß den '''§§ 491 bis 508 des Bürgerlichen Gesetzbuchs'''; auch unter Angabe des Datums des Vertragsabschlusses und des gemäß '''§ 492 Abs. 2 des Bürgerlichen Gesetzbuchs''' anzugebenden effektiven Jahreszinses; 4. die Erklärung, dass der Anspruch nicht von einer Gegenleistung abhängt oder dass die Gegenleistung erbracht ist; 5. die Bezeichnung des Gerichts, das für ein streitiges Verfahren zuständig ist. (2) Der Antrag bedarf der handschriftlichen Unterzeichnung. (3) 1 Der Antrag kann in einer nur maschinell lesbaren Form vermittelt werden, wenn diese dem Gericht für seine maschinelle Bearbeitung geeignet erscheint. 2 Wird der Antrag von einem Rechtsanwalt oder einer registrierten Person nach § 10 Abs. 1 Satz 1 Nr. 1 des Rechtsdienstleistungegesetztes gestellt, ist nur diese Form der Antragstellung zulässig. '''[Satz 3 ab 1. 1. 2018:]''' 3 Der Antrag kann unter Nutzung des elektronischen Identitätsnachweises nach § 18 des Personalausweisgesetztes oder § 78 Absatz 5 des Aufenthaltsgesetztes gestellt werden. 3 '''[Satz 3 bis 31. 12. 2017, Satz 4 ab 1. 1. 2018 :] Der handschriftlichen Unterzeichnung bedarf es nicht, wenn in anderer Weise gewährleistet ist, dass der Antrag nicht ohne den Willen des Antragstellers übermittelt wird. (Quellinfo = Buch "ZPO" S. 158 ff.)'''
:Kapitel 2 Besondere Vorschriften für Verbraucherdarlehensverträge (BGB)
: '''§ 491 1) 2) Verbraucherdarlehensvertrag.'''
: (1) 1 Die Vorschriften dieses Kapitels gelten für Verbraucherdarlehensverträge, soweit nichts anderes bestimmt ist. 2 Verbraucherdarlehensverträge sind Allgemein- Verbraucherdarlehensverträge und Immobiliar-Verbraucherdarlehensverträge. (2) 1 Allgemein- Verbraucherdarlehensverträge sind entgeltliche Darlehensverträge zwischen einem Unternehmer als Darlehensgeber und einem Verbraucher als Darlehensnehmer. 2 Keine Allgemein Verbraucherdarlehensverträge sind Verträge, 1 bei denen der Nettodarlehensbetrag (Artikel 247 § 3 Abs 2 des Einführungsgesetzes zum Bürgerlichen Gesetzbuche 1) weniger als 200 Euro beträgt. 2 ei denen sich die Haftung des Darlehensnehmers auf eine dem Darlehensgeber zum Pfand übergebene Sache Beschränkt, 3 .bei denen der Darlehensnehmer das Darlehen binnen drei Monaten zurückzuzahlen hat und nur geringe Kosten vereinbart sind. 4. die von Arbeitgebern mit ihren Arbeitnehmers als Nebenleistung zum Arbeitsvertrag zu einem niedrigeren als dem marktüblichen effektiven Jahreszins (§ 6 der Preisangabenverordnung) abgeschlossen werden und anderen Personen nicht angeboten werden. 5. die nur mit einem begrenzten Personenkreis auf Grund von Rechtsvorschriften in öffentlichem Interesse abgeschlossen werden, wenn im Vertrag für den Darlehensnehmer günstigere als marktübliche Bedingungen und höchstens der marktübliche Sollzinssatz vereinbart sind. 6. bei denen es sich um Immobil- Verbraucherdarlehensverträge gemäß Absatz 3 handelt.
: (3) 1 Immobiliar-Verbraucherdarlehendverträge sind entgeltliche Darlehensverträge wischen einem Unternehmer als Darlehensgeber und einem Verbraucher als Darlehensnehmer, die 1. durch ein Grundpfandrecht oder eine Reallast gesichert sind oder 2. für den Erwerb oder die Erhaltung des Eigentumsrechts an Grundstücken, an bestehenden oder zu errichtenden Gebäuden oder für den Erwerb oder die Erhaltung von grundstücksgleichen Rechten bestimmt sind. 2 Keine Immobiliar-Berbraucherdarlehensverträge sind Verträge gemäß Absatz 2 Satz 2 Nummer 4. 3 Auf Immobiliar-Berbruacherdarlehensverträge gemäß Absatz 2 Satz 2 Nummer 4 ist nur '''§ 491 a Absatz 4''' anwendbar. (4) '''§ 358 Abs. 2''' und 4 sowie die '''§§ 491 a bis 495''' und '''505a bis 505 d''' sind nicht auf Darlehensverträge anzuwenden, die in ein nach den Vorschriften der Zivilprozessordnung errichtetes gerichtliches Protokoll aufgenommen oder durch einen gerichtlichen Beschluss über das Zustandekommen und den Inhalt eines zweichen den Parteien geschlossenen Vergleichs festgestellt sind, wenn in das Protokoll oder den Beschluss der Sollzinssatz, die bei Abschluss des Vertrags in Rechnung gestellten Kosten des Darlehens sowie die Voraussetzungen aufgenommen worden sind unter denen der Sollzinssatz oder die Kosten angepasst werden können. '''(Quellinfo = Buch "BGB" S. 117 ff.)'''
= § 691 (ZPO) Zurückweisung des Mahnantrags. =
(1) 1 Der Antrag wird zurückgewiesen: 1. wenn er den Vorschriften der §§ 688, 689,690, 703 c Abs. 2 nicht entspricht; 2. wenn der Mahnbescheid nur wegen eines Teiles des Anspruchs nicht erlassen werden kann. 2 Vor der Zurückweisung ist der Antragsteller zu hören. (2) Sollte durch die Zustellung des Mahnbescheids eine Frist gewahrt werden oder die Verjährung neu beginnen oder nach § 204 des Bürgerlichen Gesetzbuchs gehemmt werden, so tritt die Wirkung mit der Einreichung oder Anbringung des Antrags auf Erlass des Mahnbescheids ein,wenn innerhalb eines Monats seit der Zustellung der Zurückweisung des Antrags Klage eingereicht und diese demnächst zugestellt wird. (3) 1 Gegen die Zurückweisung findet die sofortige Beschwerde statt, wenn der Antrag in einer nur maschinell lesbaren Form übermittelt und mit der Begründung zurückgewiesen worden ist, dass diese Form dem Gericht für seine maschinelle Bearbeitung nicht geeignet erscheine. 2 Im Übrigen sind Entscheidungen nach Absatz 1 unanfechtbar. '''(Quellinfo = Buch "ZPO" S. 159 ff.)'''
= § 692 (ZPO) Mahnbescheid. =
(1) Der Mahnbescheid enthält: 1. die in § 690 Abs. 1 Nr . 1 bis 5 bezeichneten Erfordernisse des Antrags; 2. den Hinweis, dass das Gericht nicht geprüft hat. ob dem Antragsteller der geltend gemachte Anspruch zusteht; 3. die Aufforderung innerhalb von zwei Wochen seit der Zustellung des Mahnbescheids, soweit der geltend gemachte Anspruch als begründet angesehen wird, die behauptete Schuld nebst den geforderten Zinsen und der dem Betrag nach bezeichneten Kosten zu begleichen oder dem Gericht mitzuteilen, ob und in welchem Umfang dem geltend gemachten Anspruch widersprochen wird. 4 den Hinweis, dass ein dem Mahnbescheid entsprechender Vollstreckungsbescheid ergehen kann, aus dem der Antragsteller die Zwangsvollstreckung betreiben kann falls der Antragsgegner nicht bis zum Fristablauf Widerspruch mit jenem Formular der beigefügten Art erhoben hat; 5. für den Fall, dass Formulare eingeführt sind, den Hinweis, dass der Wirderspruch mit jenem Formular der beigefügten Art erhoben werden soll, das auch bei jedem Amtsgericht erhältlich ist und ausgefüllt werden kann; 6. für den Fall des Widerspruchs, die Ankündigung, an welches Gericht die Sache abgegeben wird, mit dem Hinweis, dass diesem Gericht die Prüfung seiner Zuständigkeit vorbehalten bleibt. (2) An Stelle einer handschriftlichen Unterzeichnung genügt ein entsprechender Stempelabdruck oder eine elektronische Signatur. '''(Quellinfo = Buch "ZPO" S. 158 ff.)'''
= § 693 (ZPO) Zustellung des Mahnbescheids. =
(1) Der Mahnbescheid wird dem Antragsgegner zugestellt. (2) Die Geschäftsstelle setzt den Antragsteller on der Zustellung des Mahnbescheids in Kenntnis. '''(Quellinfo = Buch "ZPO" S. 160 ff.)'''
= § 694 (ZPO) Widerspruch gegen den Mahnbescheid. =
(1) Der Antragsgegner kann gegen den Anspruch oder einen Teil des Anspruchs bei dem Gericht, das den Mahnbescheid erlassen hat, schriftlich Widerspruch erheben, solange der Vollstreckungsbescheid nicht verfügt ist. (2) 1 Ein verspäteter Widerspruch wird als Einspruch behandelt. 2 Dies ist dem Antragsgegner, den den Widerspruch erhoben hat, mitzuteilen. '''(Quellinfo = Buch "ZPO" S. 160 ff.)'''
= § 695 (ZPO) Mitteilung des Widerspruchs; Abschriften. =
1 Das Gericht hat den Antragsteller von dem Widerspruch und dem Zeitpunkt seiner Erhebung in Kenntnis zu setzen. 2 Wird das Mahnverfahren nicht maschinell bearbeitet, so soll der Antragsgegner die erforderliche Zahl von Abschriften mit dem Widerspruch einreichen. '''(Quellinfo = Buch "ZPO" S. 160 ff.)'''
= § 696 (ZPO) Verfahren nach Widerspruch. =
(1) 1 Wird rechtzeitig Widerspruch erhoben und beantragt eine Partei die Durchführung des streitigen Verfahrens, so gibt das Gericht, das den Mahnbescheid erlasen hat, den Rechtsstreit von Amts wegen an das Gericht ab, das in dem Mahnbescheid gemäß § 692 Abs. 1 Nr 1 bezeichnet worden ist, wenn die Parteien übereinstimmend die Abgabe an ein anderes Gericht verlangen, an diese. 2 Der Antrag kann in den Antrag auf Erlass des Mahnbescheids aufgenommen werden. 3 Die Abgabe ist den Parteien mitzuteilen; sie ist nicht anfechtbar. 4 Mit Eingang der Akten bei dem Gericht, an das er abgegeben wird, gilt der Rechtstreit als dort anhängig. 5 § 281 Ab. 2 Satz 1 gilt entsprechend. (2) 1 Ist das Mahnverfahren maschinell bearbeitet worden, so tritt, sofern die Akte nicht elektronisch übermittelt wird, an die Stelle der Akten ein maschinell erstellter Aktenausdruck. 2 Für diesen gelten die Vorschriften über die Beweiskraft öffentlicher Urkunden entsprechend. 3 § 298 findet keine Anwendung. (3) Die Streitsache gilt als mit Zustellung des Mahnbescheid rechtshängig geworden, wenn sie alsbald nach de Erhebung des Widerspruch abgegeben wird. (4) 1 Der Antrag auf Durchführung des streitigen Verfahrens kann bis zum Beginn der mündlichen Verhandlung des Antragsgegners zur Hauptsache zurückgenommen werden. 2 Die Zurücknahme kann vor der Geschäftsstelle nicht rechtshängig geworden anzusehen. (5) Das Gericht, an das der Rechtsstreit abgegeben ist, ist hierzu in seiner Zuständigkeit nicht gebunden. '''(Quellinfo = Buch "ZPO" S. 161 ff.)'''
= § 697 (ZPO) Einleitung des Streitverfahrens. =
(1) 1 Die Geschäftsstelle des Gerichts an das die Streitsache abgegeben wird, hat dem Antragsteller unverzüglich aufzugeben, seinem Anspruch binnen zwei Wochen in einer der Klageschrift entsprechende Form zu dd. 2 § 270 Satz 2 gilt entsprechend. (2) 1 Bei Eingang der Anspruchsbegründung ist wie nach Eingang einer Klage weiter zu verfahren. 2 Zur schriftlichen Klageerwiderungen Verfahren. nach § 276 kann auch eine mit der Zustellung der Anspruchsbegründung beginnende Frist gesetzt werden. (3) 1 Geht die Anspruchsbegründung nicht rechtzeitig ein,so wird bis zu ihrem Eingang Termin zur mündlichen mündlichen Verhandlung nur auf Antrag des Antragsgegner bestimmt . 2 Mit der Terminbestimmung setzt der Vorsitzende dem Antragsteller Eine Frist zur Begründung des Anspruchs; § 296 Abs. 1, 4 gilt entsprechend. (4) 1 Der Antragsgegner kann den Widerspruch bis zum Beginn seiner mündlichen Verhandlung zur Hauptsache zurücknehmen, jedoch nicht nach erlass eines Versäumnisurteil s gegen ihn. 2 Die Zurücknahme kann zu Protokoll der Geschäftsstelle erklärt werden. (5) 1 Zur Herstellung eines Urteils in abgekürzter Form nach § 313 b Ansatz 2, § 317 Absatz 6 kann der Mahnbecheid an Stelle der Klageschrift benutzt werden . 2 Ist das Mahnverfahren maschinell bearbeitet worden, so tritt an die Stelle der Klageschrift der maschinell erstellte Aktenausdruck. '''(Quellinfo = Buch "ZPO" S. 130 ff.)'''
= § 698 (ZPO) Abgabe des Verfahrens am selben Gericht. =
Die Vorschriften über die Abgabe des Verfahrens gelten sinngemäß, wenn Mahnverfahren und streitiges Verfahren bei demselben Gericht durchgeführt werden. '''(Quellinfo = Buch "ZPO" S. 130 ff.)'''
= § 699 (ZPO) Vollstreckungsbescheid. =
(1) 1 Auf der Grundlage des Mahnbescheids erlässt das Gericht auf Antrag einen Vollstreckungsbescheid, wenn der Antragsgegner nicht rechtzeitig Widerspruch erhoben hat. 2 Der Antrag kann nicht vor Ablauf der Widerspruchsfrist gestellt werden; er hat die Erklärung zu enthalten, ob und welche Zahlungen auf den Bescheid geleistet worden sind; '''[bis 31. 12. 2017:''' § 690 Abs. 3 Satz 1 und 3''']''' '''[ab 1. 1. 2018:''' § 690 Abs. 3''']''' gilt entsprechend 3 Ist der Rechtsstreit bereits an ein anderes Gericht abgegeben, so erlässt dieses den Vollstreckungsbescheid. (2) Soweit das Mahnverfahren nicht maschinell bearbeitet wird kann der Vollstreckungsbescheid auf den Mahnbescheid gesetzt werden. (3) 1 In den Vollstreckungsbescheid sind die bisher entstandenen Kosten des Verfahrens aufzunehmen. 2 Der Antragsteller braucht die Kosten nur zu berechnen,, wenn das Mahnverfahren nicht maschinell bearbeitet wird; im Übrigen genügen die zur maschinellen Berechnung erforderlichen Angaben. (4) 1 Der Vollstreckungsbescheid wird dem Antragsgegner von Amts wegen zugestellt, wenn nicht der Antragsteller die Übermittlung an sich zur Zustellung im Parteibetrieb beantragt hat. 2 In diesen Fällen wird der Vollstreckungsbescheid dem Antragsteller zur Zustellung übermittelt; die Geschäftsstelle des Gerichts vermittelt diese Zustellung nicht. 3 Bewilligt das mit dem Mahnverfahren befasste Gericht die öffentliche Zustellung, so wird die Benachrichtigung nach § 186 Abs 2 Satz 2 und an die Gerichtstagel des Gerichts angeheftet oder in das Informationssystem des Gerichts eingestellt, das in dem Mahnbescheid gemäß § 692 Abs 1 Nr. 1 bezeichnet worden ist. (5) Die Belehrung gemäß § 232 ist dem Antragsgegner zusammen mit der Zustellung des Vollsreckungsbescheids schriftlich mitzuteilen. '''(Quellinfo = Buch "ZPO" S. 161 ff.)'''
= § 700 (ZPO) Einspruch gegen den Vollstreckungsbescheid. =
(1) Der Vollstreckungsbescheid steht einem für vorläufig vollstreckbar erklärten Versäumnisurteil gleich. (2) Die Streitsache gilt als mit der Zustellung des Mahnbescheids rechtshängig geworden. (3) 1 Wird Einspruch eingelegt, so gibt das Gericht, das den Vollstreckungsbescheid erlassen hat, den Rechtsstreit von Amts wegen an das Gericht ab, das in dem Mahnbescheid gemäß § 692 Abs. 1 Nr. 1 bezeichnet worden ist, wenn die Parteien übereinstimmend die Abgabe an ein anderes Gericht verlangen, an dieses. 2. §696 Abs. 1 Satz 3 bis 5, Abs2, 5 § 697 Abs. 1, 4, § 698 gelten entsprechend. 3 § 340 Abs. 3 ist nicht anzuwenden. (4) 1 Bei Eingang Teer Anspruchsbegründung ist wie nach Eingang einer Klage weiter zu verfahren wenn der Einspruch nicht als unzulässig verworfen wird. 2 § 276 Abs. 1 Satz 1 3 , Abs. 2 ist nicht anzuwenden. (5) Geht die Anspruchsbegründung innerhalb der von der Geschäftsstelle gesetzten Frist nicht ein und wird der Einspruch auch nicht als unzulässig verworfen, bestimmt der Vorsitzende unverzüglich Termin; § 697 Abs. 3 Satz 2 gilt entsprechend. (6) Der Einspruch darf nach § 345 nur verworfen werden, soweit der Voraussetzungen des § 331 Abs 1,2 erster Halbsatz fr ein Versäumnisurteil vorliegen, wird der Vollstreckungsbescheid aufgeben. '''(Quellinfo = Buch "ZPO" S. 162 ff.)'''
= § 701 (ZPO) Wegfall der Wirkung des Mahnbescheids. =
1 Ist Widerspruch nicht erhoben und beantragt der Antragsteller den Erlass des Vollstreckungsbescheids nicht binnen einer sechsmonatigen Frist, die mit der Zustellung des Mahnbescheids beginnt, so fällt die Wirkung des Mahnbescheids weg. 2 Dasselbe gilt, wenn der Vollstreckungsbescheid rechtzeitig beantragt ist, der Antrag aber zurückgewiesen wird. '''(Quellinfo = Buch "ZPO" S. 163 ff.)'''
= § 702 (ZPO) Form von Anträgen und Erklärungen. =
(1) 1 Im Mahnverfahren können die Anträge und Erklärungen vor dem Urkundsbeamten der Geschäftsstelle abgegeben werden. 2 Soweit Formulare eingeführt sind, werden diese ausgefüllt; der Urkundsbeamte vermerkt unter Angabe des Gerichts und des Datums, dass er den Antrag oder die Erklärung aufgenommen hat. 3 Auch soweit Formulare nicht eingeführt sind, ist für den Antrag auf Erlass eines Mahnbescheids oder eines Vollsstreckungsbescheids bei dem für das Mahnverfahren zuständigen Gericht die Aufnahme eines Protokolls nicht erforderlich. (2) Der Antrag auf Erlass eines Mahnbesheids oder eines Vollstreckungsbescheids wir dem Antragsgegner nicht mitgeteilt. '''(Quellinfo = Buch "ZPO" S. 163 ff.)'''
= § 703 (ZPO) Kein Nachweis der Vollmacht. =
1 Im Mahnverfahren bedarf es des Nachweises einer Vollmacht nicht. 2 Wer als Bevollmächtigter einen Antrag einreicht oder einen Rechtsbehelf einlegt, hat seine ordnungsgemäße Bevollmächtigung zu versichern. '''(Quellinfo = Buch "ZPO" S. 163 ff.)'''
= § 703 a (ZPO) Urkunden-, Wechsel- und Scheckmahnverfahren. =
(1) Ist der Antrag des Antragstellers auf den Erlass eines Urkunden- Wechsel- oder Scheckmahnbescheids gerichtet, so wird der Mahnbescheid als Urkunden-, Wechsel- oder Scheckmahnbescheid bezeichnet. (2) Für das Urkunden-, Wechsel- und Scheckmahnverfahren gelten folgende besondere Vorschriften: 1. die Bezeichnung als Urkunden-, Wechsel- oder Scheckmahnbescheid hat die Wirkung, dass die Streitsache, wenn rechtzeitig Widerspruch erhoben wird, im Urkunden-, Wechsel- oder Scheckprozess anhängig wird, 2. die Urkunden sollen in dem Antrag auf Erlass des Mahnbescheids und in dem Mahnbescheid bezeichnet werden; ist die Sache an das Streitgericht abzugeben, so müssen die Urkunden in Urschrift oder in Abschrift der Anspruchsbegründung beigefügt werden; 3. im Mahnverfahren ist nicht zu prüfen, ob die gewählte Prozessart statthaft ist. 4. beschränkt sich der Widerspruch auf den Antrag, dem Beklagten die Ausführung seiner Rechte vorzubehalten, so ist der Vollstreckungsbescheid unter diesen Vorbehalt zu erlassen. Auf das weitere Verfahren ist die Vorschrift des § 600 entsprechend anzuwenden. '''(Quellinfo = Buch "ZPO" S. 163 ff.)'''
= § 703 b (ZPO) Sonderregelungen für maschinelle Bearbeitung. =
(1) Bei maschineller Bearbeitung werden Beschlüsse, Verfügungen, Ausfertigungen und Vollstreckungsklauseln mit dem Gerichtssiegel versehen; einer Unterschrift bedarf es nicht. (2) Das Bundesministerium der Justiz und für Verbraucherschutz wird ermächtigt, durch Rechtsverordnung mit Zustimmung des Bundesrates den Verfahrensablauf zu regeln, soweit dies für eine einheitliche maschinelle Bearbeitung der Mahnverfahren erforderlich ist (Verfahrensablaufplan) '''(Quellinfo = Buch "ZPO" S. 163 ff.)'''
= § 703 c (ZPO) Formulare; Einführung der maschinellen Bearbeitung. =
(1) 1 Das Bundesministerium der Justiz und für Verbraucherschutz wird ermächtigt, durch Rechtsverordnung 1) mit Zustimmung des Bundesrates zur Vereinfachung des Mahnverfahrens und zum Schutze der in Anspruch genommenen Partei Formulare einzuführen. 2 Für 1. Mahnverfahren bei Gerichten, die die Verfahren maschinell bearbeiten. 2. Mahnverfahren bei Gerichten, die die Verfahren nicht maschinell bearbeiten. 3. Mahnerfahren, in denen der Mahnbescheid im Ausland zuzustellen ist. 4. Mahnverfahren, in denen der Mahnbescheid nach Artikel 32 des Zusatzabkommen zum NATO-Truppenstatut vom 3. August 1959 (BGB1, 1961 II S. 1183, 1218) zuzustellen ist, können unterschiedliche Formulare eingeführt werden. (2) Soweit nach Absatz 1 Formulare für Anträge und Erklärungen der Parteien eingeführt sind, müssen sich die Parteien ihrer bedienen. (3) Die Landesregierungen bestimmen durch Rechtsverordnung den Zeitpunkt, in dem bei einem Amtsgericht maschinelle Bearbeitung der Mahnverfahren eingeführt wird; sie können die Ermächtigung durch Rechtsverordnung auf die Landesjustizverwaltungen übertragen. '''(Quellinfo = Buch "ZPO" S. 164 ff.)'''
= § 703 d (ZPO) Antragsgegner ohne allgemeinen inländischen Gerichtsstand. =
(1) Hat der Antragsgegner keinen allgemeinen Gerichtsstand im Inland, so gelten die nachfolgenden besonderen Vorschriften. (2) 1 Zuständig für das Mahnverfahren ist das Amtsgericht, das für das streitige Verfahren zuständig sein würde, wenn die Amtsgerichte im ersten Rechtszug sachlich unbeschränkt zuständig wären. 2 § 689 Abs. 2 gilt entsprechend. '''(Quellinfo = Buch "ZPO" S. 164 ff.)'''
::'''Buch 8. Zwangsvollstreckung'''
: '''Abschnitt 1. Allgemeine Vorschriften'''
= § 704 (ZPO) Vollstreckbare Endurteile. =
Die Zwangsvollstreckung findet statt aus Endurteilen, die rechtskräftig oder für vorläufig vollstreckbar erklärt sind. '''(Quellinfo = Buch "ZPO" S. 164 ff.)'''
= § 705 (ZPO) Formelle Rechtskraft. =
1 Die Rechtskraft der Urteile tritt vor Ablauf der für die Einlegung des zulässigen Rechtsmittels oder des zulässigen Einspruchs bestimmten Frist nicht ein. 2 Der Einritt der Rechtskraft wird durch rechtzeitige Einlegung des Rechtsmittels oder des Einspruchs gehemmt. '''(Quellinfo = Buch "ZPO" S. 165 ff.)'''
= § 706 (ZPO) Rechtskraft- und Notfristzeugnis. =
(1) Zeugnisse über die Rechtskraft der Urteile sind auf Grund der Prozessakten von der Geschäftsstelle des Gerichts des ersten Rechtszuges und, solange der Rechtsstreit in einem höheren Rechtszug anhängig ist, von der Geschäftsstelle des Gerichts dieses Rechtszuges zu erteilen. (2) 1 Soweit die Erteilung des Zeugnisses davon abhängt, dass gegen das Urteil ein Rechtsmittel nicht eingelegt ist, holt die Geschäftsstelle des Gerichts des ersten Rechtszuges bei der Geschäftsstelle des für das Rechtsmittel zuständigen Gerichts eine Mitteilung in Textform ein, dass bis zum Ablauf der Notfrist eine Rechtsmittelschrift nicht eingereicht sei. 2 Einer Mitteilung durch die Geschäftsstelle des Revisonsgerichts, dass ein Antrag auf Zulassung der Revision nach § 566 nicht eingereicht sei, bedarf es nicht. '''(Quellinfo = Buch "ZPO" S. 165 ff.)'''
= § 707 (ZPO) Einstweilige Einstellung der Zwangsvollstreckung. =
(1) 1 Wird die Wiedereinsetzung in den vorigen Stand oder eine Wiederaufnahme des Verfahrens beantragt oder die Rüge nach § 321 a erhoben oder wird der Rechtsstreit nach der Verkündung eines Vorbehaltsurteils fortgesetzt , so kann das Gericht auf Antrag anordnen, dass die Zwangsvollstreckung gegen oder ohne Sicherheitsleistung einstweilen eingestellt werde oder nur gegen Sicherheitsleistung stattfinde und dass die Vollstreckungsmaßregeln gegen Sicherheitsleistung aufzuheben seien. 2 Die Einstellung der Zwangsvollstreckung ohne Sicherheitsleistung ist nur zulässig, wenn glaubhaft gemacht wird, dass der Schuldner zur Sicherheitsleistung nicht in der Lage ist und die Vollstreckung einen nicht zu ersetzenden Nachteil bringen würde. (2) 1 Die Entscheidung ergeht durch Beschluss. 2 Eine Anfechtung des Beschlusses findet nicht statt. '''(Quellinfo = Buch "ZPO" S. 165 ff.)'''
= § 708 (ZPO) Vorläufige Vollstreckbarkeit ohne Sicherheitsleistung. =
Für vorläufig vollstreckbar ohne Sicherheitsleistung sind zu erklären: 1. Urteile, die auf Grund eines Anerkenntnissen oder eines Verzichts ergehen; 2. Versäumnisurteile und Urteile nach Lage der Akten gegen die säumige Partei gemäß § 331 a; 3. Urteile, durch die gemäß § 341 der Einspruch als unzulässig verworfen wird; 4. Urteile, die im Urkunden-, Wechsel- oder Scheckprozess erlassen werden; 5. Urteile, die ein Vorbehaltsurteil, das im Urkunden-, Wechsel- oder Scheckprozess erlassen wurde, für vorbehaltlos erklären; 6. Urteile, durch die Arreste oder einstweilige Verfügungen abgelehnt oder aufgehoben werden 7. Urteile in Streitigkeiten zwischen dem Vermieter und dem Mieter oder Untermieter von Wohnräumen oder anderen Räumen oder zwischen dem Mieder und dem Untermieter solcher Räume wegen Überlassung, Benutzung oder Räumung, wegen Fortsetzung des Mietverhältnisses über Wohnraum auf Grund der §§ 574 bis 574 b des Bürgerlichen Gesetzbuchs sowie wegen Zurückhaltung der von dem Mieter oder dem Untermieter in die Mieträume eingebrachten Sachen; 8. Urteile, die die Verpflichtung aussprechen, Unterhalt, Renten wegen Entziehung einer Unterhaltsforderung oder Renten wegen einer Verletzung des Körpers oder der Gesundheit zu entrichten soweit sich die Verpflichtung auf die Zeit nach der Klageerhebung und auf das ihr vorausgehende letzte Vierteljahr erzieht; 9. Urteile nach §§ 861, 862 des Bürgerlichen Gesetzbuchs auf Wiedereinräumung des Besitzes oder auf Beseitigung oder Unterlassung einer Besitzstörung; 10. Berufungsurteile in vermögensrechtlichen Streitigkeiten. Wird die Berufung durch Urteil oder Beschluss gemäß § 522 Absatz 2 zurückgewiesen., ist auszusprechen dass das angefochtene Urteil ohne Sicherheitsleistung vorläufig vollstreckbar ist; 11. andere Urteile in vermögensrechtlichen Streitigkeiten, wenn der Gegenstand der Verurteilung in der Hauptsache 1250 Euro nicht übersteigt oder wenn nur die Entscheidung über die Kosten vollstreckbar ist und eine Vollstreckung im Wert von nicht mehr als 1500 Euro ermöglicht. '''(Quellinfo = Buch "ZPO" S. 165 ff.)'''
= § 709 (ZPO) Vorläufige Vollstreckbarkeit gegen Sicherheitsleistung. =
1 Andere Urteile sind gegen eine der Höhe nach zu bestimmende Sicherheit für vorläufig vollstreckbar zu erklären. 2 Soweit wegen einer Geldforderung zu vollstrecken ist, genügt es, wenn die Höhe der Sicherheitsleistung in einem bestimmten Verhältnis zur Höhe des jeweils zu vollstreckenden Betrages angegeben wird. 3 Handelt es sich um ein Urteil, das ein Versäumnisurteil aufrechterhält, so ist auszusprechen, dass die Vollstreckung aus dem Versäumnisurteil nur gegen Leistung oder Sicherheit fortgesetzt werden darf. '''(Quellinfo = Buch "ZPO" S. 166 ff.)'''
= § 710 (ZPO) Ausnahmen von der Sicherheitsleistung des Gläubigers. =
Kann der Gläubiger die Sicherheit nach § 709 nicht oder nur unter erheblichen Schwierigkeiten leisten, so ist das Urteil auf Antrag auch ohne Sicherheitsleistung für vorläufig vollstreckbar zu erklären, wenn die Aussetzung der Vollstreckung dem Gläubiger einen schwer zu ersetzenden oder schwer abzusehenden Nachteil bringen würde oder aus einem sonstigen Grund für den Gläubiger unbillig wäre, insbesondere weil der die Leistung für seine Lebenshaltung oder seine Erwerbstätigkeit dringend benötigt. '''(Quellinfo = Buch "ZPO" S. 166 ff.)'''
= § 711 (ZPO) Abwendungsbefugnis. =
1 In den Fällen des § 708 Nr. 4 bis 11 hat das Gericht auszusprechen, dass der Schuldner die Vollstreckung durch Sicherheitsleistung oder Hinterlegung abwenden darf, wenn nicht der Gläubiger vor der Vollstreckung Sicherheit leistet. 2 § 709 Satz 2 gilt entsprechend, für den Schuldner jedoch mit der Maßgabe dass Sicherheit in einem bestimmten Verhältnis zur Höhe des auf Grund des Urteils vollstreckbaren Betrages zu leisten ist. 3 Für den Gläubiger gilt § 710 entsprechend. '''(Quellinfo = Buch "ZPO" S. 166 ff.)'''
= § 712 (ZPO) Schutzantrag des Schuldners. =
(1) 1 Würde die Vollstreckung dem Schuldner einen nicht zu ersetzenden Nachteil bringen, so hat ihm das Gericht auf Antrag zu gestatten, die Vollstreckung durch Sicherheitsleistung oder Hinterlegung ohne Rücksicht auf eine Sicherheitsleistung des Gläubigers abzuwenden; § 709 Satz 2 gilt in den Fällen des § 709 Satz 1 entsprechend. 2 Ist der Schuldner dazu nicht in der Lage, so ist das Urteil nicht für vorläufig vollstreckbar zu erklären oder die Vollstreckung auf die in § 720a Abs. 1, 2 bezeichneten Maßregeln zu beschränken. (2) 1 Dem Antrag des Schuldners ist nicht zu entsprechen wenn ein überwiegendes Interesse des Gläubigers entgegensteht. 2 In den Fällen des § 708 kann das Gericht anordnen, dass das Urteil nur gegen Sicherheitsleistung vorläufig vollstreckbar ist. '''(Quellinfo = Buch "ZPO" S. 167 ff.)'''
= § 713 (ZPO) Unterbleiben von Schuldnerschutzanordnungen. =
Die in den §§ 711, 712 zugunsten des Schuldners zugelassenen Anordnungen sollen nicht ergehen, wen die Voraussetzungen, unter denen ein Rechtsmittel gegen das Urteil stattfindet, unzweifelhaft nicht vorliegen. '''(Quellinfo = Buch "ZPO" S. 168 ff.)'''
= § 714 (ZPO) Anträge zur vorläufigen Vollstreckbarkeit. =
(1) Anträge nach den §§ 710, 711 Satz 3, § 712 sind vor Schluss der mündlichen Verhandlung zu stellen, auf die das Urteil ergeht. (2) Die tatsächlichen Voraussetzungen sind glaubhaft zu machen. '''(Quellinfo = Buch "ZPO" S. 168 ff.)'''
= § 715 (ZPO) Rückgabe der Sicherheit. =
(1) 1 Das Gericht, das eine Sicherheitsleistung des Gläubigers angeordnet oder zugelassen hat, ordnet auf Antrag die Rückgabe der Sicherheit an, wenn ein Zeugnis über die Rechtskraft des für vorläufig vollstreckbar erklärten Urteils vorgelegt wird. 2 Ist die Sicherheit durch eine Bürgschaft bewirkt worden, so ordnet das Gericht das Erlöschen der Bürgschaft an. (2) § 109 Abs. 3 gilt entsprechend. '''(Quellinfo = Buch "ZPO" S. 168 ff.)'''
= § 716 (ZPO) Ergänzung des Urteils. =
Ist über die vorläufige Vollstrecktbarkeit nicht entschieden, so sind wegen Ergänzung des Urteils die Vorschriften des § 321 anzuwenden. '''(Quellinfo = Buch "ZPO" S. 168 ff.)'''
= § 717 (ZPO) Wirkungen eines aufhebenden oder abändernden Urteils =
(1) Die vorläufige Vollstreckbarkeit tritt mit der Verkündung eines Urteils, das die Entscheidung In der Hauptsache oder die Vollsteckbarkeitserklärung aufhebt oder abändert, insoweit außer Kraft, als die Aufhebung oder Abänderung ergeht. (2) 1 Wird ein für vorläufig vollstreckbar erklärtes Urteil aufgehoben oder abgeändert, so ist der Kläger zum Ersatz des Schadens verpflichtet, der dem Beklagten durch die Vollstreckung des Urteils oder durch eine zur Abwendung der Vollstreckung gemachte Leistung entstanden ist. 2 Der Beklagte kann den Anspruch auf Schadensersatz in dem anhängigen Rechtsstreit geltend machen, wird der Anspruch geltend gemacht, so ist er als zur Zeit der Zahlung oder Leistung rechtshängig geworden anzusehen. (3) 1 Die Vorschriften des Absatzes 2 sind auf die im § 708 Nr. 10 bezeichneten Berufungsurteile mit Ausnahme der Versäumnisurteile, nicht anzuwenden. 2 Soweit ein solches Urteil aufgehoben oder abgeändert wird, ist der Kläger auf Antrag des Beklagten zur Erstattung des von diesem auf Grund des Urteils Gezahlten oder Geleisteten zu verurteilen. 3 Die Erstattungspflicht des Klägers bestimmt sich nach den Vorschriften über die Herausgabe einer ungerechtfertigten Bereicherung. 4. Wird der Antrag gestellt, so ist der Anspruch auf Erstattung als zur Zeit der Zahlung oder Leistung rechtshängig geworden anzusehen: die mit der Rechtsabhängigkeit nach den Vorschriften des bürgerlichen Rechts verbundenen Wirkungen treten mit der Zahlung oder Leistung auch dann ein, wenn der Antrag nicht gestellt wird.'''(Quellinfo = Buch "ZPO" S. 168 ff.)'''
= § 718 (ZPO) Vorabentscheidung über vorläufige Vollstreckbarkeit =
(1) In der Berufungsinstanz ist über die vorläufige Vollstreckbarkeit auf Antrag vorab zu verhandeln und zu entscheiden, (2) Eine Anfechtung der in der Berufungsinstanz über die vorläufige Vollstreckbarkeit erlassenen Entscheidung findet nicht statt. '''(Quellinfo = Buch "ZPO" S. 169 ff.)'''
= § 719 (ZPO) Einstweilige Einstellung bei Rechtsmittel und Einspruch. =
(1) 1 Wird gegen ein für vorläufig vollstreckbar erklärtes Urteil der Einspruch oder die Berufung eingelegt, so gelten die Vorschriften des § 707 entsprechend. 2 Die Zwangsvollstreckung aus einem Versäumnisurteil darf nur gegen Sicherheitsleistung eingestellt werden, es sei denn, dass das Versäumnisurteil nicht in gesetzlicher Weise ergangen ist oder sie säumige Partei glaubhaft macht, dass ihr Säumnis unverschuldet war.
(2) 1 Wird Revision gegen ein für vorläufig vollstreckbar erklärtes Urteil eingelegt, so ordnet das Revisionsgericht auf Antrag an, dass die Zwangsvollstreckung einstweilen eingestellt wird, wenn die Vollstreckung dem Schuldner einen nicht zu ersetzenden Nachteil bringen würde und nicht ein überwiegendes Interesse des Gläubigers entgegensteht. 2 Die Parteien haben die tatsächlichen Voraussetzungen glaubhaft zu machen.
(3) Die Entscheidung ergeht per Beschluss. '''(Quellinfo = Buch "ZPO" S. 169 ff.)'''
= § 720 (ZPO) Hinterlegung bei Abwendung der Vollstreckung. =
Darf der Schuldner nach § 711 Abs. 1 Satz 1 die Vollstreckung durch Sicherheitsleistung oder Hinterlegung abwenden, so ist gepfändetes Geld oder der Erlös gepfändeter Gegenstände zu hinterlegen.
= § 721 (ZPO) Räumungsfrist. =
.....Text folgt noch!
= § 722 (ZPO) Vollstreckbarkeit ausländischer Urteile. =
.....Text folgt noch!
= § 723 (ZPO) Vollstreckungsurteil. =
.....Text folgt noch!
= § 724 (ZPO) Vollstreckbare Ausfertigung. =
.....Text folgt noch!
= § 725 (ZPO) Vollstreckungsklausel. =
.....Text folgt noch!
= § 726 (ZPO) Vollstreckbare Ausfertigung bei bedingten Leistungen. =
.....Text folgt noch!
= § 727 (ZPO) Vollstreckbare Ausfertigung für und gegen Rechtsnachfolger. =
.....Text folgt noch!
= § 728 (ZPO) Vollstreckbare Ausfertigung bei Nacherbe oder Testamentsvollstrecker. =
.....Text folgt noch!
= § 729 (ZPO) Vollstreckbare Ausfertigung gegen Vermögens- und Firmenübernehmer. =
.....Text folgt noch!
= § 730 (ZPO) Anhörung des Schuldners. =
.....Text folgt noch!
= § 731 (ZPO) Klage auf Erteilung der Vollstreckungsklausel. =
.....Text folgt noch!
= § 755<sup>1)</sup>Ermittlung des Aufenthaltsorts des Schuldners. =
(1) <sup>1</sup> Ist der Wohnsitz oder gewöhnliche Aufenhaltsort des Schuldners nicht bekannt, darf der Gerichtsvollzieher auf Grund des Vollstreckungsauftrags und der Übergabe der vollstreckbaren Ausfertigung zur Ermittlung des Aufenthaltsorts des Schuldners bei der Meldebehörde die gegenwärtigen Anschriften sowie Angaben zur Haupt- und Nebenwohnung des Schuldners erheben.
<sup>2</sup>Der Gerichtsvollzieher darf auch beauftragt werden, die gegenwärtigen Anschriften, den Ort der Hauptniederlassung oder den Sitz des Schuldners zu erheben. Ort der Hauptniederlassung öden den Sitz des Schuldners zu erheben. <br> 1. durch Einsicht in das Handels-, Genossenschaft-, Partnerschafts-, Unternehmens- oder Vereinsregister oder <br> 2. durch Einholung einer Auskunft bei den nach Landesrecht für die Durchführung der Aufgaben nach § 14 Absatz 1 der Gewerbeordnung zuständigen Behörden.
(2)<sup>1</sup>Soweit der Aufenthaltsort des Schuldners nach Absatz 1 nicht zu ermitteln ist, darf der Gerichtsvollzieher <br> 1. zunächst beim Ausländerzentralregisteer die Angaben zur aktenführenden Ausländerbehörde sowie zum Zuzug oder Fortzug des Schuldners und anschließend bei der gemäß der Auskunft aus dem Ausländerzentralregister aktenführenden Ausländerbehörde den Aufenthaltsort des Schuldners. <br> 2. bei den Trägern der gesetzlichen Rentenversicherung '''''[ab 1.1.2022: '' '''''und bei einer berufsständischen Versorgungseinrichtung im Sinne des § 6 Absatz 1 Satz 1 Nummer 1 des Sechsten Buches Sozialgesetzbuch]'' die dort bekannte derzeitige Anschrift, den derzeitigen oder zukünftigen Aufenthaltsort des Schulders sowie''' <br> '''3. bei dem Kraftfahrt-Bundesamt die Halterdaten nach § 33 Abs. 1 Satz 1 Nr. 2 des Straßenverkehrsgesetzes erheben.''' <sup>2</sup>'''Ist der Schuldner Unionsbürger, darf der Gerichtsvollzieher die Daten nach Satz 1 Nummer 1 nur erheben, wenn ihm tatsächliche Anhaltspunkte für die Vermutung der Feststellung des Nichtbestehens oder des Verlusts des Freizügigkeitsrechts vorliegen'''. <sup>3</sup>'''Eine Übermittlungen Daten nach Satz 1 Nummer 1 an den Gerichtsvollzieher ist ausgeschlossen, wenn der Schuldner Unionsbürger ist, für den eine Feststellung des Nichtbestehens oder des Verlusts des Freizügigkeitsrechts nicht vorliegt. '''''[Satz 4 ab 1.1.2022:]''''' <sup>4</sup>Die ''Erhebung nach Satz 1 Nummer 2 bei einer berufsständischen Versorgungseinrichtung darf der Gerichtsvollzieher nurdurchführen, wenn der Gläubiger die berufsständische Versorgungseinrichtung bezeichnet und tatsächliche Anhaltspunkte nennt, die nahelegen, dass der Schuldner Mitglied dieser berufsständischen Versorgungseinrichtung ist.'' <br> (3) Nach Absatz 1 oder Absatz 2 erhobene Daten, die innerhalb der letzten drei Monate bei dem Gerichtsvollzieher eingegangensind, darf dieser auch in einem Zwangsvollstreckungsverfahren eines weiteren Gläubigers gegen denselben Schuldner verarbeiten, wenn die Voraussetzungen für die Datenerhebung auch bei diesem Gläubiger vorliegen.
= § 758 (ZPO) Durchsuchung: Gewaltanwendung. =
(1) Der Gerichtsvollzieher ist befugt, die Wohnung und die Behältnisse des Schuldners zu durchsuchen, soweit der Zweck der Vollstreckung dies erfordert. (2) Er ist befugt, die verschlossenen Haustüren, Zimmertüren und Behältnisse öffnen zu lassen. (3) Er ist, wenn er Widerstand findet, zur Anwendung von Gewalt befugt und kann zu diesem Zweck die Unterstützung der polizeilichen Vollzugsorgane nachsuchen. '''(Quellinfo = Buch "ZPO" S. 177 ff.)'''
= § 758a (ZPO) Richterliche Durchsuchungsanordnung: Vollstreckung zur Unzeit =
(1) 1 Die Wohnung des Schuldners darf ohne dessen Einwilligung nur auf Grund einer Anordnung des Richters bei dem Amtsgericht durchsucht werden, in dessen Bezirk die Durchsuchung erfolgen soll. 2 Dies gilt nicht, wenn die Einholung der Anordnung den Erfolg der Durchsuchung gefährden würde.
(2) Auf die Vollstreckung eines Titels auf Räumung oder Herausgabe von Räumen und auf die Vollstreckung eines Haftbefehls nach § 802g ist Absatz 1 nicht anzuwenden. (3) 1 Willigt der Schuldner in die Durchsuchung ein oder ist eine Anordnung gegen ihn nach Absatz 1 Satz 1 ergangen oder nach Absatz 1 Satz 2 entbehrlich, so haben Personen die Mitgewahrsam an der Wohnung des Schuldner haben, die Durchsuchung zu dulden. 2 Unbillige Härten gegenüber Mitgewahrsamsinhabern sind zu vermeiden. (4) 1 Der Gerichtsvollzieher nimmt eine Vollstreckungshandlung zur Nachtzeit und an Sonn- und Feiertagen nicht vor, wenn dies für den Schuldner und die Mitgewahrsamtsinhaber eine unbillige Härte darstellt oder der zu erwartende Erfolg in einem Missverhältnis zu dem Eingriff steht, in Wohnungen nur auf Grund einer besondreren Anordnung des Richters bei dem Amtsgericht. 2 Die Nachtzeit umfasst die Stunden von 21 bis 6 Uhr. (5) Die Anordnung nach Absatz 1 ist bei der Zwangsvollstreckung vorzuzeigen. (6) 1 Das Bundesministerium der Justiz und für Verbraucherschutz wird ermächtigt durch Rechtsverordnung mit Zustimmung des Bundesrates Formulare für den Antrag auf Erlass einer richterlichen Durchsungsanordnung nach Absatz 1 einzuführen. 2 Soweit nach Satz 1 Formulare eingeführt sind, muss sich der Antragsteller ihrer bedienen. 3 Für Verfahren bei Gerichten die die Verfahren elektronisch bearbeiten und für Verfahren bei Gerichten, die die Verfahren nichtelektronisch bearbeiten, können unterschiedlichen Formulare eingeführt werden. '''(Quellinfo = Buch "ZPO" S. 177 ff.)'''
= § 759 (ZPO) Zuziehung von Zeugen =
Wird bei einer Vollstreckungshandlung Widerstand geleistet oder ist bei einer in der Wohnung des Schuldners vorzunehmenden Vollstreckungshandlung weder der Schuldner noch ein erwachsener Familienangehöriger, eine in der Familie beschäftigte Person oder ein erwachsener ständiger Mitbewohner anwesend, so hat der Gerichtsvollzieher zwei erwachsener Personen oder einen Gemeinde- oder Polizeibeamten als Zeugen zuzuziehen. '''(Quellinfo = Buch "ZPO" S. 177 ff.)'''
= § 760 (ZPO) Akteneinsicht: Aktenabschrift =
1 Jeder Person, die bei dem Vollstreckungsverfahren beteiligt ist, muss auf Begehren Einsicht der Akten des Gerichtsvollziehers gestattet und Abschrift einzelner Aktenstücke erteilt werden. 2 Werden die Akten des Gerichtsvollziehers elektronisch geführt, erfolgt die Gewährung von Akteneinsicht durch Erteilung von Ausdrucken, durch Übermittlung von elektronischen Dokumenten oder durch Wiedergabe auf einem Bildschirm; dies gilt auch für die nach §§ 885 a Absatz 2 Satz 2 elektronisch gespeicherten Dateien, '''(Quellinfo = Buch "ZPO" S. 178 ff.)'''
= § 761 (ZPO) - (weggefallen) =
'''(Quellinfo = Buch "ZPO" S. 178 ff.)'''
= § 762 (ZPO) Protokoll über Vollstreckungshandlungen =
(1) DerGerichtsvollzieher hat über jede Vollstreckungshandlung ein Protokoll aufzunehmen. (2) Das Protokoll muss enthalten: 1. Ort und Zeit der Aufnahmen: 2. den Gegenstand der Vollstreckungshandlung unter kurzer Erwähnung der wesentlichen Vorgänge. 3. die Namen der Personen, mit denen verhandelt ist; 4. die Unterschrift dieser Personen und den Vermerk, dass die Unterzeichnung nach Vorlesung oder Vorlegung zur Durchsicht und nach Genehmigung erfolgt sei: 5. die Unterschrift des Gerichtsvollziehers. (3) Hat einem der unter Nummer 4 bezeichneten Erfordernisse nicht genügt werden können, so ist der Grund anzugeben. '''(Quellinfo = Buch "ZPO" S. 178 ff.)'''
= § 763 (ZPO) Aufforderungen und Mitteilungen =
(1) 1 Die Aufforderungen und sonstigen Mitteilungen, die zu den Vollstreckungshandlungen gehören, sind von dem Gerichtsvollzieher mündlich zu erlassen und vollständig in das Protokoll aufzunehmen. (2) 1 Kann dies mündlich nicht ausgeführt werden, so hat der Gerichtsvollzieher eine Abschrift des Protokolls zuzustellen oder durch die Post zu übersenden. 2 Es muss im Protokoll vermerkt werden, dass diese Vorschrift befolgt ist. 3 Eine öffentliche Zustellung findet nicht statt. '''(Quellinfo = Buch "ZPO" S. 178 ff.)'''
= § 764 (ZPO) Vollstreckungsgericht =
(1) Die den Gerichten zugewiesene Anordnung von Vollstreckungshandlungen und Mitwirkung bei solchen gehört zur Zuständigkeit der Amtsgerichte als Vollstreckungsgerichte. (2) Als Vollstreckungsgericht ist, sofern nicht das Gesetz ein anderes Amtsgericht bezeichnet, das Amtsgericht anzusehen, in dessen Bezirk das Vollstreckungsverfahren stattfinden soll oder stattgefunden hat. (3) Die Entscheidungen des Vollstreckungsgerichts ergehen durch Beschluss. '''(Quellinfo = Buch "ZPO" S. 178 ff.)'''
= § 765 (ZPO) Vollstreckungsgerichtliche Anordnungen bei Leistung Zug um Zug. =
1 Hängt die Vollstreckung von einer Zug um Zug zu bewirkenden Leistung des Gläubigers an den Schuldner ab, so darf das Vollstreckungsgericht eine Vollstreckungsmaßregel nur anordnen, wenn 1. der Beweis, dass der Schuldner befriedigt oder im Verzug der Annahme ist, durch öffentliche oder öffentlich beglaubigte Urkunden geführt wird und ein Abschrift dieser Urkunden bereits zugestellt ist; der Zustellung bedarf es nicht, wenn bereits der Gerichtsvollzieher die Zwangsvollstreckung nach § 756 Abs. 1 begonnen hatte und der Beweis durch das Protokoll des Gerichtsvollziehers geführt wird; oder
2. der Gerichtsvollzieher eine Vollstreckungsmaßnahme nach § 756 Abs. 2 durchgeführt hat und diese durch das Protokoll des Gerichtsvollziehers nachgewiesen ist. '''(Quellinfo = Buch "ZPO" S. 178 ff.)'''
= § 765 a (ZPO) Vollstreckungsschutz. =
(1) 1 Auf Antrag des Schuldners kann das Vollstreckungsgericht eine Maßnahme der Zwangsvollstreckung ganz oder teilweise aufheben, untersagen oder einstweilen einstellen, wenn die Maßnahme unter voller Würdigung des Schutzbedürfnisses des Gläubigers eggen ganz besonderer Umstände eine Härte bedeutet, die mit den guten Sitten nicht vereinbar ist. 2 Es ist befugt, die in § 732 Ab. 2 bezeichneten Anordnungen zu erlassen. 3 Betrifft die Maßnahme ein Tier, so hat das Vollstreckungsgericht bei der von ihm vorzunehmenden Abwägung die Verantwortung ges Menschen für das Tier zu berücksichtigen. (2) Eine Maßnahme zur Erwirkung der Herausgabe von Sachen kann der Gerichtsvollzieher bis zur Entscheidung des Vollstreckungsgerichts, jedoch nicht länger als eine Woche aufschieben, wenn ihm die Voraussetzungen des Absatzes 1 Satz 1 glaubhaft gemacht werden und dem Schulter die rechtzeitige Anrufung Tees Vollstreckungsgerichts nicht möglich war. (3) In Räumungssachen ist der Antrag nach Absatz 1 spätestens zwei Wochen vor dem festgesetzten Räumungstermin zu stellen, es sei denn dass die Gründe , auf denen der Antrag beruht, erst nach diesem Zeitpunkt entstanden sind oder der Schuldner ohne sein Verschulden an einer rechtzeitigen Antragstellung gehindert war. (4) Das Vollstreckungsgericht hebt seinen Beschluss auf Antrag auf oder ändert ihn, wenn dies mit Rücksicht auf eine Änderung der Sachlage geboten ist. (5) Die Aufhebung von Vollsrteckungsmaßregeln erfolgt in den Fällen des Absatzes 1 Satz 1 und des Absatzes 4 erst nach Rechtskraft des Beschlusses. '''(Quellinfo = Buch "ZPO" S. 179 ff.)'''
= § 766 (ZPO) Erinnerung gegen Art und Weise der Zwangsvollstreckung. =
(1) 1 Über Anträge, Einwendungen und Erinnerungen, welche die Art und Weise der Zwangsvollstreckung oder das vom Gerichtsvollzieher bei ihr zu beobachtende Verfahren betreffen, entscheidet das Vollstreckungsgericht. 2 Es ist befugt, die im § 732 Abs. 2 bezeichenden Anordnungen zu erlassen. (2) Dem Vollstreckungsgericht steht auch die Entscheidung zu, wenn ein Gerichtsvollzieher sich weigert, einen Vollstreckungsauftrag zu übernehmen oder eine Vollstreckungshandlung dem Auftrag gemäß auszuführen, oder wenn wegen der von dem Gerichtsvollzieher in Ansatz gebrachten Kosten Erinnerungen erhoben werden. '''(Quellinfo = Buch "ZPO" S. 179 ff.)'''
= § 767 (ZPO) Vollstreckungsabwehrklage. =
(1) Einwendungen, die den durch das Urteil festgestellten Anspruch selbst betreffen, sind von dem Schuldner im Wege der Klage bei dem Prozessgericht des ersten Rechtszuges geltend zu machen. (2) sie sind nur insoweit zulässig, als die Gründe auf denen sie beruhen, erst nach dem Schluss der mündlichen Verhandlung, in der Einwendungen nach den Vorschriften dieses Gesetzes spätestens hätten geltend gemacht werden müssen, entstanden sind und durch Einspruch nicht mehr geltend gemacht werden können. (3) Der Schuidner muss in der von ihm zu erhebenden Klage alle Einwendungen geltend machen, die er zur Zeit der Erhebung der Klage geltend zu machen imstande war. '''(Quellinfo = Buch "ZPO" S. 180 ff.)'''
= § 768 (ZPO) Klage gegen Vollstreckungsklausel. =
Die Vorschriften des § 767 Abs. 1, 3 gelten entsprechend, wenn in den Fällen des § 726 Abs. 1, der §§ 727 bis 729, 738. 742, 744, des § 749 der Schuldner den bei der Erteilung der Vollstreckungsklausel als beweisen angenommenen Eintritt der Voraussetzung für die Erteilung der Vollstreckungsklausel bestreitet, unbeschadet der Befugnis des Schuldners, in diesen Fällen Einwendungen gegen die Zulässigkeit der Vollstreckungsklausel nach § 732 zu erheben. '''(Quellinfo = Buch "ZPO" S. 180 ff.)'''
= § 769 (ZPO) Einstweilige Anordnungen. =
(1) 1 Das Prozessgericht kann auf Antrag anordnen, dass bis zum Erlass des Urteils über die in den §§ 767, 768 bezeichneten Einwendungen die Zwangsvollstreckung gegen oder ohne Sicherheitsleistung eingestellt per nur gegen Sicherheitsleistung fortgesetzt werde und das Vollstreckungsmaßregeln gegen Sicherheitsleistung aufzuheben seien. 2 Es setzt eine Sicherheitsleistung für die Einstellung der Zwangsvollstreckung nicht fest, wenn der Schuldner zur Sicherheitsleistung nicht in der Lage ist und die Rechtsverfolgung durch ihn hinreichende Aussicht auf Erfolg bietet. 3 Die tatsächlichen Behauptungen, die den Antrag begründen, Erfolg bietet. 3 Die tatsächlichen Behauptungen, die den Antrag begründen sind glaubhaft zu machen. (2) 1 In dringenden Fällen kann das Vollstreckungsgericht eine solche Anordnung erlassen, unter Bestimmung einer Frist innerhalb der die Entscheidung des Prozessgerichts beizubringen sei. 2 Nach fruchtlosem Ablauf der Frist wird die Zwangsvollstreckung fortgesetzt. (3) Die Entscheidung über diese Anträge ergeht durch Beschluss. (4) Im Fall der Anhängigkeit einer auf Herabsetzung gerichteten Abänderungsklage gelten die Absätze 1 bis 3 entsprechend. '''(Quellinfo = Buch "ZPO" S. 180 ff.)'''
= § 770 (ZPO) Einstweilige Anordnungen im Urteil. =
<sup>1</sup>Das Prozessgericht kann in dem Urteil, durch das über die Einwendungen entschieden wird, die in dem vorstehendem Paragraphen bezeichneten Anordnungen erlassen oder die bereits erlassenen Anordnungen aufheben, abändern oder bestätigen. <sup>2</sup> Für die Anfechtungen einer solchen Entscheidung gelten die Vorschriften des § 718 entsprechend. '''(Quellinfo = Buch "ZPO" S. 184 ff.)'''
= § 771 (ZPO) Drittwiderspruchsklage. =
(1) Behauptet ein Dritter, dass ihm an dem Ggenstnd der Zwangsvollstreckung ein die Veräußerung hinderndes Recht zustehe, so ist der Widerspruch gegen die Zwangsvollstreckung im Wege der Klage bei dem Gericht geltend zu machen, in dessen Bezirk die Zwangsvollstreckung erfolgt. (2) Wird die Klage gegen den gläubiger und den Schuldner gerichtet, so sind diese als Streitgenossen anzusehen. (3)<sup>1</sup> Auf die Einstellung der Zwangsvollstreckung und die Aufhebung der bereits getroffenen Vollstreckungmapregeln sin die Vorschriften der §§ 769, 770 entsprechend anzuwenden. <sup>2</sup> Die Aufhebung einer Vollstreckungsmaßregel ist auch ohne Sicherheitsleistung zulässig. '''(Quellinfo = Buch "ZPO" S. 184 ff.)'''
= § 772 (ZPO) Drittwiderspruchsklage bei Veräußerungsverbot. =
<sup>1</sup>Solange ein Veräußerungsverbot der in den §§ 135,136 des Bürgerlichen Gesetzbuchs bezeichneten Art besteht, soll der Gegenstand auf den es sich bezieht, wegen eines persönlichen Anspruchs oder auf Grund eines infolge des Verbots unwirksamen Rechts nicht im Wege der Zwangsvollstreckung veräußert oder überwiesen werden. <sup>2</sup>Auf Grund des Veräußerungsverbots kann nach Maßgabe des § 771 Widerspruch erhoben werden.
= § 773 (ZPO) Drittwiderspruchsklage des Nacherben. =
= § 774 (ZPO) Drittwiderspruchsklage des Ehegatten oder Lebenspartners. =
= § 775 (ZPO) Einstellung oder Beschränkung der Zwangsvollstreckung. =
= § 776 (ZPO) Aufhebung von Vollstreckungsmaßregeln. =
= § 777 (ZPO) Erinnerung bei genügender Sicherung des Gläubigers. =
= § 778 (ZPO) Zwangsvollstreckung vor Erbschaftsnahme. =
= § 779 (ZPO) Fortsetzung der Zwangsvollstreckung nach dem Tod des Schuldners. =
= § 780 (ZPO) Vorbehalt der beschränkten Erbenhaftung. =
::'''Titel 2. Zwangsvollstreckung in das bewegliche Vermögen'''
: '''Untertitel 1. Allgemeine Vorschriften'''
= § 802 <sup>1</sup>(ZPO) Auskunftsrechte des Gerichtsvollziehers. =
= § 803 (ZPO) Pfändung. =
(1) 1 Die Zwangsvollstreckung in das bewegliche Vermögen erfolgt durch Pfändung. 2 Sie darf nicht weiter ausgedehnt werden,als es zur Befriedigung des Gläubigers und zur Deckung der Kosten der Zwangsvollstreckung erforderlich ist. (2) Die Pfändung hat zu unterbleiben, wenn sich von der Verwertung der zu pfändenden Gegenstände ein Überschuss über die Kosten der Zwangsvollstreckung nicht erwarten lässt. '''(Quellinfo = Buch "ZPO" S. 200 ff.)'''
= § 804 (ZPO) Pfändungsrecht. =
(1) Durch die Pfändung erwirbt der Gläubiger ein Pfandrecht an dem gepfändeten Gegenstande. (2) Das Pfandrecht gewährt dem Gläubiger im Verhältnis zu anderen Gläubigern dieselben Rechte wie ein durch Vertrag erworbenes Faustpfandrecht; es geht Pfand- und Vorzugsrechten vor, die für den Fall eines Insolvenzverfahrens den Faustpfandrechten nicht gleichgestellt sind. 1) (3) Das durch eine frühere Pfändung begründete Pfandrecht geht demjenigen vor, das durch eine spätere Pfändung begründet wird. '''(Quellinfo = Buch "ZPO" S. 200 ff.)'''
= § 829 a (ZPO) Vereinfachter Vollstreckungsantrag bei Vollstreckungsbescheiden. =
Text folgt noch!
= § 830 (ZPO) Pfändung einer Hypothekenforderung. =
Text folgt noch!
= § 830 a (ZPO) Pfändung einer Schiffshypothekenforderung. =
Text folgt noch!
= § 831 a (ZPO) Pfändung indossabler Papiere. =
Text folgt noch!
= § 832 (ZPO) Pfändungsumfang bei fortlaufenden Bezügen. =
Text folgt noch!
= § 833 (ZPO) Pfändungsumfang bei Arbeits- und Diensteinkommen . =
Text folgt noch!
= § 833 a (ZPO) Pfändungsumfang bei Kontoguthaben. =
Text folgt noch!
= § 834 (ZPO) Keine Anhörung des Schuldners. =
Text folgt noch!
= § 835 a (ZPO) Überweisung einer Geldforderung. =
Text folgt noch!
= § 836 <sup>1</sup> (ZPO) Wirkung der Überweisung. =
Text folgt noch!
= § 837 (ZPO) Überweisung einer Hypothekenforderung. =
Text folgt noch!
= § 837 a (ZPO) Überweisung einer Schiffshypothekenforderung. =
Text folgt noch!
= § 838 (ZPO) Einrede des Schuldners bei Faustpfand. =
Text folgt noch!
= § 839 (ZPO) Überweisung bei Abwendungsbefugnis. =
Text folgt noch!
= § 840 (ZPO) Erklärungspflicht des Drittschuldners. =
Text folgt noch!
= § 841 (ZPO) Pflicht zur Streitverkündung. =
Text folgt noch!
= § 842 (ZPO) Schadenersatz bei verzögerter Beitreibung. =
Text folgt noch!
= § 843 (ZPO) Verzicht des Pfandgläubigers. =
Text folgt noch!
= § 844 (ZPO) Andere Verwertungsart. =
Text folgt noch!
= § 845 <sup>1</sup> (ZPO) Vorpfändung. =
Text folgt noch!
= § 846 (ZPO) Zwangsvollstreckung in Herausgabeansprüche. =
Text folgt noch!
= § 847 (ZPO) Herausgabeanspruch auf eine bewegliche Sache. =
Text folgt noch!
= § 847 a (ZPO) Herausgabeanspruch auf ein Schiff. =
Text folgt noch!
= § 848 (ZPO) Herausgabeanspruch auf eine unbewegliche Sache. =
Text folgt noch!
= § 849 (ZPO) Keine Überweisung an Zahlungs statt. =
Text folgt noch!
= § 850 (ZPO) Pfändungsschutz für Arbeitseinkommen. =
(1) Arbeitseinkommen, das in Geld zahlbar ist, kann nur nach Maßgabe der §§ 850a bis 850i gepfändet werden. (2) Arbeitseinkommen im Sinne dieser Vorschrift sin die Dienst- und Versorgungsbezüge der Beamten, Arbeits- und Dienstlöhne. Ruhegelder und ähnliche nach dem einstweiligen oder dauernden Ausscheiden aus dem Dienst- oder Arbeitsverhältnis gewährte fortlaufende Einkünfte, ferner Hinterblebenenbezüge, soweit sonstige Vergütungen für Dienstleistungen aller Art, die die Erwerbstätigkeit des Schuldners vollständig oder zu einem wesentlichen Teil in Anspruch nehmen. (3) Abeitseinkommen und auchdiefeolgenden Bezüge, soweit sie in Geld zahlbar sind:
:: a) Bezüge, die ein Arbeitnehmer zum Ausgleich für Wettbewerbsbeschränkungen fpr die Zeit nach Beendigung eines inestverhältnisses beanspruchen kann:
:: b) Renten, die auf Grund von Versicherungsunternehmen oder seiner unterhaltsberechtigten Angehörigen eingegangen sind.
(4) Die Pfändung des in Geld zahlbaren Arbeitskommens erfasst alle Vergütungen, die dem Schuldner aus der Arbeits- oder Dienstleistung zustehen, ohne Rücksicht auf ihre Benennung oder Berechnungsart. '''(Quellinfo = Buch "ZPO" S. 216 ff.)'''
= § 850 a (ZPO) Unpfändbare Bezüge. =
Unpfändbar sind
1. zur Hälfte die für die Leistung von Mehrarbeitsstunden gezahlten Teile des Arbeitsseinkommens; 2. die für die Dauer eines Urlaubs über das Arbeitseinkommen hinaus gewährten Bezüge, Zuwendungen aus Anlass eines besonderen Betriebsereignisses und Treugelder, soweit sie den Rahmen des Üblichen nicht übersteigen; 3. Aufwandsentschädigungen, Auslösungsgelder und sonstige soziale Zulagen für auswärtige Beschäftigungen, das Entgelt für selbstgestelltes Arbeitsmaterial. Gefahrenzulagen, sowie Schmutz und Erschwerniszulagen, soweit diese Bezüge den Rahmen des Üblichen nicht übersteigen; 4. Weihnachtsvergütungen bis zum Betrag der Hälfte des monatlichen Arbeitseinkommens, höchstens aber bis zum Betrag von 500 Euro; 5. Geburtsbeihilfen sowie Beihilfen aus Anlass der Eingehung einer Ehe oder Begründung einer Lebenspartnerschaft, sofern die Vollstreckung wegen anderer als der aus Anlass der Geburt, der Eingebung einer Ehe oder der Begründung einer Lebenspartnerschaft entstandenen Ansprüche betrieben wird; 6. Erziehungsgelder, Studienbeihilfen und ähnliche Bezüge; 7. Sterbe- und Gnadenbezüge aus Arbeits- und Dienstverhältnissen; 8. Blindenzulagen. '''(Quellinfo = Buch "ZPO" S. 217 ff.)'''
= § 850 b (ZPO) Bedingt pfändbare Bezüge. =
Text folgt noch!
= § 850 c<sup>1</sup> (ZPO) Pfändungsgrenzen für Arbeitseinkommen. =
Text folgt noch!
= § 850 d (ZPO) Pfändbarkeit bei Unterhaltsansprüchen. =
Text folgt noch!
= § 850 e<sup>1</sup> (ZPO) Berechnung des pfändbaren Arbeitseinkommens. =
Text folgt noch!
= § 850f (ZPO) Änderung des unpfändbaren Betrages. =
Text folgt noch!
= § 850g (ZPO) Änderung der Unpfändbarkeitsvoraussetzungen. =
Text folgt noch!
= § 886 (ZPO) Herausgabe bei Gewahrsam eines Dritten. =
Befindet sich eine herauszugebende Sache im Gewahrsam eines Dritten, so ist dem Gläubiger auf dessen Antrag der Anspruch des Schuldners auf Herausgabe der Sache nach den Vorschriften zu überweisen, welche die Pfändung und Überweisung einer Geldforderung betreffen. '''(Quellinfo = Buch "ZPO" S. 242 ff.)'''
:::::::'''Abschnitt 6. Schiedsspruch und Beendigung des Verfahrens'''
= § 1051 (ZPO) Anwendbares Recht.=
(1) <sup>1</sup> Das Schiedsgericht hat die Streitigkeit in Übereinstimmung mit den Rechtsvorschriften zu entscheiden, die von den Parteien als auf den Inhalt des Rechtsstreits anwendbar bezeichnet worden sind. <sup>2</sup> Die Bezeichnung des Rechts oder der Rechtsordnung eines bestimmten Staats ist, sofern die Parteien nicht ausdrücklich etwas anderes vereinbart haben, als unmittelbare Verweisung auf die Sachvorschriften dieses Staates und nicht auf sein Kollisionsrecht zu verstehen. (2) Haben die Parteien die anwendbaren Rechtsvorschriften nicht bestimmt, so hat das Schiedsgericht das Recht des Staates anzuwenden, mit dem der Gegenstand des Verfahrens die engsten Verbindungen aufweist. (3) <sup>1</sup> Das Schiedsgericht hat dann nach Billigkeit zu entscheiden, wenn die Parteien es ausdrücklich dazu ermächtigt haben. <sup>2</sup> Die Ermächtigung kann bis zur Entscheidung des Schiedsgerichts erteilt werden. (4) In allen Fällen hat das Schiedsgericht in Übereinstimmung mit den Bestimmungen des Vertrages zu entscheiden und dabei bestehende Landesbräuche zu berücksichtigen.
= § 1052 (ZPO) Entscheidung durch ein Schiedsrichterkollegium.=
= § 1053 (ZPO) Vergleich.=
= § 1054 (ZPO) Form und Inhalt des Schiedsspruchs.=
= § 1055 (ZPO) Wirkungen des Schiedsspruchs.=
= § 1056 (ZPO) Beendigung des schiedsrichterlichen Verfahrens.=
bs2gmqwqnx758df0d7b46h365kykwfv
Ing Mathematik: Numerische Mathematiksysteme am Beispiel von Octave
0
109787
1092409
1091814
2026-10-24T09:15:22Z
Intruder
1513
/* Die IF-Verzweigung */
1092409
wikitext
text/x-wiki
{{Navigation_zurückhochvor_buch|
zurücktext=Maxima|
zurücklink=Ing Mathematik: Computeralgebrasysteme am Beispiel von Maxima|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Julia für Ingenieure|
vorlink=Ing Mathematik: Julia}}
= Hallo Welt und allgemeine Hinweise =
== Was ist Octave ==
* Octave ist eine Software zur numerischen Lösung mathematischer Probleme.
* Octave ist Open-Source (GPL-Lizenz).
* Octave ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Octave ist weitgehend kompatibel zum Numerik-Standardprogramm {{W|Matlab|MATLAB}}.
* Octave ist ein Interpreter.
* Octave als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
{{Wikipedia | GNU Octave}}
== Octave installieren ==
=== MS Windows ===
Laden Sie das aktuelle Octave-Paket von der Webseite [https://octave.org/download] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.
=== Linux ===
Entweder ist Octave bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Dazu gehen Sie auf die Seite [https://wiki.octave.org/Category:Installation], wählen die vorhandene Linux-Variante und folgen der angegebenen Beschreibung (z.B. <code>zypper ... </code> für openSUSE. Oder Sie benutzen unter openSUSE Tumbleweed direkt das Setup-Programm {{W|YaST}}).
== Octave starten ==
=== MS Windows ===
Das Icon für das Octave-Programm doppelklicken (für das Konsolenprogramm ... CLI, für die grafische Benutzeroberfläche ... GUI). Und schon startet das Programm.
[[Datei:octavestart1.jpg]]
=== Linux ===
In einer Linux-Konsole den Befehl "octave" eintippen, mit der RETURN-Taste bestätigen, und das Programm (CLI) startet:
GNU Octave (x86_64-suse-linux-gnu) version 11.1.0
Copyright (C) 1993-2026 The Octave Project Developers.
License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>
This is free software; see the source code for copying conditions.
There is NO WARRANTY, to the extent permitted by law. For details, type 'warranty'.
Home page: <https://octave.org>
Support resources: <https://octave.org/support>
Improve Octave: <https://octave.org/get-involved>
For changes from previous versions, type 'news'.
octave:1>
Um Octave mit der eingebauten GUI zu starten, kann der Befehl <code>octave --force-gui</code> verwendet werden:
[[File:Gnu_Octave_IDE.png|600px]]
Alternativ kann, z.B. unter openSUSE Tumbleweed (mit {{W|KDE Plasma 6|KDE-Plasma}}), die Octave-IDE auch über den Application Launcher im Menü ''Education -> GNU Octave'' gestartet werden.
== Ein paar Worte zur Erklärung ==
Im Folgenden wird immer das Konsolenprogramm (CLI ... Command Line Interface) für die Eingabe von Befehlen benutzt. Erst gegen Ende dieses Textes wird auch kurz auf das GUI von Octave eingegangen.
Teilweise werden Ergebnisse der älteren Octave-Version 3.0.3 dargestellt. Die dargestellten Grafiken und Ausgabetexte können je nach Version leicht voneinander abweichen. Der Text wurde ursprünglich mit der Octave-Version 3.0.3 erstellt und anschließend auf die Versionen 5.2 bis 11.1.0 aktualisiert. Dieser Mischmasch sollte aber kein Problem darstellen.
Getestet wurden die Beispiele ursprünglich unter dem Betriebssystem MS Windows 10, später auch mit MS Windows 11, bzw. mit openSUSE Leap 15.6 (Octave 6.4.0, nur vereinzelt) und ab März 2026 auch mit openSUSE Tumbleweed (ab Octave 10.3.0, nur vereinzelt).
== Ein erstes Programm ==
Kommentare werden in Octave mit dem Prozentzeichen (%) oder alternativ mit der Raute (#) eingeleitet. Sie werden vom Octave-Interpreter ignoriert. Will man kompatibel mit MATLAB bleiben, so ist die Version mit dem %-Zeichen vorzuziehen. Text kann mit der disp-Funktion ausgegeben werden. Starten Sie Octave und geben sie folgende Anweisungen zeilenweise ein
octave-3.0.3.exe:1> % Das ist ein Kommentar
octave-3.0.3.exe:2> # und das auch
octave-3.0.3.exe:3> disp "Hallo Welt!"
Als Ergebnis erhalten Sie
Hallo Welt!
Der Prompt (z.B. octave-3.0.3.exe:1>) ist natürlich abhängig von der Octave-Version und den schon eingegebenen Zeilen. Er ist selbstverständlich nicht einzutippen, sondern wird vom Octave-System geliefert.
Strings können in Octave entweder in Anführungszeichen (") gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.
= Octave als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Octave. Geben Sie dann die Formel
octave-3.0.3.exe:1> 3 * 5
ein, drücken die Taste ENTER/RETURN und erhalten als Ergebnis
ans = 15
Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck <math>\sin\sqrt{15}</math> berechnen :
octave-3.0.3.exe:2> sin(sqrt(15))
ans = -0.6679
Octave kennt eine Handvoll von Konstanten, z.B.:
Zeilenweise Eingabe:
% Die Kreiszahl PI
pi
% Die Eulersche Zahl
e
% Zur Maschinengenauigkeit
eps
Ausgabe:
ans = 3.1416
ans = 2.7183
ans = 2.2204e-016
"ans" steht übrigens für den Begriff "answer" (auf Deutsch "Antwort"). Mit "ans" kann wie mit jeder anderen Variable oder Konstanten weitergerechnet werden, z.B.:
Eingabe:
% Der Kreisradius sei 10
10
% Der Kreis-Umfang mit diesem Radius sei folgendes
2 * pi * ans
Ausgabe:
ans = 10
ans = 62.832
Die Ausgabe eines Befehls am Bildschirm (das "Echo") kann übrigens durch Anwendung des Semikolons (;) unterdrückt werden. Gezeigt werden soll dies nun mit Hilfe des obigen Beispiels. Es soll nur der Umfang ausgegeben werden, nicht der Radius.
Eingabe:
% Der Kreisradius sei 10
10;
% Der Kreis-Umfang mit diesem Radius sei folgendes
2 * pi * ans
Ausgabe:
ans = 62.832
Vielleicht ist manchem die Genauigkeit, mit der Echo bzw. der Befehl disp Werte ausgibt, nicht ausreichend. Dem kann Abhilfe verschafft werden und zwar so:
Eingabe:
format short
pi
format long
pi
format longe
pi
% usw.
Ausgabe:
ans = 3.1416
ans = 3.14159265358979
ans = 3.14159265358979e+00
Beenden lässt sich das Octave-Programm durch Eingabe von quit oder exit (und natürlich zur Bestätigung die RETURN-Taste drücken).
== Die Hilfefunktion von Octave ==
Die Eingabe von help mit Angabe eines Funktionsnamens liefert detaillierte Infos zu der gesuchten Funktion.
Eingabe:
help sin
Ausgabe:
'sin' is a built-in function from the file libinterp/corefcn/mappers.cc
-- Y = sin (X)
Compute the sine for each element of X in radians.
See also: asin, sind, sinh.
Additional help for built-in functions and operators is
available in the online version of the manual. Use the command
'doc <topic>' to search the manual index.
Help and information about Octave is also available on the WWW
at https://www.octave.org and via the help@octave.org
mailing list.
Auch gibt es die doc-Funktion für eine vollständige Dokumentation des Octave-Systems, z.B.:
Eingabe:
doc
Ausgabe:
[[Datei:Octave_730_doc_screenshot.jpg]]
== Sonstige einfache Berechnungen ==
In octave gibt es eine "umgekehrte" Division:
11 / 2 % normale Division (Rechtsdivision)
11 \ 2 % umgekehrte Division (Linksdivision)
Ausgabe:
ans = 5.5000
ans = 0.1818
Potenzieren kann man so:
12^5
Ausgabe:
ans = 248832
Den Modulo-Operator % wie in C/C++, Java oder Python gibt es in Octave '''nicht'''. Das Prozentzeichen ist dem Kommentar vorbehalten. Man kann aber eine Funktion hierfür benutzen
y = mod(20, 3)
Ausgabe:
y = 2
Runden mit und auf Ganzzahlen kann man in Octave so:
a = int32(10);
b = int32(3);
x = a / b
y = int32(15) / int32(4)
Ausgabe:
x = 3
y = 4
Siehe dazu aber auch die Funktionen <code>floor</code>, <code>ceil</code> und <code>idivide</code>.
Mittels <code>int32()</code> werden Zahlen als 32-Bit-Ganzzahlen dargestellt. Standardmäßig ist der Datentyp nämlich <code>double</code>. Das ist zu beachten, es ergeben sich unterschiedliche Ergebnisse.
Beispiel:
clear();
a = int32(10);
b = int32(3);
x = a / b
c = 10;
d = 3;
y = c / d
whos()
Ausgabe:
x = 3
y = 3.3333
Variables visible from the current scope:
variables in scope: top scope
Attr Name Size Bytes Class
==== ==== ==== ===== =====
a 1x1 4 int32
b 1x1 4 int32
c 1x1 8 double
d 1x1 8 double
x 1x1 4 int32
y 1x1 8 double
Total is 6 elements using 36 bytes
Ist der Wertebereich von <code>int32</code> zu klein (4 Bytes, <math>-2^{31}</math> bis <math>2^{31} - 1</math>), so gibt es auch <code>int64</code> (8 Bytes, <math>-2^{63}</math> bis <math>2^{63} - 1</math>).
<code>clear</code> löscht Namen und gibt den Speicherplatz wieder frei. <code>whos()</code> liefert detaillierte Informationen der aktuell definierten Variablen.
== Aufgaben ==
* Berechnen Sie mit Octave den Ausdruck <math>\frac{1}{2}\cdot e^2 \cdot \tan(\pi/3)</math>.
* Berechnen Sie mit Octave den Ausdruck <math>2\; \text{cosd}(60) - 3\sin(\pi/5)</math>. Anmerkung: cosd erwartet den Parameter im Gradmaß (d für "degree"), sin erwartet den Parameter im Bogenmaß.
* Erkunden Sie die Fehlerfunktion "erf" mittels Octave-Hilfe.
* Welche Zahl ergibt sich durch <code>3 / 4 \ 2</code>?
* Welche Zahlen werden durch die folgenden Anweisungen ausgegeben?
idivide(int32(10), int32(3), "fix")
idivide(int32(10), int32(3), "round")
idivide(int32(10), int32(3), "floor")
idivide(int32(10), int32(3), "ceil")
floor(10.3)
ceil(10.3)
= Octave als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.m
% Das ist ein Kommentar
# und das auch
disp "Hallo Welt!"
Skriptdateien müssen mit der Dateiendung .m versehen werden. In der Octave-Konsole fügen Sie den Dateipfad mittels
octave-3.0.3.exe:1> addpath("c:/tmp")
hinzu (es ist der UNIX-spezifische Slash (/) zu benutzen). Alternativ können Sie zumindest unter MS Windows auch einen Doppel-Backslash (\\) einsetzen. Oder Sie wechseln mittels <code>cd c:/tmp</code> direkt ins Verzeichnis <code>c:/tmp</code>.
Danach bringen Sie die Skriptdatei test1.m (sozusagen das Hauptprogramm) zur Ausführung
octave-3.0.3.exe:2> test1
Achtung: Die Datei (die Funktion oder das Hauptprogramm) ist in der Octave-Kommandozeile ohne .m-Dateiendung anzugeben. Wie erwartet ergibt sich folgende Ausgabe am Bildschirm
Hallo Welt!
Zumindest unter Linux können Sie z.B. auch komfortabel den {{W|Shebang|Shebang}} (<code>#!</code>) nutzen. Gegeben sei das Octave-Script
#!/usr/bin/octave
disp("Hallo Welt!");
Gepeichert sei es ebenfalls als <code>test1.m</code>. Starten Sie ein Terminal, wechseln Sie in das entsprechende Arbeitsverzeichnis und geben Sie
./test1.m
ein, so erhalten Sie wieder
Hallo Welt!
als Ausgabe auf dem Terminal. Die Zugriffsberechtigung muss natürlich mittels <code>chmod</code> richtig gesetzt werden. Oder Sie führen direkt Octave mit der Datei <code>test1.m</code> aus:
octave test1.m
Sie sehen, mehrere Wege führen zum Ziel.
== Blockkommentare ==
In neueren Octave-Versionen ab dem Jahr 2009 sind auch Blockkommentare möglich. Blockkommentare werden wie normale Kommentare vom Octave-Interpreter ignoriert.
%{
Das ist ein
Blockkommentar
%}
#{
und das auch
#}
Achtung! Folgendes wäre kein Blockkommentar, sondern ergibt einen Fehler.
#{ Das ist kein
Blockkommentar
#}
Die erste Zeile würde zwar durch das # auskommentiert (Zeilenkommentar), die zweite Zeile aber nicht. Die dritte Zeile ist wieder ein Zeilenkommentar.
== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen.
Gültige Variablenbezeichner wären also:
xyz
x1
_wert
name_anzahl
Da Octave case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
xyz
XYZ
xYz
Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.m gespeichert.
x = 5
y = 10
z = x*y
Bringen Sie die Datei test1.m zur Ausführung, so erhalten Sie folgende Bildschirmausgabe
x = 5
y = 10
z = 50
Normalerweise will man aber nur z anzeigen, die Werte von x und y sind ja bereits bekannt. Dazu fügen Sie an den Anweisungsenden, wie bereits weiter oben erwähnt, bei x und y jeweils ein Semikolon (;) an, um das Anweisungsende explizit zu markieren.
x = 5;
y = 10;
z = x*y
Nun erhalten Sie als Ergebnis nur noch
z = 50
Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben.
x = 5; y = 10; z = x*y
Ausgabe:
z = 50
Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
x = 5;
% inkrementiere x
++x
% x = x - 2
x -= 2
Bildschirmausgabe:
ans = 6
x = 4
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist.
Soll eine Anweisung auf mehrere Zeilen verteilt werden, z.B. weil sie zu lang ist, so kann dies durch Verwendung von drei Punkten (...) geschehen, wie nachfolgend dargestellt.
x = 5;
y = 1000 * x + ...
sin(x/2)
Ausgabe:
y = 5000.6
Diese Drei-Punkte-Methode soll nicht für in Anführungszeichen (") eingeschlossene Strings verwendet werden. Diese Methode ist seit geraumer Zeit "deprecated" und funktioniert mit der Version 9.1.0 gar nicht mehr. Benutzen Sie statt dessen den Backslash (\):
txt = "xxxxxxxxxxxxxxxxxxxx\
yyyyyyyyyyyyyyyyy"
Ausgabe:
txt = xxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyy
Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist in Octave problemlos möglich:
wert = 10
wert = 35.5
wert = "Hallo"
wert = pi
Ausgabe:
wert = 10
wert = 35.500
wert = Hallo
wert = 3.1416
Der Befehl <code>who</code>, bzw. <code>whos</code> listet die gegenwärtig definierten Variablen, z.B.:
clear;
a = 10.5;
v = [1 2 3 4 5 12 13];
m = ["s1", "s2"; "s3", "s4"];
disp "***** Der Befehl who *****"
who
disp "***** Der Befehl whos *****"
whos
Ausgabe:
***** Der Befehl who *****
Variables visible from the current scope:
a m v
***** Der Befehl whos *****
Variables visible from the current scope:
variables in scope: top scope
Attr Name Size Bytes Class
==== ==== ==== ===== =====
a 1x1 8 double
m 2x4 8 char
v 1x7 56 double
Total is 16 elements using 72 bytes
==Hexadezimale und binäre Zahlen==
% Hexadezimale Zahl
disp( 0xABC )
% Binäre Zahl
disp( 0b1000011 )
Ausgabe (als Dezimalzahlen):
2748
67
Octave kann auch dezimale in binäre Zahlen etc. umwandeln:
dec2bin( 214 )
Ausgabe:
ans = 11010110
Siehe dazu in der Octave-Hilfe auch folgende Funktionen:
bin2dec, dec2base, dec2hex, hex2dec, base2dec
== Zahlenkolonnen ==
Eine Zahlenkolonne (oder ein Vektor) mit gleichen Abständen der Werte kann folgendermaßen erzeugt werden:
% a ... Startwert
% b ... Schrittweite
% c ... Endwert
a = 0;
b = 10;
c = 100;
x = a : b : c;
disp(x);
Ausgabe:
0 10 20 30 40 50 60 70 80 90 100
Ähnliche Resultate lassen sich auch durch Anwendung der linspace-Funktion erhalten, z.B.:
% a ... Startwert
% b ... Endwert
% c ... Anzahl der Werte
a = 0;
b = 100;
c = 11;
v = linspace(a, b, c)
Ausgabe:
v =
0 10 20 30 40 50 60 70 80 90 100
== Verzweigungen ==
=== Die IF-Verzweigung ===
Die IF-Verzweigung ist aus anderen Programmiersprachen bereits bekannt. In Pseudocode lässt sie sich folgendermaßen darstellen:
WENN bedingung TRUE
führe block1 aus
SONST
führe block2 aus
ENDE
Die test1.m-Datei laute also wie folgt:
x = 5;
if x < 4
disp "x ist kleiner als 4";
else
disp "Der else-Zweig wird ausgefuehrt";
disp "x ist groesser oder gleich 4";
end
Ausgabe:
Der else-Zweig wird ausgefuehrt
x ist groesser oder gleich 4
Octave kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:
* <, <= ... kleiner (gleich)
* >, >= ... größer (gleich)
* == ... gleich
* ~=, != ... ungleich
* &, && ... AND
* |, || ... OR
* ~, ! ... NOT
Beispielsweise:
a = 5;
b = 9;
if a<=10 & b!=7
disp("OK");
else
disp("Nicht OK");
end
Ausgabe:
OK
Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen <math>\varepsilon</math>-Wert) vorgeben.
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:
i = 0.1 + 0.2;
disp(i)
if(i == 0.3)
disp("OK");
else
disp("NOK");
end
Ausgabe:
0.3000
NOK
Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist.
Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:
ist = 0.1 + 0.2;
soll = 0.3;
epsilon = 0.000001;
disp(ist);
if(abs(ist-soll) < epsilon)
disp("OK");
else
disp("NOK");
end
Ausgabe:
0.3000
OK
=== Die SWITCH-Verzweigung ===
In Pseudocode:
WECHSLE ZU var
FALLS wert1 == var
führe block1 aus
FALLS wert2 == var
führe block2 aus
...
SONST
führe blockn aus
ENDE
Eine Beispielsimplementierung in Octave könnte so aussehen:
x = "g";
switch(x)
case "k"
disp("klein");
case "g"
disp("gross");
otherwise
disp("sonstiges")
end
Ausgabe:
gross
Anmerkungen für C-Programmierer:
* in Octave darf zum Abschluß von ''case'' kein Doppelpunkt folgen (würde einen Syntaxfehler auslösen).
* ein ''break'' als Abschluß eines ''case''-Blocks ist nicht erlaubt (würde in Octave einen parse error auslösen). ''break'' ist Schleifen vorbehalten. ''switch'' hat in Octave keinen "Durchfall" und ähnelt somit eher der Fortran-Anweisung ''select case''.
Mehrere Fälle in einem ''case'' können wie nachfolgend behandelt werden:
x = "K";
switch(x)
case {"k" "K"}
disp("klein");
case {"g" "G"}
disp("gross");
otherwise
disp("sonstiges")
end
Ausgabe:
klein
== Schleifen ==
=== Die WHILE-Schleife ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt.
In Pseudocode:
SOLANGE bedingung TRUE
führe block aus
ENDE
In Octave:
x = 0;
while x <= 10
disp(x);
x++;
end
Ausgabe:
0
1
2
3
4
5
6
7
8
9
10
=== Die DO-UNTIL-Schleife ===
Die DO-UNTIL-Schleife ist fußgesteuert. Beachte: Diese Schleife ist nicht äquivalent zu der aus anderen Programmiersprachen bekannten DO-WHILE-Schleife. DO-WHILE bedeutet "TUE SOLANGE", DO-UNTIL bedeutet "TUE BIS". Sie wird mindestens einmal ausgeführt.
Pseudocode:
TUE
führe block aus
BIS bedingung TRUE
Mittels Octave:
x = 0;
do
disp(x);
x++;
until(x >= 5)
Ausgabe:
0
1
2
3
4
=== Die FOR-Schleife ===
for x = 0 : 2 : 10
disp(x);
end
Ausgabe:
0
2
4
6
8
10
Der FOR-Schleifenkopf ist in Form einer Zahlenkolonne folgendermaßen aufgebaut:
for variable = startwert : schrittweite : endwert
Man beachte, dass Vektorisierung gegenüber einem Schleifendurchlauf eine erhebliche Zeiteinsparung bewirken kann (man siehe in der [https://docs.octave.org/latest/Vectorization-and-Faster-Code-Execution.html Octave-Dokumentation das Kapitel 19 "Vectorization and Faster Code Execution"]). Folgendes Beispiel ist an genanntes Octave-Kapitel angelehnt. Zuerst wird eine Berechnung mittels Schleifendurchlauf durchgeführt und der Zeitbedarf ausgegeben. Dieser Zeitbedarf hängt natürlich auch von der verwendeten Hardware etc. ab.
Eingabe:
n = m = 500;
a = b = eye(500);
t1 = time();
for i = 1:n
for j = 1:m
c(i,j) = a(i,j) + b(i,j);
endfor
endfor
t2 = time();
t_diff = t2-t1
Ausgabe:
t_diff = 3.7566
Der Zeitverbrauch beträgt hier also ca. 4 Sekunden. Im Gegensatz dazu
Eingabe:
a = b = eye(500);
t1 = time();
c = a + b;
t2 = time();
t_diff = t2-t1
Ausgabe:
t_diff = 1.5974e-05
ist der Zeitverbrauch hier sehr gering. Vektoren und Matrizen werden etwas später in diesem Text detailliert behandelt. Hier nur soviel: Mittels ''eye'' wird eine Einheitsmatrix kreiert.
Octave hat im Gegensatz zu MATLAB keinen {{W|Just-in-time-Kompilierung|JIT-Compiler}} (JIT ... '''J'''ust '''i'''n '''T'''ime). Darum ist Vektorisierung gerade hier von eminenter Bedeutung.
=== Schleifen abbrechen ===
Zum Abbrechen einer Schleife gibt es den Befehl "break".
for var = 0 : 1 : 100
disp (var);
if var == 5
break;
end
end
Ausgabe:
0
1
2
3
4
5
"continue" setzt mit dem nächsten Schleifendurchlauf fort, z.B.
for var = 0 : 1 : 10
if var == 5
continue;
end
disp (var);
end
Ausgabe:
0
1
2
3
4
6
7
8
9
10
== Aufgaben ==
* Berechnen Sie die Summe der ersten 10000 natürlichen Zahlen (bei 1 beginnend)
** in Form einer WHILE-Schleife
** in Form einer DO-UNTIL-Schleife
** in Form einer FOR-Schleife
** mittels sum-Befehl (siehe dazu auch die von Octave zur Verfügung gestellte Hilfefunktion).
** mittels gaußscher Summenformel (<math>\sum_{i=1}^n{i} = 1+2+...+n = n(n+1) / 2</math>)
* Schreiben Sie für obige Alternativen Programme mit denen der Zeitbedarf der Schleifen, Befehle bzw. Formeln gemessen werden kann. Welche Alternativen sind aus Zeitgründen (minimale Laufzeit) empfehlenswert?
= Grafiken zeichnen =
== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall <math>x\in[-3,3]</math> gezeichnet werden. Der Programmcode lautet in der einfachsten Form:
x = -3 : .1: 3;
y = cosh(x);
plot(x,y);
grid on;
Ausgabe:
[[Datei:octave_cosh.jpg]]
Der Code ist quasi selbsterklärend. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. "plot" ist der Zeichenbefehl. "grid on" schaltet ein Zeichengitter ein.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen.
Sie könnten nun auf die Idee kommen, obiges Script unter Linux mit der Shebang-Zeile zu erweitern, um es direkt als Programm auszuführen.
#!/usr/bin/octave
x = -3 : .1: 3;
y = cosh(x);
plot(x,y);
grid on;
Die Enttäuschung folgt auf dem Fuß. Außer einem kurzen Aufblinken des Grafikfensters ist nicht viel zu sehen. Das Programm läuft einfach durch und wird nach der letzten Anweisung beendet. Abhilfe kann z.B. der <code>input</code>-Befehl schaffen:
#!/usr/bin/octave
x = -3 : .1: 3;
y = cosh(x);
plot(x,y);
grid on;
refresh();
input("Zum Beenden RETURN-Taste drücken");
Das Programm wartet somit, bis Sie im Terminal die RETURN-Taste drücken. <code>refresh()</code> dient dazu, das Grafikfenster unmittelbar zu aktualisieren. Sonst würde das Ausgabefenster leer bleiben, bis es durch externe Anreize aktualisiert wird (z.B. durch Fenster minimieren/maximieren). Gleiches gilt für die <code>octave test1.m</code>-Variante.
Ein etwas komplexeres Beispiel ist Folgendes
x = -3 : .1: 3;
y = cosh(x) + 2.^x;
plot(x,y);
grid on;
Man beachte den Punkt bei 2.^x (2 hoch x). Vergisst man den Punkt, dann erhält man eine Fehlermeldung (ähnlich dieser):
error: for x^y, only square matrix arguments are permitted and one argument must be scalar. Use .^ for elementwise power.
error: called from
test1 at line 2 column 3
Ausgabe:
[[Datei:octave_cosh2.jpg]]
Der Funktionsgraph kann auch als Fläche eingefärbt werden:
x = -3 : .1: 3;
y = cosh(x) + 2.^x;
fill (x, y, "b");
Ausgabe:
[[Datei:octave_cosh3.jpg | 500px]]
=== Graphen mehrerer Funktionen und weiteres ===
Mehrere Graphen lassen sich folgendermaßen in ein Fenster zeichnen:
x = -3 : .1: 3;
y1 = cosh(x) + 2.^x;
y2 = sin(x) .* cos(x);
plot(x,y1, x,y2);
title("Funktionsgraphen");
legend("cosh ...", "sin ...");
xlabel("x");
ylabel("y");
grid on;
[[Bild:octave_cosh14.jpg|600px]]
Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht:
x = -3 : .1: 3;
y1 = cosh(x) + 2.^x;
y2 = sin(x) .* cos(x);
plot(x,y1,"*r", x,y2,"ob");
title("Funktionsgraphen");
legend("cosh ...", "sin ...");
xlabel("x");
ylabel("y");
grid on;
[[Datei:octave_cosh4.jpg]]
Bei plot kann auch der Linienstil des jeweiligen Graphen angegeben werden, z.B. steht
* für Sternchenlinie
o für Kreise in der Linie
r für rot
b für blau
Ein ähnliches Resultat liefert der Code:
x = -3 : .1: 3;
y1 = cosh(x) + 2.^x;
y2 = sin(x) .* cos(x);
plot(x,y1, "Color", "red", "*", x,y2, "Color", "blue", "o");
title("Funktionsgraphen");
legend("cosh ...", "sin ...");
xlabel("x");
ylabel("y");
grid on;
Will man mehrere Graphen in ein Fenster zeichnen, aber nicht alles in einen plot-Befehl quetschen, so kann die "hold on"-Anweisung die Lösung des Problems sein:
%Lösche alle benutzerdefinierten Variablen aus der Symboltabelle
clear;
%Schließe alle Fenster
close all;
%Lösche Konsolenfenster und setze Cursor zurück
clc;
x = -3 : .1: 3;
y1 = cosh(x) + 2.^x;
y2 = sin(x) .* cos(x);
plot(x,y1, "Color", "red");
hold on;
plot(x,y2, "Color", "blue");
title("Funktionsgraphen");
legend("cosh ...", "sin ...");
xlabel("x");
ylabel("y");
grid on;
[[Datei:octave_coshsin1.jpg]]
Bei diesem Program wurden auch einige Möglichkeiten (clear, close, clc) gezeigt, um das System aufzuräumen. Ein "hold off" würde natürlich die hold-Funktion wieder ausschalten.
=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale <math>x = t \cos(t), y = t \sin(t)</math> im Intervall <math>[0, 6\pi]</math> gezeichnet werden.
clear;
close all;
clc;
t = 0 : .1: 6*pi;
x = t .* cos(t);
y = t .* sin(t);
plot(x,y);
grid on;
[[Datei:octave_spirale1.jpg]]
Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den axis-Befehl verwenden (axis muss nach plot erscheinen).
t = 0 : .1: 6*pi;
x = t .* cos(t);
y = t .* sin(t);
plot(x,y);
grid on;
axis equal;
[[Datei:octave_spirale222.jpg]]
=== Strichstärke ===
Für manche Zwecke ist es sinnvoll die Strichstärke des Graphen zu erhöhen. Dies kann über den Parameter "LineWidth" der plot-Funktion geschehen.
t = 0 : .1: 6*pi;
x = t .* cos(t);
y = t .* sin(t);
plot(x,y, "LineWidth", 2);
grid on;
axis equal;
Ausgabe:
[[Datei:octave_spirale3.jpg]]
=== Beliebigen Text ausgeben ===
x = -10:0.1:10;
plot (x, sin (x), "LineWidth", 2);
text (2.7, 0.8, "Das ist die sin-Funktion");
Ausgabe:
[[Datei:octave_text1.jpg]]
=== Logarithmische Achseneinteilung ===
x = -3 : .1: 3;
y = cosh(x) + 2.^x;
% Halblogarithmische Darstellung
semilogy(x,y);
grid on;
Ausgabe:
[[Datei:octave_semilog1.jpg]]
Auch die x-Achse kann mit "semilogx" logarithmisch skaliert werden. Mit "loglog" werden beide Achsen logarithmisch skaliert.
=== Aufgaben ===
* Zeichnen Sie die Strophoide <math>x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3</math>. Das Ganze sollte in etwa so aussehen wie folgende Grafik:
[[Datei:octave_strophoide.jpg]]
* Zeichnen Sie die verschlungene Hypozykloide <math>x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15</math>. Das Ganze sollte in etwa so aussehen wie folgende Grafik:
[[Datei:octave_hypozykloide.jpg]]
* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben (Hinweis: Siehe dazu auch die Octave-Hilfefunktion für den plot-Befehl).
* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.
* Erkunden Sie in der Octave-Hilfe den ezplot-Befehl.
== Gitterlinien und Koordinatenachsen ==
* Zwischengitterlinien aktivieren: <code>grid minor;</code>
* Gitterabstände exakt selbst festlegen, z.B.: <code>set(gca, "XTick", -10 : 1 : 10);</code>
* Gitterfarben und -linienstile anpassen, z.B.:
set(gca, 'GridColor', [0.1, 0.1, 0.1]);
set(gca, 'GridLineStyle', '-');
set(gca, 'MinorGridColor', [0.2, 0.2, 0.2]);
set(gca, 'MinorGridLineStyle', '--');
* Koordinatenachsen selbst festlegen, z.B.
axis([-2, 10, -3, 8]); % x-Achse von -2 bis 10, y-Achse von -3 bis 8
* Markierungen auf den Achsen einstellen, z.B. <code>xticks(0:1:10);</code>
* Achsenkreuz auf 0 setzen:
set(gca, "xaxislocation", "origin");
set(gca, "yaxislocation", "origin");
* Umhüllende Linien abschalten: <code>box off;</code>
<code>gca</CODE> steht übrigens für '''g'''et '''c'''urrent '''a'''xes. Analog dazu gibt es auch <code>gcf</code> ('''g'''et '''c'''urrent '''f'''igure) und <code>gco</code> ('''g'''et '''c'''urrent '''o'''bject). Das ist aber alles schon sehr speziell und wird hier nicht vertieft.
=== Aufgabe ===
Probieren Sie die oben stichpunktartig angegebenen Möglichkeiten an konkreten Programmbeispielen aus.
== 3D ==
=== Räumliche Kurven ===
Mittels "plot3" lassen sich Raumkurven zeichnen.
t = 0 : .1 : 9*pi;
x = cos(t);
y = sin(t);
z = 1.3 .^ t;
plot3(x,y,z);
grid on;
[[Datei:octave_raumkurve1.jpg]]
=== Flächen ===
==== ezsurf ====
Die wahrscheinlich einfachste Möglichkeit 3D-Flächen zu erzeugen, besteht in der Verwendung des ezsurf-Befehls. Beachten Sie beim folgenden Beispiel auch wieder den Punkt beim Multiplikationssymbol (elementweise Multiplikation soll verwendet werden, keine Matrizenmultiplikation) in der anonymen Funktion. Was eine anonyme Funktion ist, wird weiter hinten in diesem Text kurz erklärt. Fürs Erste reicht es zu wissen, dass die Funktion f(x, y) jeweils im Intervall [0, 10] gezeichnet werden soll.
clear; close all; clc; clf;
f = @(x, y) sin(x) + 3.*cos(y);
ezsurf (f, [0, 10]);
[[Bild:octave_ezsurf1.jpg|600px]]
Dieses Bild wurde mit der Octave-Version 5.2 erstellt. Es ist im Prinzip identisch zu jenen des folgenden Abschnitts, die mit der Version 3.0.3 erstellt wurden, nur die Farbschattierung ist anders. Ändern lässt sich diese Eigenschaft mit dem colormap-Befehl (siehe auch Octave-Hilfe):
clear; close all; clc; clf;
colormap(hot);
f = @(x, y) sin(x) + 3.*cos(y);
ezsurf (f, [0, 10]);
[[Bild:octave_colormap_hot.jpg|600px]]
==== surf und mesh ====
Für das Zeichnen von Flächen existiert der surf-Befehl. Der meshgrid-Befehl kreiert ein Netz in der xy-Zeichenebene. Beachten Sie beim folgenden Beispiel auch wieder den Punkt beim Multiplikationssymbol der Formel für z.
x = 0 : .1 : 10;
y = 0 : .1 : 10;
[x_grid, y_grid] = meshgrid(x, y);
z = sin(x_grid) + 3.*cos(y_grid);
surf(x_grid, y_grid, z);
[[Datei:octave_flaeche1.jpg]]
Auch ein Farbstreifen kann via "colorbar" zur Grafik hinzugefügt werden.
x = 0 : .1 : 10;
y = 0 : .1 : 10;
[x_grid, y_grid] = meshgrid(x, y);
z = sin(x_grid) + 3.*cos(y_grid);
surf(x_grid, y_grid, z);
colorbar("East");
[[Datei:octave_flaeche2.jpg]]
Das Ganze in Netzdarstellung läßt sich so programmieren:
x = 0 : .2 : 10;
y = 0 : .2 : 10;
[x_grid, y_grid] = meshgrid(x, y);
z = sin(x_grid) + 3.*cos(y_grid);
mesh(x_grid, y_grid, z);
Ausgabe:
[[Datei:octave_mesh1.jpg]]
==== Ellipsoide und Kegel ====
Für das Zeichnen von Kugeln oder Ellipsoiden stellt Octave den "sphere"-Befehl bzw. den "ellipsoid"-Befehl zur Verfügung.
clear; close all; clc;
% Ellipsoiden zeichnen
[x, y, z] = sphere(30);
surf(5*x, 4*y, 3*z);
hold on;
[x, y, z] = ellipsoid(5, 5, 5, 6, 3, 2, 30);
surf(x, y, z);
axis equal;
[[Bild:octave_ellipsoid2.jpg|600px]]
Für Zylinder und Kegel ist der "cylinder"-Befehl zuständig.
clear; close all; clc;
% Kegel und Zylinder zeichnen
[x, y, z] = cylinder([1 2], 100);
surf(x, y, z*3);
hold on;
[x, y, z] = cylinder([0.5 0.5], 50);
surf(x+3, y, z*2);
axis equal;
[[Bild:octave_cylinder2.jpg|600px]]
=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve <math>x = 2 \cdot \cosh(t)</math>, <math>y = 5 \cdot \sin(t)</math>, <math> z = t^{2} - t</math>, <math>0 \leq t \leq 3\pi</math>. Das Ganze sollte etwa wie folgt aussehen:
[[Datei:octave_kurve10.jpg]]
* Zeichnen Sie die Fläche <math>z = \log(x) + \cos(y)</math>. Das Ganze sollte etwa wie folgt aussehen:
[[Datei:octave_flaeche10.jpg]]
== Weiteres ==
=== subplot ===
Zeichnen mit Untergrafiken: Hier wird z.B. ein Fenster mit drei Untergrafiken gezeichnet.
Eingabe:
t = 0 : .5 : 10;
[x_grid, y_grid] = meshgrid(t, t);
subplot(311);
surf(x_grid, y_grid, sin(x_grid) + cos(y_grid) );
subplot(312);
surf(x_grid, y_grid, sin(x_grid) + log(y_grid) );
subplot(313);
surf(x_grid, y_grid, x_grid + cos(y_grid) );
Ausgabe:
[[Datei:octave_subplot2.jpg]]
Die dreistellige Ziffer beim subplot-Befehl bedeutet folgendes:
* Die erste Ziffer ist die Zeilenanzahl
* Die zweite Ziffer ist die Reihenanzahl und
* Die dritte Ziffer ist der Index.
Beim obigen Beispiel ist die z-Achse ein bisschen zusammengedrückt. Dies wollen wir mit nachfolgendem Code ansatzweise "verbessern" und ein paar weitere Spielereien mit Subplots durchführen.
t = 0 : .5 : 10;
[x_grid, y_grid] = meshgrid(t, t);
% fig = figure();
ax1 = subplot(4, 1, 1:2);
surf(x_grid, y_grid, sin(x_grid) + cos(y_grid) );
grid(ax1, "minor");
axis(ax1, [0, 10, 0, 20, -2, 2]);
ax2 = subplot(413);
surf(x_grid, y_grid, sin(x_grid) + log(y_grid) );
ax3 = subplot(414);
surf(x_grid, y_grid, x_grid + cos(y_grid) );
% refresh();
% input();
[[Datei:octave_subplot105.svg| 400px]]
Nun sei ein Beispiel mit 3x2-Untergrafiken angeführt.
clear;
close all;
clc;
x = 0 : .1 : 10;
subplot(321);
plot(x, sin(x));
text(2, -0.5, "Index 1");
subplot(322);
plot(x, tan(x));
text(2, 2, "Index 2");
subplot(323);
plot(x, cosh(x) );
text(2, 3000, "Index 3");
subplot(324);
plot(x, gamma(x) )
text(2, 100000, "Index 4");
subplot(325);
plot(x, log(x) );
text(2, 0, "Index 5");
subplot(326);
plot(x, exp(x) );
text(2, 10000, "Index 6");
Ausgabe:
[[Datei:octave_subplot3.jpg]]
Hier ist sehr gut zu sehen, in welcher Reihenfolge der Index läuft.
Will man bspw. die Hintergrundfarbe eines Subplots setzen (z.B. auf die Farbe rot), so kann dies über folgende Befehle geschehen:
ax1 = subplot(321);
set(ax1, "color", [1.0, 0.0, 0.0]);
=== figure ===
Zeichnen in verschiedene Fenster, z.B.
clear;
close all;
clc;
x = 0 : .1 : 10;
y = 0 : .1 : 10;
[x_grid, y_grid] = meshgrid(x, y);
figure(1)
surf(x_grid, y_grid, sin(x_grid) + cos(y_grid));
figure(2)
surf(x_grid, y_grid, sin(x_grid) + log(y_grid));
Ausgabe:
[[Datei:octave_figure111.jpg|700px]]
Die Größe und Position eines Fensters können festgelegt werden:
f1 = figure(1, "Position", [100, 100, 800, 600]);
Hintergrundfarbe setzen
f2 = figure(2, 'Color', [1.0, 0.0, 0.0]);
oder auch per
set(f1, 'Color', [1.0, 0.0, 0.0]);
=== Linien zeichnen ===
Zeichnen Sie eine Linie von der Koordinate [-15, 0] zu [15, 5]:
clear;
close all;
clc;
x = line([-15 15], [0, 5], "Color", "black", "LineWidth", 2);
Ausgabe:
[[Datei:octave_linie1.jpg]]
Man beachte, dass Octave nicht Punkte P1(x1, y1), P2(x2, y2) erwartet, sondern einen x-Vektor [x1 x2] und einen y-Vektor [y1 y2].
Ein allgemeines Viereck wird z.B. mit folgendem Befehl gezeichnet.
line([-15 15 10 -5, -15], [0, 5, 20, 15, 0], "LineWidth", 2);
[[Datei:octave_viereck2.jpg]]
Auch dreidimensionale Formen lassen sich mit dem line-Befehl zeichnen:
clear; close all; clc;
line([-15 15 10 -5, -15], [0, 5, 20, 15, 0], [10, 20, 30, 40, 50], "LineWidth", 2);
[[Datei:octave_dreidim2.jpg]]
=== Aufgaben ===
* Zeichnen Sie mittels "subplot" die Funktionsgrafen <math>y_1=\tan(x), y_2=\tan(2x), y_3=\tan\sqrt x, y_4=x\cdot \tan(x)</math> in folgender Form in ein Fenster:
** in 2x2-Darstellung
** in 1x4-Darstellung.
* Zeichnen Sie die im obigen Beispiel angegebenen Funktionsgrafen mittels "figure" jeweils in ein eigenes Fenster.
= Vektoren und Matrizen =
== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein.
=== Zeilen- und Spaltenvektoren ===
% Ein Zeilenvektor
v1 = [1, 2, 3]
% Ein Spaltenvektor
v2 = [6; 7; 8]
Ausgabe:
v1 =
1 2 3
v2 =
6
7
8
Alternative Schreibweisen:
% Ein Zeilenvektor
v1 = [1 2 3]
% Ein Spaltenvektor
v2 = [6
7
8]
Die Ausgabe entspricht der obigen Darstellung.
=== Zugriff auf Vektorelemente ===
Nachfolgend seien einige Zugriffsmöglichkeiten auf die einzelnen Vektorelemente erläutert.
Auf ein einzelnes Element kann via Index zugegriffen werden. Der Index startet bei 1:
v1 = [1 2 4 8 16];
v2 = v1(3)
Ausgabe:
v2 = 4
Mehrere Elemente werden folgendermaßen angesprochen:
v1 = [1 2 4 8 16];
v2 = v1(3:4)
Ausgabe:
v2 =
4 8
Liefere den Teilvektor von einem gegebenen Index bis zum letzten Element:
v1 = [1 2 4 8 16];
v2 = v1(3:end)
Ausgabe:
v2 =
4 8 16
=== Addition und Subtraktion von Vektoren ===
v1 = [1, 2, 3];
v2 = [5, 7, 9];
res = v1 + v2
res = v1 - v2
Ausgabe:
res =
6 9 12
res =
-4 -5 -6
=== Multiplikation mit Skalaren ===
faktor = 3;
v = [1, 2, 3];
res = faktor * v
Ausgabe:
res =
3 6 9
=== Skalarprodukt ===
Das Skalarprodukt ist bekanntermaßen als <math>v_1 \cdot v_2 = |v_1| |v_2| \cos(\angle(v_1, v_2))</math> definiert. In Octave sieht das so aus:
v1 = [1, 2, 3];
v2 = [5, 6, 7];
res = dot(v1, v2)
Ausgabe:
res = 38
=== Vektorprodukt ===
v1 = [1, 2, 3];
v2 = [5, 6, 7];
res = cross(v1, v2)
Ausgabe:
res =
-4 8 -4
Enger an die mathematische Darstellung lehnt sich folgender Code an. Die zu multiplizierenden Vektoren seien in Form von Spaltenvektoren gegeben.
Mathematisch:
<math>a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
</math>
Octave-Code:
a = [1
2
3];
b = [5
6
7];
res = cross(a, b)
Ausgabe:
res =
-4
8
-4
=== Transponierter Vektor ===
v1 = [1, 2, 3];
v2 = [5; 6; 7];
res1 = v1'
res2 = v2'
Ausgabe:
res1 =
1
2
3
res2 =
5 6 7
=== Einige weitere Vektorfunktionen ===
Beispiel:
% 1 + 2 + 3
v = [1 2 3];
sum(v)
Ausgabe:
ans = 6
Beispiel:
% 1 * 2 * 3 * 4
v = [1 2 3 4];
prod(v)
Ausgabe:
ans = 24
Beispiel:
% 1^2 + 2^2 + 3^2
v = [1 2 3];
sumsq (v)
Ausgabe:
ans = 14
== Matrizen ==
Gegeben sei folgende 2x3-Matrix <math>m=\left(\begin{array}{ccc}
1 & 2 & 3\\
4 & 5 & 6
\end{array}\right)</math>.
Eingabe:
m = [1, 2, 3; 4, 5, 6]
Ausgabe:
m =
1 2 3
4 5 6
Alternativ und anschaulicher kann diese 2x3-Matrix auch so eingegeben werden:
m = [1 2 3
4 5 6]
Dies ist schon sehr nahe an der mathematischen Darstellungsweise.
=== Zugriff auf Matrizenelemente ===
m = [1 2 3
4 5 6];
% Element aus Zeile 2 und Spalte 3
m(2,3)
Ausgabe:
ans = 6
Eine andere Zugriffsmöglichkeit ist diese:
m = [1 2 3
4 5 6];
% Auf das fünfte Element soll zugegriffen werden
m(5)
Ausgabe:
ans = 3
Die Matrix wird also spaltenweise durchlaufen (nicht zeilenweise). Dies ist vielleicht auf den ersten Blick etwas ungewöhnlich, wird aber z.B. auch in Fortran so gehandhabt.
Auch Teilmatrizen können einfach gebildet werden:
m = [1 2 3
4 5 6];
m(2:end, 2:end)
Ausgabe:
ans =
5 6
Siehe zu diesem Thema auch etwas weiter hinten in diesem Text den Abschnitt "Teilmatrizen".
=== Addition und Subtraktion von Matrizen ===
m1 = [1, 2, 3; 4, 5, 6];
m2 = [-4, -2, 0; 2, 4, 6];
m1 + m2
m1 - m2
Ausgabe:
ans =
-3 0 3
6 9 12
ans =
5 4 3
2 1 0
=== Transponierte Matrix ===
m = [1, 2, 3; 4, 5, 6];
m'
Ausgabe:
ans =
1 4
2 5
3 6
=== Rang einer Matrix ===
Der Rang einer Matrix Rg(M) ist die maximale Anzahl der linear unabhängigen Zeilenvektoren (Spaltenvektoren).
m1 = [1, 2, 3; 4, 5, 6];
m2 = [1, 2; 2, 4];
rank(m1)
rank(m2)
Ausgabe:
ans = 2
ans = 1
Regulär ist eine nxn-Matrix, wenn der Rg(M) = n. D.h. die erste Matrix m1 ist regulär, die zweite m2 singulär.
=== Inverse Matrix ===
m1 = [1, 3; 0, -5 ];
m2 = [1, 2; 2, 4];
inv(m1)
inv(m2)
Ausgabe:
ans =
1.00000 0.60000
0.00000 -0.20000
warning: matrix singular to machine precision
warning: called from
test1 at line 4 column 1
ans =
Inf Inf
Inf Inf
Die Matrix m2 in diesem Beispiel ist singulär (d.h. die Determinante ist 0). Determinanten werden etwas weiter unten in diesem Text behandelt. Inf steht für Infinity (= Unendlich).
=== Multiplikation von Matrizen (falksches Schema) ===
m1 = [1, 3, 4; 0, -5, 1];
m2 = [1, 2; 2, 3; 0, 2];
m1 * m2
Ausgabe:
ans =
7 19
-10 -13
Will man aus irgendwelchen Gründen nicht das falksche Schema ausführen, sondern elementweise Multiplikation, so funktioniert das mit dem Punkt-Operator, z.B.
m1 = [1, 3; 0, -5];
m2 = [1, 2; 4, 2];
% falksches Schema
m1 * m2
% elementweise Multiplikation
m1 .* m2
Ausgabe:
ans =
13 8
-20 -10
ans =
1 6
0 -10
Verifikation, falksches Schema (Zeile*Spalte):
[ 1 3 ] [ 1 2 ] [ 1*1+3*4 1*2+3*2 ] [ 13 8 ]
[ 0 -5 ] [ 4 2 ] = [ 0*1-4*5 0*2-5*2 ] = [ -20 -10 ]
Verifikation, elementweise Multiplikation (homologe Elemente):
[ 1 3 ] [ 1 2 ] [ 1*1 3*2 ] [ 1 6 ]
[ 0 -5 ] [ 4 2 ] = [ 0*4 -5*2 ] = [ 0 -10 ]
=== Determinante einer Matrix ===
m1 = [1, 3; 0, -5 ];
m2 = [1, 2; 2, 4];
det(m1)
det(m2)
Ausgabe:
ans = -5
ans = 0
m1 ist regulär, m2 ist singulär. Determinanten können nur von quadratischen Matrizen gebildet werden.
=== Teilmatrizen ===
m = [1, 2, 3; 0, 5, 1];
% Die Matrix in einen Spaltenvektor umwandeln
m1 = m(:)
% Das Element aus der 1. Zeile und der 2. Spalte extrahieren
m2 = m(1,2)
% Erste Zeile extrahieren
m3 = m(1, 1:3)
m4 = m(1, :)
% Zweite Spalte extrahieren
m5 = m(1:2, 2)
m6 = m(:, 2)
Ausgabe:
m1 =
1
0
2
5
3
1
m2 = 2
m3 =
1 2 3
m4 =
1 2 3
m5 =
2
5
m6 =
2
5
=== Einheitsmatrizen ===
eye(3,2)
Ausgabe:
ans =
1 0
0 1
0 0
=== Nullmatrizen ===
zeros(2,3)
Ausgabe:
ans =
0 0 0
0 0 0
=== Diagonalmatrizen ===
diag([1, 2, 3])
Ausgabe:
ans =
1 0 0
0 2 0
0 0 3
=== Spur einer Matrix ===
trace([1,2,3; 6,9, 0])
Ausgabe:
ans = 10
=== LR-Zerlegung einer Matrix ===
Führen Sie die LR-Faktorisierung (LR ... links/rechts bzw. LU ... left/upper) einer Matrix m aus. l sei die linke Dreiecksmatrix, r die rechte Dreiecksmatrix und p die Permutationsmatrix
m = [1 0 5
-1 1 -2
0 0 3];
[l, r, p] = lu(m)
Ausgabe:
l =
1 0 0
-1 1 0
0 0 1
r =
1 0 5
0 1 3
0 0 3
p =
1 0 0
0 1 0
0 0 1
=== Eigenwerte ===
a = [5 8
1 3];
% Eigenvektoren und Eigenwerte
[ev, ew] = eig(a)
Ausgabe:
ev =
0.9701 -0.8944
0.2425 0.4472
ew =
Diagonal Matrix
7 0
0 1
Die Eigenwerte sind hier <math>\lambda_1 = 7</math> und <math>\lambda_2 = 1</math>. Die Eigenvektoren sind [0.9701 0.2425] bzw. [-0.8944 0.4472]. Da das Gleichungssystem <math>(A - \lambda_i E) x_i = 0</math> singulär ist, sind alle Lösungsvektoren Vielfache dieser Eigenvektoren.
=== Schwach besetzte Matrizen ===
{{Wikipedia | Dünnbesetzte Matrix}}
Gegeben sei die schwach besetzte Matrix
m = [0 1 0 0 0
0 0 0 3 0
4 0 0 2 0
0 0 1 0 0
0 0 0 1 7]
Mittels dem sparse-Befehl kann man einfach die Elemente != 0 nach folgendem Schema eingeben.
sparse ([zeilenindizes] [spaltenindizes] [werte])
also in unserem Fall:
ms = sparse([1 2 3 3 4 5 5], [2 4 1 4 3 4 5], [1 3 4 2 1 1 7])
Ausgabe:
ms =
Compressed Column Sparse (rows = 5, cols = 5, nnz = 7)
(3, 1) -> 4
(1, 2) -> 1
(4, 3) -> 1
(2, 4) -> 3
(3, 4) -> 2
(5, 4) -> 1
(5, 5) -> 7
Die volle Matrix erhält man mit dem Befehl full:
m = full(ms)
Ausgabe:
m =
0 1 0 0 0
0 0 0 3 0
4 0 0 2 0
0 0 1 0 0
0 0 0 1 7
Grafisch anzeigen lassen kann man sich die Besetzung von Matrizen mit dem spy-Befehl:
spy(ms);
oder (für allgemeine Matrizen auch mittels)
spy(m);
Ausgabe:
[[Datei:octave_sparse1.jpg]]
Wirklich interessant ist der spy-Befehl für größere Matrizen, z.B. um die Bandstruktur zu visualisieren.
e = eye(200);
es = sparse(e);
% Auf sparse-Matrizen kann genauso zugegriffen werden wie auf normalen Matrizen
es(100, 15) = 100;
spy(es);
Ausgabe:
[[Datei:octave_sparse2.jpg]]
=== Matrizen mit Zufallswerten ===
Insbesondere für Testzwecke kann es manchmal sinnvoll sein größere Matrizen mit Zufallswerten zu bilden. Dazu stellt Octave u.a. den rand-Befehl zur Verfügung.
m = rand(5, 6)
Ausgabe:
m =
0.86605 0.61108 0.71347 0.97119 0.52428 0.21993
0.74059 0.49062 0.56073 0.68592 0.74737 0.62680
0.20790 0.84874 0.36834 0.31102 0.25813 0.28933
0.84732 0.98777 0.91512 0.42240 0.87891 0.63757
0.76823 0.80367 0.24639 0.78208 0.77170 0.95281
Die Zufallszahlen liegen gleichverteilt zwischen 0 und 1 und werden nach dem Mersenne-Twister-Verfahren mit einer Periode von <math>2^{19937}-1</math> gebildet.
Andere Verfahren sind:
* randn: Normalverteilte Pseudozufallselemente mit Mittelwert=0 und Varianz=1
* rande: Exponentialverteilte Zufallselemente
* randg: Gammaverteilte Zufallselemente
* randp: Poissonverteilte Zufallselemente
Details dazu siehe in der Octave-Hilfefunktion.
== Aufgaben ==
* Berechnen Sie den Winkel zwischen den beiden Vektoren a = [1 2 0] und b = [2 1 1]. Hinweis: Siehe diesbezüglich auch im Oktave-Hilfesystem den Befehl "norm".
* Gegeben seien Vektoren a = [1 2 5], b = [0 0 -1] und c = [-1 -2 2]. Berechnen Sie das Spatprodukt aus diesen drei Vektoren.
* Multiplizieren Sie die beiden Matrizen A und B (mit Octave und zur Kontrolle händisch)
A = [0 0 1
1 2 1]
B = [1 1
1 2
0 4]
* Ist die Matrix C regulär? Wenn ja, dann bilden Sie die inverse Matrix.
C = [-1 0 0 -4
2 0 1 5
7 6 2 0
3 0 2 6]
* Ist die Matrix D regulär? Wenn ja, dann bilden Sie die inverse Matrix.
D = [2 1 0 0
0 0 2 1
0 0 0 2
1 1 0 0]
* Berechnen Sie die Konditionszahl der folgenden Matrix. Hinweis: Siehe diesbezüglich im Oktave-Hilfesystem den Befehl cond
[3 4 -5
6 0 3
1 1 2]
* Berechnen Sie die Eigenwerte und Eigenvektoren der folgenden Matrix
[6 -3 4 0
0 7 -1 1
0 10 -3 -2
0 1 -2 1]
= Komplexe Zahlen =
Die imaginäre Einheit wird in Octave durch den Buchstaben i, j, I oder J symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung <math>z = \Re(z) + i \cdot \Im(z)</math>
* Polardarstellungen <math>z = r \cdot (\cos(\phi) + i \cdot \sin(\phi)) = r \cdot e^{i\cdot \phi}</math>
Die konjugiert komplexe Zahl ist <math>z^* = \Re(z) - i \cdot \Im(z)</math>
== Mit komplexen Zahlen rechnen ==
z1 = 2 + 5i; % kartesische Darstellung
z2 = 3 * exp(3j); % Polardarstellung
% Addition
res = z1 + z2;
disp("z1 + z2 = "); disp(res);
% Multiplikation
res = z1 * z2;
disp("z1 * z2 = "); disp(res);
% Realteil
res = real(z2);
disp("Realteil von z2 = "); disp(res);
% Imaginärteil
res = imag(z2);
disp("Imaginaerteil von z2 = "); disp(res);
% Betrag
res = abs(z1);
disp("Betrag von z1 = "); disp(res);
% Argument
res = angle(z1);
disp("Argument von z1 = "); disp(res);
% Konjugiert komplexe Zahl
res = conj(z1);
disp("Konjugiert komplexe Zahl von z1 = "); disp(res);
Ausgabe:
z1 + z2 =
-0.96998 + 5.42336i
z1 * z2 =
-8.0568 - 14.0032i
Realteil von z2 =
-2.9700
Imaginaerteil von z2 =
0.42336
Betrag von z1 =
5.3852
Argument von z1 =
1.1903
Konjugiert komplexe Zahl von z1 =
2 - 5i
== Die gaußsche Zahlenebene ==
clear; close all; clc;
z1 = 3 + 5i;
z2 = 5 * exp(0.5i);
hold on;
plot(z1, "*");
compass(z1);
plot(z2, "o");
compass(z2);
grid on;
[[Datei:octave_komplex1.jpg]]
== Aufgaben ==
* Berechnen Sie die Quadratwurzel der komplexen Zahl <math>z = 3 + 2i</math>.
* Verwandeln Sie folgende Zahlen in die Polarkoordinatendarstellung: <math>-11 - 3i</math> und <math>(1+i)^{10}</math>
* Verwandeln Sie folgende Zahlen in die Normaldarstellung: <math>12 \cdot e^{i\cdot \pi / 4}</math> und <math>3 \cdot (\cos(\pi / 3) + i \cdot \sin(\pi / 3))</math>
* Zeichnen Sie die Zahl <math>3 + 5i</math> in der gaußschen Zahlenebene als Zeiger.
= Funktionen =
Um Programme zu strukturieren und einfacher zu gestalten können Programmteile in Funktionen ausgelagert werden. Eingebaute Funktionen haben wir schon kennengelernt (z.B. die Sinus-Funktion sin). Nun wollen wir sehen, wie man selbst solche Funktionen schreiben kann.
== Eine einfache Funktion schreiben ==
Datei addiere.m:
function res = addiere(a, b)
% Addiere zwei Zahlen a + b
res = a + b;
end
Datei test1.m:
addiere(10, 15)
Ausgabe:
ans = 25
* Jede Funktion sollte in einer eigenen m-Datei stehen.
* Der Dateiname sollte mit dem Funktionsnamen (natürlich ohne Dateiendung .m) übereinstimmen.
* Der Kommentar unter dem Funktionskopf wird als Hilfstext angezeigt, wenn die help-Funktion (hier "help addiere") aufgerufen wird.
== Inline-Funktionen ==
Kurze Funktionen können auch als Inline-Funktionen geschrieben werden.
addiere = inline("a + b");
x = 5;
y = 10;
z = addiere(x, y)
Oder in diesem Fall noch kürzer
addiere = inline("a + b");
z = addiere(5, 10)
Ausgabe:
z = 15
Bei neueren Octave-Versionen kann bei der Verwendung von Inline-Funktionen die Warnung
warning: inline is obsolete; use anonymous functions instead
erscheinen. Ein Blick in die Hilfe-Funktion
help inline
zeigt das selbe Ergebnis. Es sollen also anonyme Funktionen (siehe etwas weiter unten in diesem Text) anstelle von Inline-Funktionen verwendet werden.
== Funktionsstring ==
addiere = "a + b";
a = 5;
b = 10;
z = eval(addiere)
Ausgabe:
z = 15
== Anonyme Funktionen ==
{{Wikipedia | Anonyme Funktion}}
addiere = @(a, b) a + b;
x = 10;
y = 20;
z = addiere(x, y)
oder kürzer
addiere = @(a, b) a + b;
z = addiere(10, 20)
Ausgabe:
z = 30
oder noch kürzer
(@(a,b) a+b)(10, 20)
Ausgabe:
ans = 30
== Nullstellen von Funktionen bestimmen ==
sinh2 = @(x) sinh(x) + 2;
z = fzero(sinh2, 1)
Ausgabe:
z = -1.4436
Zur Kontrolle soll hier der Graph der Funktion dargestellt werden
clear;
close all;
clc;
sinh2 = @(x) sinh(x) + 2;
x = -2 : 0.1 : 0;
y = sinh2(x);
z = fzero(sinh2, 1)
plot(x, y);
hold on;
plot(z, 0, "o", "Color", "red", "LineWidth", 2);
text (-1.8, 0.8, "Nullstelle");
line([z -1.7], [0, .7], "Color", "black");
grid on;
Ausgabe:
[[Datei:octave_funktion5.jpg]]
Weiter unten im Text wird die ähnliche Funktion "fsolve" beschrieben. "fzero" benutzt zwei verschiedene Funktionen zur Problemlösung, darunter eben auch "fsolve".
Für die Nullstellenbestimmung von Polynomen gibt es die Funktion "roots". Näheres dazu folgt im nächsten Kapitel.
== Globale Variablen ==
Datei addiere.m:
function res = addiere()
global a b;
res = a + b;
end
Datei test1.m:
clear;
close all;
clc;
global a b;
a = 5;
b = 3;
addiere()
Ausgabe:
ans = 8
== Aufgaben ==
* Schreiben Sie eine Funktion "ellipse", welche eine Ellipse am Bildschirm darstellt. Zur Erinnerung: Die Parameterdarstellung der Ellipse lautet <math>x = a\cdot\cos(t), y = b\cdot\sin(t), 0 \leq t \leq 2\pi</math>, Funktionsargumente seien a und b.
* Schreiben Sie <math>y = 2\cdot\sin(x) + 3\cdot\cos(x/2)</math>
** als normale Funktion
** als Funktionsstring
** als Inlinefunktion
** als anonyme Funktion
** stellen Sie diese Funktion grafisch am Bildschirm dar.
= Polynome =
== Einzelne Polynomwerte berechnen ==
% y = 2*x^3 + 5*x^2 + 4 für x = 2 berechnen
p = [2, 5, 0, 4];
polyval(p, 2)
Ausgabe:
ans = 40
== Polynome zeichnen ==
% y = 2*x^3 - 5*x^2 + 4 für das Intervall -5 <= x <= 5 grafisch darstellen
x = -5 : .1 : 5;
p = [2, 5, 0, 4];
y = polyval(p, x);
plot(x,y);
grid on;
Ausgabe:
[[Datei:octave_polynom1.jpg]]
== Nullstellen bestimmen ==
Für Polynome existiert die Funktion "roots" zur Nullstellenbestimmung.
% Nullstellen für y = 2*x^3 - 5*x^2 + 4 bestimmen
p = [2, 5, 0, 4];
r = roots(p)
Ausgabe:
r =
-2.76214 + 0.00000i
0.13107 + 0.84077i
0.13107 - 0.84077i
Dieses Polynom hat nur eine reelle Nullstelle. Diese liegt, wie am obigen Grafen zu ersehen ist, in der Nähe von -2.762. Die beiden anderen Nullstellen sind konjugiert komplex zueinander (wie es auch sein sollte).
== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms <math>y = 2x^4 - 3x^3 - x + 7</math>.
* Berechnen Sie die Nullstellen von <math>y = 7x^5 - 3x^2 + 12</math>.
* Zeichnen Sie das Polynom <math>y = 12x^4 - 70x</math> im Intervall <math>-5 \leq x \leq 5</math>.
= Lineare Gleichungssysteme =
Sei <math>Ax = b</math> ein lineares Gleichungssystem. <math>A</math> sei die Koeffizientenmatrix, <math>x</math> der Lösungsvektor und <math>b</math> ein bekannter Vektor.
== Einfache Berechnung mittels Gauß-Verfahren ==
{{Wikipedia | Gaußsches Eliminationsverfahren}}
Beispiel:
A = [5 1
0 2];
b = [1
2];
x = A \ b
Ausgabe:
x =
0
1
== Das gmres-Verfahren ==
gmres steht für Generalized Minimal Residual.
{{Wikipedia | GMRES-Verfahren}}
A = [5 1
0 2];
b = [1
2];
x = gmres(A, b)
Ausgabe:
gmres converged at iteration 2 to a solution with relative residual 2.22045e-16
x =
-1.6653e-16
1.0000e+00
Das Ergebnis weicht etwas vom gaußschen Verfahren ab, ist aber trotzdem im Rahmen der Näherung korrekt.
Weiters kennt Octave noch andere iterative Verfahren, z.B. cgs (Conjugate Gradient Squared) oder bicgstab (Bi-Conjugate Gradient Stabilized). Näheres zu diesen Verfahren siehe in der weiterführenden Literatur (z.B. bei Meister: Numerik linearer Gleichungssysteme, Vieweg+Teubner, 2011)
{{Wikipedia | CGS-Verfahren}}
== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Octave (und zur Kontrolle auch händisch):
5x + 6y - 2z = 12
3x - y - 3z = 6
2x + 2y + 4z = 5
= Nichtlineare Gleichungssysteme =
== fsolve und fzero ==
Löse eine beliebige Gleichung f(x) = 0, z.B. <math> f(x) = x^2 - 5\cos(x) - 10 = 0 </math>:
f = @(x) x^2 - 5*cos(x) - 10;
xstart = 1;
[x, fval, info] = fsolve(f, xstart)
Ausgabe:
x = 2.4681
fval = -1.7764e-015
info = 1
* x ist eine Nullstelle in der Nähe vom Startwert xstart.
* fval ist die Abweichung, den f bei x aufweist.
* info ist ein "Fehlercode": 1 bedeutet, dass der relative Fehler in der spezifizierten Toleranz liegt (wie es sein soll). 3 würde bedeuten, dass der Algorithmus nicht konvergiert (z.B. weil keine Nullstelle existiert).
Zur Kontrolle plotten wir den Funktionsgraphen:
x = - 1 : .1 : 3;
y = x.^2 - 5.*cos(x) - 10;
plot(x,y, "LineWidth", 2);
grid on;
Ausgabe:
[[Datei:octave_nichtlin1.jpg]]
Und siehe da, die gesuchte Nullstelle liegt wie berechnet bei einem Wert nahe 2,5. Die Funktion <math>x^2 - 5\cos(x) - 10</math> hat noch eine zweite Nullstelle, wie in der folgenden Abbildung zu erkennen ist.
[[Datei:octave_nichtlin2.jpg]]
Diese zweite Nullstelle erhalten wir, wenn der Startwert in der Nähe dieser zweiten Nullstelle liegt, also z.B. bei -1. Ändern Sie einfach den entsprechenden Startwert im obigen Programmcode, und das Programm sollte die Nullstelle in der Nähe von -2.5 liefern.
Auch die Funktion ''fzero'' kann zur Lösung einer nichtlinearen Gleichung verwendet werden. Die Hilfe-Funktion von Octave empfiehlt dies sogar eindringlich für den Fall einer nichtlinearen Gleichung in einer Variablen. Für das gleiche Beispiel wie oben kann der Programmcode folgendermaßen aussehen:
Eingabe:
f = @(x) x^2 - 5*cos(x) - 10;
[x0, y0] = fzero (f, [0, 3])
Ausgabe:
x0 = 2.4681
y0 = -1.2434e-14
== Gleichungssysteme ==
Folgende Aufgabe ist dem Buch "Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72" entnommen. Zu lösen ist das nichtlineare Gleichungssystem
<math>f_1 = 2x_1 + 4x_2 = 0 </math>
<math>f_2 = 4x_1 + 8x_2^3 = 0</math>
Lösung:
f.m:
function y = f(x)
y(1) = 2*x(1) + 4*x(2);
y(2) = 4*x(1) + 8*x(2)^3;
end
test1.m:
clear;
close all;
clc;
[x, fval, info] = fsolve (@f, [0, 1])
[x, fval, info] = fsolve (@f, [0, -1])
[x, fval, info] = fsolve (@f, [0, 0])
Ausgabe:
x =
-2 1
fval =
0 7.4930e-09
info = 1
x =
2 -1
fval =
0 -7.4930e-09
info = 1
x =
0 0
fval =
0 0
info = 1
== Aufgaben ==
* Bestimmen Sie die Nullstellen von <math>f(x) = x^2 - 3</math>. Plotten Sie den Grafen.
* Bestimmen Sie die Nullstelle von <math>f(x) = sin(x) - x - 1</math>. Plotten Sie den Grafen.
* Lösen Sie das folgende Gleichungssystem (und stellen Sie das Ganze grafisch am Bildschirm dar): <math> f_1 = x_1 + x_2 = 0; f_2 = x_1 + \sin{x_2} = 0</math>
= Interpolation =
== Eindimensionale Interpolation ==
{{Wikipedia | Interpolation (Mathematik)}}
Bezüglich eindimensionaler Interpolation sei auf die [https://docs.octave.org/v11.1.0/One_002ddimensional-Interpolation.html Octave-Dokumentation und Hilfefunktion zum Befehl " interp1"] verwiesen. Dort findet sich auch ein Programmbeispiel, das als Grundlage des folgenden Plots dient:
[[Datei:octave_interpol1.jpg]]
== Mehrdimensionale Interpolation ==
Bezüglich mehrdimensionaler Interpolation siehe die [https://docs.octave.org/v11.1.0/Multi_002ddimensional-Interpolation.html Hilfefunktion zu "interp2", "interp3" und "interpn"].
== Aufgabe ==
* Gegeben seinen die fünf Stützpunkte p1 = [1, 0], p2 = [2, -5], p3 = [3, 2], p4 = [4, 7], p5 = [5, 6]. Legen Sie eine Funktion (die Interpolierende) durch diese Stützpunkte. Eine Lösungsmöglichkeit:
xp = [1 2 3 4 5];
yp = [0, -5, 2, 7, 6];
xf = 1 : .1 : 5;
spl = interp1(xp, yp, xf, "spline");
pch = interp1(xp, yp, xf, "pchip");
plot(xp, yp, "or", "LineWidth", 2, xf, spl, "LineWidth", 2, ...
xf, pch, "LineWidth", 2);
legend("stuetzpunkte", "spline", "pchip", "location", "southeast");
[[Datei:octave_interpol3.jpg]]
= Differenzialrechnung =
== Polynome differenzieren ==
Es soll das Polynom <math>y = 2x^3 - 5x^2 + 7</math> differenziert werden.
% Differenzieren des Polynoms y = 2*x^3 - 5*x^2 + 7
p = [2, -5, 0, 7];
polyder(p)
Ausgabe:
ans =
6 -10 0
D.h. also, die Ableitung von <math>y = 2x^3 - 5x^2 + 7</math> ist <math>y' = 6x^2 - 10x</math>.
== Sonstige Funktionen differenzieren ==
Als Beispiel differenzieren wir <math>y = 5x\sin{x}</math> und stellen das Ganze grafisch dar.
clear;
close all;
clc;
x = 0 : 0.01 : 10;
y = 5 .* x .* sin(x);
y_strich = diff(y) / 0.01;
plot(x, y, "Color", "red", "LineWidth", 2);
hold on;
plot(x(1:length(x)-1), y_strich, "Color", "blue", "LineWidth", 2);
legend("y", "y'");
grid on;
Ausgabe:
[[Datei:octave_diff1.jpg]]
diff(y) ist der Vektor aus den Differenzen y(2)-y(1), ..., y(n)-y(n-1). Für die genaue Arbeitsweise der diff-Funktion siehe "help diff".
== Aufgaben ==
* Differenzieren Sie das Polynom <math>y = 5y^5 - y^4 + 6y - 4</math>.
* Differenzieren Sie die Funktion <math>y = \log(x) + 10x</math> und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion <math>y = \frac{\sinh(x)}{(1+x)}</math> und stellen Sie y, sowie y' grafisch am Bildschirm dar.
= Integralrechnung =
== Polynome integrieren ==
Berechnen Sie das unbestimmte Integral von <math>y = 2x^3 - 7x^2 + 7</math>
p = [2, -7, 0, 7];
p_int = polyint(p)
Ausgabe:
p_int =
0.50000 -2.33333 0.00000 7.00000 0.00000
Das Ergebnis lautet also <math>\int{y dx} = 0.5x^4 - 2.33333x^3 + 7x + C</math> (auf die Integrationskonstante C darf nicht vergessen werden!).
== Gauß-Quadratur ==
{{Wikipedia | Gauß-Quadratur}}
Berechnen Sie das Integral <math>\int_{0}^{3}x^2 dx</math> mittels Gauß-Quadratur.
Datei f.m:
function y = f(x)
y = x^2;
end
Datei test1.m:
[v, ier, nfun, err] = quad ("f", 0, 3)
Ausgabe:
v = 9.0000
ier = 0
nfun = 21
err = 9.9920e-014
Erläuterung zur Ausgabe:
* v ... Resultat der Integration
* ier ... integer error code
* nfun ... Anzahl der Funktionsaufrufe
* err ... Fehler in der Lösung
== Quadratur mittels adaptiver Lobatto-Regel ==
Berechnen Sie diesmal das Integral <math>\int_{0}^{3}x^2 dx</math> mittels Lobatto-Quadratur.
f = inline("x.^2");
v = quadl (f, 0, 3)
Ausgabe:
v = 9
Wie weiter oben bereits angesprochen kann bei der Ausgabe eine Warnung erfolgen. Inline-Funktionen sind inzwischen als obsolet erklärt und es sollen stattdessen anonyme Funktionen verwendet werden.
Zwecks Übung sei nachfolgend nochmals dieses Beispiel berechnet. Diesmal wird aber eine anonyme Funktion verwendet.
v = quadl (@(x) x.^2, 0, 3)
== Aufgaben ==
* Integrieren Sie das Polynom <math>y = 5y^5 - y4 + 6y - 4</math>.
* Integrieren Sie die Funktion <math>y = \log(x) + 10x</math> von -5 bis 5.
* Integrieren Sie die Funktion <math>y = x^3</math> von 0 bis 4. Verwenden Sie hierzu die Simpsonregel (siehe dazu in der Hilfefunktion den Befehl "quadv").
= Gewöhnliche Differenzialgleichungen =
== ode23, ode45 und lsode ==
Für die Lösung von Differenzialgleichungen stehen die Funktionen
* ode23
bzw.
* ode45
zur Verfügung. Diese Funktionen implementieren das Runge-Kutta-Verfahren. "ode" steht für "Ordinary Differential Equation" (also auf Deutsch für "Gewöhnliche Differentialgleichung"). Die Zahlen bei ode23 oder ode45 stehen für die Ordnung.
{{Wikipedia | Runge-Kutta-Verfahren}}
Beispiel <math>y' = x^2 + y^3</math>:
clear;
close all;
clc;
[x, y] = ode45(@(x,y) (x^2+y^3), [0 1], 0);
plot(x, y, "LineWidth", 2);
Ausgabe:
[[Datei:octave_ode1.jpg]]
Bezüglich der genauen Funktionsweise von "ode45" (oder "ode23") siehe die Octave-Hilfe.
Auch die Funktion "lsode" steht zur Lösung von ODEs zur Verfügung.
Beispiel <math>y' = x + y</math>:
clear;
close all;
clc;
t = 0 : .1 : 5;
[y2, istate, msg] = lsode(@(x,y) (x + y), 1, t);
istate
msg
plot(t, y2);
Ausgabe:
istate = 2
msg = successful exit
[[Datei:octave_lsode1.jpg]]
Bezüglich der genauen Funktionsweise von "lsode" siehe die Octave-Hilfe.
== Aufgaben ==
* Lösen Sie die Differenzialgleichung <math>y' = \frac{1}{x\cdot y}</math> mit Octave. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung <math>m' = -k\cdot m</math>. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung <math>y' = \sqrt{|y|}</math>.
= Die Fast-Fourier-Transformation =
{{Wikipedia | Schnelle Fourier-Transformation}}
Für die Funktion "fft" siehe das Octave-Hilfesystem.
= Mengenrechnung =
== Vereinigungsmenge ==
v1 = [1 2 3 4];
v2 = [2 4 6];
union(v1, v2)
Ausgabe:
ans =
1 2 3 4 6
== Schnittmenge ==
v1 = [1 2 3 4];
v2 = [2 4 6];
intersect(v1, v2)
Ausgabe:
ans =
2 4
= Logik =
Logische Operatoren werden oft benötigt, z.B. bei Schleifen und Verzweigungen.
Octave kennt die logischen Operatoren <code>or, and, not</code> und <code>xor</code>. Als Beispiel sei die Wahrheitstabelle für den Operator <code>or</code> dargestellt.
A B A or B
--------------------
true true true
true false true
false true true
false false false
In Octave kann das so ausgedrückt werden:
or( true, true )
or( true, false )
or( false, true )
or( false, false )
Ausgabe:
ans = 1
ans = 1
ans = 1
ans = 0
Zahlen ungleich 0 stehen für true, 0 für false. Z.B.:
or( 22, 0)
Ausgabe:
ans = 1
Äquivalent zu <code>or</code> ist der Operator <code>|</code>:
22 | 0
Ausgabe:
ans = 1
Zwecks näheren Informationen zu den Operatoren <code>and (&, &&), not (~, !)</code> und <code>xor</code> bemühe man Octaves Help-Funktion.
Bitweise logische Funktionen kennt Octave auch, so kann man z.B. zwei Zahlen mit dem bitweisen OR-Operator verknüpfen:
0b1100101
0b0110001
---------
0b1110101
Oder in Dezimalzahlen:
101
49
---
117
In Octave:
bitor( 0b1100101, 0b0110001 )
dec2bin( ans )
Ausgabe:
ans = 117
ans = 1110101
Zu <code>bitand, bitxor</code> usw. siehe die Octave-Hilfe-Funktion.
= Stochastik =
==Deskriptive Statistik ==
=== Lageparameter ===
Arithmetischer Mittelwert:
vec = [1 2 3 4 5 12 13];
mw = mean(vec)
Ausgabe:
mw = 5.7143
Der Median oder Zentralwert läßt sich folgendermaßen berechnen:
vec = [1 2 3 4 5 12 13];
median(vec)
Ausgabe:
ans = 4
Der Modus oder häufigste Wert läßt sich mittels "mode"-Funktion eruieren:
vec = [1 2 1 3 5 1 2 7];
[m, f, c] = mode (vec);
disp(m);
disp(f);
disp(c);
Ausgabe:
1
3
{
[1,1] = 1
}
m (erste Zeile der Ausgabe) ist der Modus. f (zweite Zeile) ist die Häufigkeit. Näheres dazu siehe im Octave-Hilfesystem.
=== Streuungsparameter ===
Varianz:
vec = [1 2 3 1 1 6 7];
v = var(vec)
Ausgabe:
v = 6.3333
Standardabweichung:
vec = [1 2 3 1 1 6 7];
s = std(vec)
Ausgabe:
s = 2.5166
=== Grafiken erzeugen ===
Histogramme:
v = [1 1 2 3 1 6 7 6 1 1 1 2];
hist(v, max(v));
Ausgabe:
[[Datei:octave_histo2.jpg]]
Balkendiagramme:
v = [1 1 2 3 1 6 7 6];
bar(v);
Ausgabe:
[[Datei:octave_bar111.jpg]]
Treppendiagramm:
v = [1 1 2 3 1 6 7 6];
stairs(v);
Ausgabe:
[[Datei:octave_stairs1.jpg]]
Stabdiagramm:
v = [1 1 2 3 1 6 7 6];
stem(v);
Ausgabe:
[[Datei:octave_stem1.jpg]]
=== Aufgaben ===
Gegeben sei folgende Datentabelle mit den Werten:
v1 = [3 4 1 1 7 2 1 9 2 5 9 7 2 2 9 2 2 1 2 8]
v2 = [1 1 0 2 3 4 1 2 7 0 2 1 5 5 5 4 5 2 5 0]
* Berechnen Sie die Lageparameter und Streuungsparameter des Vektors v1.
* Berechnen Sie Kovarianz und Korrelationskoeffizient der beiden zugeordneten Vektoren v1 und v2.
* Zeichnen Sie das Histogramm des Vektors v1.
== Wahrscheinlichkeitsrechnung ==
=== Kombinatorik ===
Der Binomialkoeffizient:
<math>\binom{n}{k}=\frac{n!}{k!(n-k)!}</math>
In Octave z.B.:
n = 30;
k = 4;
n_ueber_k = nchoosek (n, k)
Ausgabe:
n_ueber_k = 27405
Permutationen sind die verschiedenen Anordnungsmöglichkeiten mit der Anzahl n! = n * (n-1) * ... * 2 * 1.
Beispiel:
v = [1, 2, 3];
p = perms(v)
Ausgabe:
p =
1 2 3
2 1 3
1 3 2
2 3 1
3 1 2
3 2 1
n! (n-Fakultät) selbst kann so berechnet werden:
% 10!
n = 10;
factorial (n)
Ausgabe:
ans = 3628800
=== Verteilungen ===
Octave kennt eine ganze Reihe von Dichte- und Verteilungsfunktionen und zwar
* Probability Density Functions (PDF, Dichtefunktionen)
* Cumulative Distribution Functions (CDF, Verteilungsfunktionen)
Z.B.:
* Binomialverteilung:
** binopdf
** binocdf
* Hypergeometrische Verteilung:
** hygepdf
** hygecdf
* Normalverteilung:
** normpdf
** normcdf
* Studentverteilung:
** tpdf
** tcdf
* Weibullverteilung:
** wblpdf
** wblcdf
Ein Codebeispiel zur Binomialverteilung:
clear;
close all;
clc;
x = 0 : 1 : 10;
n = 10;
p = 0.1;
b1 = binopdf (x, n, p);
b2 = binocdf (x, n, p);
subplot(221);
bar(x, b1);
title("binopdf");
text(1, 0.1, "n=10; p=0.1");
subplot(222);
bar(x, b2);
title("binocdf");
text(1, 0.5, "n=10; p=0.1");
n = 10;
p = 0.5;
b1 = binopdf (x, n, p);
b2 = binocdf (x, n, p);
subplot(223);
bar(x, b1);
text(1, 0.1, "n=10; p=0.5");
subplot(224);
bar(x, b2);
text(1, 0.1, "n=10; p=0.5");
Ausgabe:
[[Datei:octave_bino3.jpg]]
Möglicherweise erhalten Sie bei diesem Beispiel eine Fehlermeldung in der Form
error: 'binopdf' undefined near line 8, column 6
The 'binopdf' function belongs to the statistics package from Octave
Forge which you have installed but not loaded. To load the package, run
'pkg load statistics' from the Octave prompt.
Laden Sie einfach das Paket für die Statistikfunktionen, wie in der Fehlermeldung beschrieben.
Ein Codebeispiel zur Normalverteilung:
clear;
close all;
clc;
x = -4 : .1 : 4;
b1 = normpdf(x);
b2 = normcdf(x);
subplot(121);
plot(x, b1);
title("normpdf");
grid on;
subplot(122);
plot(x, b2);
title("normcdf");
grid on;
Ausgabe:
[[Datei:octave_norm111.jpg]]
== Zufallszahlengeneratoren ==
Octave kann Zufallszahlen aus einer großen Anzahl von Verteilungen generieren, z.B.
* Chi-Quadrat-Verteilung: chi2rnd
* Log-Normal-Verteilung: lognrnd
* Normalverteilung: normrnd
Codebeispiel:
mean = 0;
standardabweichung = 1;
zufallszahl = normrnd (mean, standardabweichung)
Ausgabe (gibt eine Zufallszahl rund um den Mittelwert 0 aus), z.B.
zufallszahl = 1.0451
Auch Zufallsvektoren (oder Zufallsmatrizen) können erstellt werden:
mean = [0 0 0 0 0];
standardabweichung = 1;
zufallsvektor = normrnd (mean, standardabweichung)
Ausgabe, z.B.:
zufallsvektor =
1.47108 -0.51280 0.52726 0.31730 -1.04422
= Das symbolic-Paket =
Octave ist kein CAS ('''C'''omputer '''A'''lgebra '''S'''ystem). Stattdessen kann man eine Schnittstelle zu SymPy (Python) etablieren, und zwar über das symbolic-Paket. Es muss vorab installiert werden, z.B. bei openSUSE mittels YaST (octave-forge-symbolic).
== Rechnen mit wirklich großen Zahlen ==
Das symbolic-Paket bietet u.a. die Möglichkeit mit großen Zahlen exakt zu hantieren.
<code>vpa</code> steht nachfolgend für '''v'''ariable-'''p'''recision '''a'''rithmetic.
pkg load symbolic;
digits(50);
vpa(0.1)
vpa("0.1")
Ausgabe:
Symbolic pkg v3.2.2: Python communication link active, SymPy v1.14.0.
ans = (sym) 0.10000000000000000555111512312578270211815834045410
ans = (sym) 0.10000000000000000000000000000000000000000000000000
Hier sieht man, dass es nötig ist, die Zahlen als String an <code>vpa</code> zu übergeben, ansonsten handelt man sich Rundungsfehler ein.
Nun noch ein Beispiel für große Gleitpunktzahlen:
pkg load symbolic;
digits(50);
x = vpa("1.12345e500");
y = vpa("20000.0");
x*y
Ausgabe:
Symbolic pkg v3.2.2: Python communication link active, SymPy v1.14.0.
ans = (sym) 2.2469000000000000000000000000000000000000000000000e+504
Um die Meldung "Symbolic pkg v3.2.2: Python communication link active, SymPy v1.14.0" zu unterdrücken, gibt es den Schalter/Befehl <code>sympref quiet on</code>:
pkg load symbolic;
sympref quiet on;
x = vpa("1.12345e500", 50);
y = vpa("20000.0", 50);
x*y
Ausgabe:
ans = (sym) 2.2469000000000000000000000000000000000000000000000e+504
Mit dem symbolic-Paket können auch noch andere Probleme gelöst werden (z.B. symbolische Integration oder Differentiation). Dies wird aber hier nicht demonstriert, sondern als Aufgabe gestellt.
== Aufgaben ==
* Recherchieren Sie im Internet zur <code>diff()</code>-Funktion von symbolic. Differenzieren Sie mit Octave folgende Funktionen symbolisch:
** <math>f(x) = \sin(x)\cdot x</math> (und zwar ist die 1. Ableitung gesucht)
** <math>g(x) = x^3</math> (die 2. Ableitung ist gesucht)
* Recherchieren Sie im Internet zur <code>int()</code>-Funktion von symbolic. Integrieren sie mit Octave symbolisch:
** <math>\int{x^3 \ d\text{x}}</math>
** <math>\int_0^2{x^3 \ d\text{x}}</math>
* Gegeben sei das lineare Gleichungssystem <math>2x+3y=7</math>; <math>\ -1x-3y=5</math>.
** Recherchieren Sie dazu im Internet zu <code>syms</code> und <code>solve()</code> aus dem symbolic-Paket
** Lösen Sie das gegebene Gleichungssystem symbolisch.
* Bestimmen Sie die Schnittpunkte eines Kreises mit einer Geraden mittels Octave und dem symbolic-Paket (nichtlineares Gleichungssystem). Das funktioniert auch mittels <code>solve()</code>. Gegeben sind die Gerade <math>y = x + 2</math> und der Kreis <math>x^2 + y^2 = 9</math>.
<small> Eine mögliche Lösung wird nachfolgend gezeigt (weil das etwas diffiziler ist und die im Internet angebotenen Lösungen teils in die Irre führen - Warnungen und Fehlermeldungen beim Ausführen der Scripte):
pkg load symbolic;
syms x y;
gerade = -y + x + 2;
kreis = x^2 + y^2 - 9;
lsg = solve([gerade, kreis], [x, y]);
disp(lsg{1}.x);
disp(lsg{1}.y);
disp("---------------");
disp(lsg{2}.x);
disp(lsg{2}.y);
Ausgabe:
Symbolic pkg v3.2.2: Python communication link active, SymPy v1.14.0.
√14
-1 + ───
2
√14
1 + ───
2
---------------
√14
- ─── - 1
2
√14
1 - ───
2
Dass das Ergebnis stimmt, kann man grafisch nachvollziehen:
% Kreis
t = 0 : .1: 2*pi+.1;
x = 3 * cos(t);
y = 3 * sin(t);
plot(x,y);
grid on;
axis equal;
% Gerade
hold on;
x = -4 : .1 : 4;
y = x+2;
plot(x,y);
% Schnittpunkte
plot(-1+sqrt(14)/2., 1+sqrt(14)/2., 'r.', 'MarkerSize', 20);
plot(-1-sqrt(14)/2., 1-sqrt(14)/2., 'r.', 'MarkerSize', 20);
% refresh();
% input("");
Ausgabe:
</small>
[[Bild:octave_nlin_gs1.svg|350px]]
* Führen Sie symbolische Laplace-Transformationen durch:
** Recherchieren Sie dazu im Internet zum Thema "Wie führt man eine Laplace-Transformation mit dem Octave-Paket symbolic aus?". Dies führt auf die Funktion <code>laplace()</code>.
** Gegeben ist die Sprungfunktion (1). Gesucht ist die Laplace-Transformierte.
** Gegeben ist die Sinusfunktion (<math>\sin{\omega t}</math>). Gesucht ist die Laplace-Transformierte.
= Regelungstechnische Aufgabenstellungen =
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket <code>control</code>. Dieses muss vorab installiert werden (z.B. bei openSUSE mittels YaST). Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms gezeigt werden. Gegeben sei <math>G(s)= \frac{1}{30s^3+20s^2+10s+1,5}</math>.
Octave-Code:
pkg load control;
zaehler = [1];
nenner = [30., 20., 10., 1.5];
G = tf(zaehler, nenner);
bode(G);
grid on;
% refresh();
% input("");
Ausgabe:
[[Bild:octave_rt1.jpg|400px]]
<code>tf()</code> steht für '''t'''ransfer '''f'''unction (engl. für Übertragungsfunktion). Die Dokumentation für das <code>control</code>-Paket findet sich [https://gnu-octave.github.io/pkg-control/doc_control.html hier].
= Einfache Benutzeroberflächen erstellen=
== Input ==
fflush (stdout);
x = input("Gib eine Zahl ein: ");
disp(2 * x);
Ein-/Ausgabe:
Gib eine Zahl ein: 12
24
Der "fflush"-Befehl sollte immer vor dem Aufruf des input-Befehls aufgerufen werden. Näheres zu "fflush" siehe im Octave-Hilfesystem.
== Diverse einfache vorgefertigte Dialoge ==
Fehlermeldung:
errordlg("Fehlermeldung");
[[Bild:octave_fehlermeldung1.jpg]]
Warnung:
warndlg("Warnung");
[[Bild:octave_warnung1.jpg]]
Hilfedialog:
helpdlg
[[Bild:octave_hilfe1.jpg]]
Abfragedialog:
button = questdlg ("Frage")
[[Bild:octave_abfrage1.jpg]]
Eingabedialog:
in = inputdlg("Eingabe")
[[Bild:octave_eingabe1.jpg]]
Messagebox:
h = msgbox ("Eine Mitteilung!");
[[Bild:octave_messagebox1.jpg]]
== Komplexere vorgefertigte Dialogboxen ==
=== Menübox ===
auswahl = menu("Auswahl", "Affe", "Elefant", "Loewe", "Sonstiges");
switch(auswahl)
case 1
disp "Affe quietscht"
case 2
disp "Elefant trompetet"
case 3
disp "Loewe bruellt"
otherwise
disp "Sonstiges"
end
Ausgabe:
[[Bild:octave_menu1.jpg]]
Es werde beispielsweise die Nummer 2 gewählt.
Ausgabe:
Elefant trompetet
=== Dialogliste ===
clear;
close all;
clc;
opt = {"Eins", "Zwei", "Drei"};
[sel, ok] = listdlg ("ListString", opt, "SelectionMode", "Multiple");
if (ok == 1)
for i = 1 : numel(sel)
disp(opt{sel(i)});
end
else
disp("Cancel");
end
[[Bild:octave_dialog1.jpg]]
Es werden beispielsweise alle Optionen ausgewählt.
Ausgabe:
Eins
Zwei
Drei
=== Fortschrittsbalken ===
h = waitbar ([0.5])
[[Bild:octave_fortschritt1.jpg]]
=== Datei- und Verzeichnisdialoge ===
Dateidialog:
[fname, fpath, fltidx] = uigetfile ()
[[Bild:octave_dateidialog2.jpg]]
Ähnlich sind die Befehle "uiputfile" und "uigetdir". Dazu sei auf die Octave-Hilfe verwiesen.
== Eigene Dialoge kreieren ==
Dieses Thema sei hier nur kurz angerissen.
Programmcode:
d = dialog("Position", [300, 300, 250, 150], "Name", "Dialog");
txt = uicontrol("Parent", d, ...
"Style", "text", ...
"Position", [20, 80, 210, 40], ...
"String", "Hallo Welt");
btn_servus = uicontrol("Parent", d, ...
"Position", [30, 20, 80, 30], ...
"String", "Servus", ...
"Callback", "disp('Servus angeklickt!');");
btn_hallo = uicontrol("Parent", d, ...
"Position", [140, 20, 80, 30], ...
"String", "Hallo", ...
"Callback", "disp('Hallo angeklickt!');");
uiwait(d);
Ausgegebenes Dialogfenster:
[[Bild:octave_dialog100.jpg]]
Ausgabe auf der Konsole (je nach gedrücktem Button), z.B.:
Servus angeklickt!
Die Position wird als [links, unten, breite, höhe] angegeben. Der Koordinatennullpunkt liegt, bezogen auf das Elternfenster, links unten. Es sind auch negative Koordinatenwerte möglich. Sinnvoll ist das z.B. bei einem dynamischen Ausblenden ohne zu löschen, oder für Animationen.
[[Bild:Cartesian-coordinate-system.svg | 150px]]
Wer mehr dazu wissen will, sei auf die Octave-Dokumentation verwiesen. Insbesondere siehe
* dialog
* uicontrol
* uipanel
* uibuttongroup
* uitable
* uimenu
* uitoolbar
== Aufgaben ==
=== Aufgabe 1 ===
Erzeugen Sie ein Dialogfenster mit einem Texteingabefeld und einem Button. Beim Klicken auf den Button soll der Eingabetext auf der Konsole ausgegeben werden. Das Dialogfenster soll also in etwa so aussehen:
[[Bild:octave_dialog105.jpg]]
Da dies etwas komplizierter als das oben gezeigte Beispiel ist, werden nachfolgend ein paar Codefragmente zwecks Lösung angegeben:
Datei button_callback.m:
function button_callback(editHandle)
eingegText = get(editHandle, "String");
disp(eingegText);
end
Codefragement in test1.m:
% ...
edit = uicontrol(% ...
"Style", "edit", ...
%, ...
"HorizontalAlignment", "left");
btn = uicontrol(% ...
"Callback", @(src, event) button_callback(edit));
% ...
Aufruf mit:
octave test1.m
Eingabe von z.B. "Hallo Welt!":
[[Bild:octave_dialog106.jpg]]
Ausgabe auf der Konsole nach dem Drücken des Buttons:
Hallo Welt!
=== Aufgabe 2 ===
Erzeugen Sie ein Dialogfenster mit zwei Eingabefeldern und einem Button. Eingegeben in diese zwei Eingabefelder werden vom Benutzer Zahlen. Auf der Konsole ausgegeben werden soll, nach Drücken des Buttons, das Produkt dieser zwei Zahlen.
Auch hier werden wieder Codefragemente angegeben.
Datei button_callback.m:
function button_callback(edit1, edit2)
zahl1 = str2double(get(edit1, 'String'));
zahl2 = str2double(get(edit2, 'String'));
disp(zahl1 * zahl2);
end
Codefragment Datei test1.m:
% ...
btn = uicontrol("Parent", d, ...
% ...
"Callback", @(src, event) button_callback(edit1, edit2));
% ...
Was passiert, wenn der Benutzer keine Zahlen, sondern beliebige Strings eingibt?
= Fehlerhandling mit try/catch =
Die try/catch-Anweisung entspricht weitgehend jener, die aus höheren Programmiersprachen wie C++ oder Java bekannt sind. Aufgebaut ist diese Anweisungsfolge so:
try
BODY
catch
CLEANUP
end
Beispiel:
clear;
close all;
clc;
try
a = 10 / "zahl";
disp(a);
disp("Weiter im try-Block");
catch
disp("Catch: Kann nicht durch einen String dividieren");
end
Ausgabe:
Catch: Kann nicht durch einen String dividieren
Sinnvoll ist die try/catch-Folge, wenn z.B. auch in einem Fehlerfall Dateien wieder geschlossen werden sollen.
= Ein- und Ausgabe =
== Formatierte Ausgabe am Bildschirm, formatiertes Lesen von der Tastatur ==
Folgendes Beispiel ist der Octave-Hilfe (von Octave 3.0.3) entnommen:
pct = 37;
filename = "foo.txt";
printf ("Processed %d%% of `%s'.\nPlease be patient.\n", pct, filename);
Ausgabe:
Processed 37% of `foo.txt'.
Please be patient.
"printf" gibt einen formatierten String am Bildschirm (genauer in den Stream stdout) aus. Wie man sieht, orientiert sich das Format an der Programmiersprache C.
Für das formatierte Lesen vom Stream stdin (normalerweise also von der Tastatur) steht das Pendant "scanf" bereit.
== Von einem String lesen bzw. in einen String schreiben ==
Bezüglich der Funktionen
* sprintf
und
* sscanf
sei auf die Octave-Hilfefunktion verwiesen.
== Lesen und Schreiben von einer Datei ==
=== Datei schreiben ===
% Datei c:\tmp\datei.test zum Schreiben öffnen
datei = fopen ("c:/tmp/datei.test", "w");
% Etwas in die Datei schreiben
fprintf(datei, "Hallo, Welt!");
% Datei schließen
fclose(datei);
=== Datei lesen ===
% Datei c:\tmp\datei.test zum Lesen öffnen
datei = fopen ("c:/tmp/datei.test", "r");
% Etwas aus der Datei lesen
[string] = fscanf(datei, "%s");
disp(string);
% Datei schließen
fclose(datei);
Ausgabe:
Hallo,Welt!
=== Dateiende prüfen ===
Mittels des Befehls
feof(FID);
kann das Dateiende geprüft werden. Wenn die EOF-Bedingung zutrifft, dann wird 1 zurückgegeben, wenn nicht dann 0. Ein Beispiel folgt später als Lösung einer Aufgabe.
=== warning und error ===
Eine Warnung kann man am stderr-Stream ausgeben. Die warning-Funktion entspricht ansonsten der printf-Funktion. Nach Ausgabe der Warnung wird das Programm normal fortgesetzt.
m = [1 2
3 6];
if(det(m) == 0)
warning("Matrix ist singulaer");
end
disp("Weiter geht's");
Ausgabe:
warning: Matrix ist singulaer
warning: called from
test1 at line 5 column 3
Weiter geht's
Schärfer ist der error-Befehl. Die Fehlermeldung wird am stderr-Stream ausgegeben. Vom Format her entspricht diese Funktion dem printf-Befehl. Nach Ausgabe der Fehlermeldung wird das Programm beendet.
m = [1 2
3 6];
if(det(m) == 0)
error("Matrix ist singulaer");
end
disp("Weiter geht's");
Ausgabe:
error: Matrix ist singulaer
error: called from
test1 at line 5 column 3
== Aufgaben ==
* Schreiben Sie ein Programm, das die Zahlen 1 bis 10 zeilenweise in eine Datei ausgibt.
* Lesen Sie diese Zeilen wieder von der Datei ein und geben Sie sie am Bildschirm aus.
* Gegeben sei eine Datei. Lesen Sie die Daten aus dieser Datei ein und rechnen Sie per Octave-Programm den Gesamtpreis für alle Tiere aus. Die Anzahl der Zeilen und der genaue Dateinhalt sei Ihnen vorab nicht bekannt. Bekannt ist nur das Datenformat wie folgt:
Nr. Name Einzelpreis Stueck
1 Affe 15000.50 2
2 Loewe 11000.90 1
3 Nashorn 45000.10 1
4 Elefant 51245.90 3
5 Tiger 9000.70 2
6 Maus 34.90 12
Eine einfache Lösung ohne Schnickschnack (Fehlerüberprüfungen etc.) für dieses Beispiel könnte wie folgt aussehen:
clear;
close all;
clc;
datei = fopen ("c:/tmp/daten1.txt", "r");
gesamtpreis = 0;
% Kopfzeile einlesen
[nr, name, preis, stk] = fscanf(datei, "%s %s %s %s", "C");
while(feof(datei) == 0)
% Datensätze einlesen
[nr, name, preis, stk] = fscanf(datei, "%d %s %f %d", "C");
gesamtpreis += preis*stk;
end
fclose(datei);
disp("Gesamtpreis = ");
format long;
disp(gesamtpreis);
Ausgabe:
Gesamtpreis =
258159.900000000
= Datencontainer =
== Datenstrukturen ==
Pseudocode:
STRUKTUR s
ZAHL a
VEKTOR b
STRING c
END
Octave-Code:
s.a = 45.9;
s.b = [1 2 3 4 5];
s.c = "Hallo!";
s
Ausgabe:
s =
scalar structure containing the fields:
a = 45.90000000000000
b =
1 2 3 4 5
c = Hallo!
Um ein paar weitere Möglichkeiten zum Handling mit Datenstrukturen aufzuzeigen, sei folgender Code aufgeführt.
Datei addsub.m
function res = addsub(a, b)
res.x = a + b;
res.y = a - b;
end
Datei test1.m
clear;
clc;
addsub(10, 50)
r = addsub(30, 70)
r.x
r.y
++r.x
Ausgabe:
ans =
scalar structure containing the fields:
x = 60
y = -40
r =
scalar structure containing the fields:
x = 100
y = -40
ans = 100
ans = -40
ans = 101
Die Funktion "addsub" liefert die Struktur res mit zwei Zahlenwerten. Die Elemente der Datenstruktur können auch außerhalb der Funktion angesprochen werden. Auch gerechnet werden kann mit diesen Elementen.
== Cell Arrays ==
Manchmal kann es sinnvoll sein mehrere Variablen verschiedenen Typs und Größe in einer Variablen zu speichern. Dies funktioniert ähnlich wie bei Vektoren. Es werden aber geschweifte Klammern verwendet.
Eingabe:
c = {"Hallo Welt!", [2 2], 44}
c{1}
c{1:2}
Ausgabe:
c =
{
[1,1] = Hallo Welt!
[1,2] =
2 2
[1,3] = 44
}
ans = Hallo Welt!
ans = Hallo Welt!
ans =
2 2
Elemente des Cell Arrays können auch wieder mit Variablen anderen Typs überschrieben werden.
c = {"Hallo Welt!", [2 2], 44};
c{1} = 5;
c
Ausgabe:
c =
{
[1,1] = 5
[1,2] =
2 2
[1,3] = 44
}
= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}
* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse "erbt" Attribute und Methoden von der Superklasse. Octave unterstützt (so wie C++ und Python, aber im Gegensatz zu Java) Mehrfachvererbung.
== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.
[[File:UmlCd Klasse-3.svg|300px]]
* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private (privat)
** # ... protected (geschützt)
* Vererbung:
<gallery>
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
</gallery>
Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0
== Klassen und Vererbung ==
Octave unterstützt auch objektorientierte Programmierung mit dem Schlüsselwort <code>classdef</code> (ab Version 4.0). Dieses Thema ist zwar etwas fortgeschritten, wird aber trotzdem kurz behandelt.
[[Bild:octave_oop1.svg|200px]]
Datei Auto.m:
classdef Auto
properties
marke1 = "Beemweh"
endproperties
methods
function zeige1(obj)
disp(["Marke: ", obj.marke1]);
endfunction
endmethods
endclassdef
Datei Cabrio.m:
classdef Cabrio < Auto
properties
marke2 = "Cabrio"
endproperties
methods
function zeige2(obj)
disp(["Marke: ", obj.marke2]);
endfunction
endmethods
endclassdef
Datei test1.m:
obj = Cabrio();
obj.zeige1();
obj.zeige2();
Ausgabe (Aufruf mittels "octave test1.m"):
Marke: Beemweh
Marke: Cabrio
GNU Octave kann auch Mehrfachvererbung:
[[Bild:octave_oop2.svg|200px]]
classdef Unterklasse < Oberklasse1 & Oberklasse2
Für die Reihenfolge der Vererbung gilt: Die zuerst genannte Klasse hat Vorrang.
Man kann mittels <code>private, protected, public</code> Daten auch kapseln:
properties(SetAccess = private, GetAccess = public)
methods (Access = public)
Standardmäßig sind alle Methoden und Attribute <code>public</code>.
Weiterführendes siehe z.B. in der [https://docs.octave.org/latest/Object-Oriented-Programming.html Octave-Dokumentation].
= Octave im Zusammenspiel mit anderen Programmiersprachen =
Man kann GNU Octave zur Kommunikation mit anderen Programmiersprachen bewegen, und das in beide Richtungen:
* GNU Octave -> andere Programmiersprache
* andere Programmiersprache -> GNU Octave
Hier die ganzen Möglichkeiten detailliert zu beschreiben würde zu weit führen. Wir beschränken uns im Wesentlichen auf die Erstellung von .oct-Files (C/C++; Fortran würde auch gehen, ist aber komplizierter) und zählen im Anschluss daran ein paar weitere Varianten auf.
== .oct-Dateien ==
Eine .oct-Datei in GNU Octave ist eine kompilierte C/C++-Datei, die als dynamisch ladbares Objekt direkt in Octave ausgeführt werden kann. oct-Dateien sind meist schneller als nativer Octave-Code.
1. Schritt: Erstelle z.B. eine C++-Datei ''quadrat.cc'' (es soll das Quadrat einer Zahl berechnet werden)
#include <octave/oct.h>
DEFUN_DLD(quadrat, args, nargout, "Quadrat einer Zahl berechnen")
{
double x = args(0).double_value();
double res = x*x;
return octave_value(res);
}
* <code>DEFUN_DLD</code> ist ein Makro. Damit wird angezeigt, dass es sich um eine dynamisch ladbare Funktion handelt ('''De'''fine '''Fun'''ction – '''D'''ynamically '''L'''inked '''D'''istribution).
* Der erste Parameter muss mit dem Namen der Funktion und der erstellten oct-Datei übereinstimmen, also hier <code>quadrat</code>.
* <code>args</code>: Argumente die beim Aufruf in Octave übergeben werden.
* <code>nargout</code>: Anzahl der Rückgabewerte.
* "Quadrat einer Zahl berechnen": Dokumentationsstring
2. Schritt: ''quadrat.cc'' kompilieren
# Terminal öffnen
# In das quadrat.cc-Verzeichnis wechseln
# Octave aufrufen
# cc-Datei zu einer oct-Datei kompilieren: <code>mkoctfile quadrat.cc</code>
# Wenn das ohne Fehlermeldung durchläuft, so sollte im Anschluss eine (relativ große) ''quadrat.oct''-Datei im entsprechenden Verzeichnis zu finden sein.
3. Schritt: Funktion <code>quadrat()</code> in Octave aufrufen, z.B.:
y = quadrat(5)
Es ergibt sich folgende Ausgabe:
y = 25
Damit das funktioniert, müssen natürlich die entsprechenden Werkzeuge (Compiler etc.) installiert sein. Darauf wird hier aber nicht näher eingegangen.
Die Dokumentation zu den .oct-Dateien findet sich auf [https://docs.octave.org/v11.1.0/Oct_002dFiles.html].
== Andere Möglichkeiten ==
* .mex-Dateien ('''M'''ATLAB '''Ex'''ecutables): Wenn man kompatibel zu MATLAB bleiben muss
* Java- oder Python-Schnittstelle (Nachteil: langsamer als .oct-Dateien)
Bevor man aber diese Möglichkeiten in Anspruch nimmt, sollte man vektorisieren. Damit lassen sich oft schon höhere Geschwindigkeiten erzielen. Dieses Thema wurde früher schon kurz behandelt ([[Ing_Mathematik:_Numerische_Mathematiksysteme_am_Beispiel_von_Octave#Die_FOR-Schleife|FOR-Schleife]]).
= Octave und die Tabellenkalkulation =
== Lesen ==
GNU Octave kann auch CSV-, LibreOffice Calc- oder MS Excel-Dateien einlesen.
Gegeben sei folgende schematisierte Datei im LibreOffice Calc-Format (test1.ods):
Februar März
Freitag 23 26
Samstag 17 41
Sonntag 34 37
=== Direkt als ODS-Datei einlesen ===
Die odsread-Funktion muss via io-Package geladen werden. Dieses Package ist nicht standardmäßig installiert, sondern kann z.B. bei openSUSE Tumbleweed mittels YaST als octave-forge-io installiert werden. Danach wird das Package geladen (pkg load io) und die Daten mittels odsread eingelesen.
pkg load io
[num, txt, raw] = odsread('test1.ods');
disp(num)
disp("------------")
disp(txt);
disp("------------")
disp(raw);
Ausgabe:
23 26
17 41
34 37
------------
{
[1,1] =
[2,1] = Freitag
[3,1] = Samstag
[4,1] = Sonntag
[1,2] = Februar
[2,2] =
[3,2] =
[4,2] =
[1,3] = März
[2,3] =
[3,3] =
[4,3] =
}
------------
{
[1,1] = [](0x0)
[2,1] = Freitag
[3,1] = Samstag
[4,1] = Sonntag
[1,2] = Februar
[2,2] = 23
[3,2] = 17
[4,2] = 34
[1,3] = März
[2,3] = 26
[3,3] = 41
[4,3] = 37
}
=== Als CSV-Datei einlesen ===
Die Datei test1.ods wird per LibreOffice Calc als CSV-Datei test1.csv (Trennzeichen ist der Strichpunkt) gespeichert (Achtung: gespeichert, nicht exportiert!):
;Februar;März
Freitag;23;26
Samstag;17;41
Sonntag;34;37
==== Mit csv2cell ====
Wir wollen hier den Strichpunkt als Trennzeichen verwenden. Per Default wird nämlich der Beistrich als Trennzeichen interpretiert.
pkg load io;
data = csv2cell("test1.csv", ";");
disp(data);
disp("---------------");
disp(data{2, 2});
Ausgabe:
{
[1,1] =
[2,1] = Freitag
[3,1] = Samstag
[4,1] = Sonntag
[1,2] = Februar
[2,2] = 23
[3,2] = 17
[4,2] = 34
[1,3] = März
[2,3] = 26
[3,3] = 41
[4,3] = 37
}
---------------
23
==== Mit dlmread ====
data = dlmread("test1.csv", ";");
disp(data);
disp("---------------");
disp(data(2, 2));
Ausgabe:
0 0 0
0 23 26
0 17 41
0 34 37
---------------
23
==== Mit importdata ====
data = importdata("test1.csv");
disp(data)
disp("------------")
disp(data.data);
disp("------------")
disp(data.data(2,2));
Ausgabe:
data =
23 26
17 41
34 37
textdata =
{
[1,1] = ;Februar;März
[2,1] = Freitag
[3,1] = Samstag
[4,1] = Sonntag
}
rowheaders =
{
[1,1] = Freitag
[2,1] = Samstag
[3,1] = Sonntag
}
------------
23 26
17 41
34 37
------------
41
Damit haben wir schon etliche Funktionen zu diesem Zweck kennengelernt. Weitere Funktionen zu
diesem Zweck sind z.B.
* csvread
* textscan
=== Als XLSX-Datei einlesen ===
Wir speichern unsere test1.ods-Datei als test1.xlsx-Datei. Dies ist das MS Excel-Standardformat. Und schon können wir den xlsread-Befehl zum Einlesen der Daten verwenden.
pkg load io
[num, txt, raw] = xlsread('test1.xlsx');
disp(num)
disp("------------")
disp(txt);
disp("------------")
disp(raw);
Die Ausgabe ist gleich wie oben bei der odsread-Funktion.
== Schreiben ==
=== Direkt als ODS-Datei schreiben ===
pkg load io
data = {
"", "Februar", "März";
"Freitag", 23, 26;
"Samstag", 17, 41;
"Sonntag", 34, 37
};
odswrite('test1.ods', data);
=== Als XLSX-Datei schreiben ===
pkg load io
data = {
"", "Februar", "März";
"Freitag", 23, 26;
"Samstag", 17, 41;
"Sonntag", 34, 37
};
xlswrite('test1.xlsx', data);
=== Als CSV-Datei schreiben ===
* dlmwrite
* csvwrite
* fprintf
= Octave GUI =
Das GUI-Programm ('''G'''raphical '''U'''ser '''I'''nterface) von Octave entspricht im Wesentlichen anderen Programmier-Benutzeroberflächen (IDEs ... '''I'''ntegrated '''D'''evelopment '''E'''nvironments), wie z.B. Eclipse (Java), Code::Blocks (C/C++) oder Spyder (Python). Nachfolgend ist ein Screenshot des Octave-GUI mit einigen Anmerkungen dargestellt.
[[Bild:octave_gui2.jpg|600px]]
Probieren Sie einfach die Möglichkeiten der zur Verfügung gestellten GUI/IDE aus.
= Komplexere Aufgaben =
* Berechnen Sie die Fläche, den Umfang, die Seitenlängen, den Inkreis und den Umkreis eines Dreiecks. Stellen Sie das Dreieck inklusive In- und Umkreis grafisch dar. Speichern Sie die Daten in einer Datei. Die drei Eckpunkte dieses Dreiecks sollen vom Benutzer beliebig vorgegeben werden.
* Die Werte einer beliebig großen quadratischen Matrix seien in einer Datei gespeichert. Lesen Sie diese Datei ein und berechnen Sie daraus die Determinante der Matrix, die inverse Matrix, die Eigenvektoren und -werte, die Spur. Führen Sie die LR-Zerlegung durch. Geben Sie diese Werte am Bildschirm aus.
= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Octave. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechende weiterführende Literatur, die Octave-Hilfefunktion und die Octave-Dokumentation verwiesen. Octave kennt noch viel mehr Befehle, als hier dargestellt wurden. Aber auch Octave selbst ist erweiterbar. Man siehe z.B. Octave Packages (https://gnu-octave.github.io/packages/) oder man schreibt selbst Erweiterungen.
{{Navigation_zurückhochvor_buch|
zurücktext=Maxima|
zurücklink=Ing Mathematik: Computeralgebrasysteme am Beispiel von Maxima|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Julia für Ingenieure|
vorlink=Ing Mathematik: Julia}}
dsc3ht3la80ehulo0m2uuo8ye7rn0vj
1092410
1092409
2026-10-24T09:23:44Z
Intruder
1513
/* Die IF-Verzweigung */
1092410
wikitext
text/x-wiki
{{Navigation_zurückhochvor_buch|
zurücktext=Maxima|
zurücklink=Ing Mathematik: Computeralgebrasysteme am Beispiel von Maxima|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Julia für Ingenieure|
vorlink=Ing Mathematik: Julia}}
= Hallo Welt und allgemeine Hinweise =
== Was ist Octave ==
* Octave ist eine Software zur numerischen Lösung mathematischer Probleme.
* Octave ist Open-Source (GPL-Lizenz).
* Octave ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Octave ist weitgehend kompatibel zum Numerik-Standardprogramm {{W|Matlab|MATLAB}}.
* Octave ist ein Interpreter.
* Octave als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
{{Wikipedia | GNU Octave}}
== Octave installieren ==
=== MS Windows ===
Laden Sie das aktuelle Octave-Paket von der Webseite [https://octave.org/download] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.
=== Linux ===
Entweder ist Octave bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Dazu gehen Sie auf die Seite [https://wiki.octave.org/Category:Installation], wählen die vorhandene Linux-Variante und folgen der angegebenen Beschreibung (z.B. <code>zypper ... </code> für openSUSE. Oder Sie benutzen unter openSUSE Tumbleweed direkt das Setup-Programm {{W|YaST}}).
== Octave starten ==
=== MS Windows ===
Das Icon für das Octave-Programm doppelklicken (für das Konsolenprogramm ... CLI, für die grafische Benutzeroberfläche ... GUI). Und schon startet das Programm.
[[Datei:octavestart1.jpg]]
=== Linux ===
In einer Linux-Konsole den Befehl "octave" eintippen, mit der RETURN-Taste bestätigen, und das Programm (CLI) startet:
GNU Octave (x86_64-suse-linux-gnu) version 11.1.0
Copyright (C) 1993-2026 The Octave Project Developers.
License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>
This is free software; see the source code for copying conditions.
There is NO WARRANTY, to the extent permitted by law. For details, type 'warranty'.
Home page: <https://octave.org>
Support resources: <https://octave.org/support>
Improve Octave: <https://octave.org/get-involved>
For changes from previous versions, type 'news'.
octave:1>
Um Octave mit der eingebauten GUI zu starten, kann der Befehl <code>octave --force-gui</code> verwendet werden:
[[File:Gnu_Octave_IDE.png|600px]]
Alternativ kann, z.B. unter openSUSE Tumbleweed (mit {{W|KDE Plasma 6|KDE-Plasma}}), die Octave-IDE auch über den Application Launcher im Menü ''Education -> GNU Octave'' gestartet werden.
== Ein paar Worte zur Erklärung ==
Im Folgenden wird immer das Konsolenprogramm (CLI ... Command Line Interface) für die Eingabe von Befehlen benutzt. Erst gegen Ende dieses Textes wird auch kurz auf das GUI von Octave eingegangen.
Teilweise werden Ergebnisse der älteren Octave-Version 3.0.3 dargestellt. Die dargestellten Grafiken und Ausgabetexte können je nach Version leicht voneinander abweichen. Der Text wurde ursprünglich mit der Octave-Version 3.0.3 erstellt und anschließend auf die Versionen 5.2 bis 11.1.0 aktualisiert. Dieser Mischmasch sollte aber kein Problem darstellen.
Getestet wurden die Beispiele ursprünglich unter dem Betriebssystem MS Windows 10, später auch mit MS Windows 11, bzw. mit openSUSE Leap 15.6 (Octave 6.4.0, nur vereinzelt) und ab März 2026 auch mit openSUSE Tumbleweed (ab Octave 10.3.0, nur vereinzelt).
== Ein erstes Programm ==
Kommentare werden in Octave mit dem Prozentzeichen (%) oder alternativ mit der Raute (#) eingeleitet. Sie werden vom Octave-Interpreter ignoriert. Will man kompatibel mit MATLAB bleiben, so ist die Version mit dem %-Zeichen vorzuziehen. Text kann mit der disp-Funktion ausgegeben werden. Starten Sie Octave und geben sie folgende Anweisungen zeilenweise ein
octave-3.0.3.exe:1> % Das ist ein Kommentar
octave-3.0.3.exe:2> # und das auch
octave-3.0.3.exe:3> disp "Hallo Welt!"
Als Ergebnis erhalten Sie
Hallo Welt!
Der Prompt (z.B. octave-3.0.3.exe:1>) ist natürlich abhängig von der Octave-Version und den schon eingegebenen Zeilen. Er ist selbstverständlich nicht einzutippen, sondern wird vom Octave-System geliefert.
Strings können in Octave entweder in Anführungszeichen (") gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.
= Octave als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Octave. Geben Sie dann die Formel
octave-3.0.3.exe:1> 3 * 5
ein, drücken die Taste ENTER/RETURN und erhalten als Ergebnis
ans = 15
Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck <math>\sin\sqrt{15}</math> berechnen :
octave-3.0.3.exe:2> sin(sqrt(15))
ans = -0.6679
Octave kennt eine Handvoll von Konstanten, z.B.:
Zeilenweise Eingabe:
% Die Kreiszahl PI
pi
% Die Eulersche Zahl
e
% Zur Maschinengenauigkeit
eps
Ausgabe:
ans = 3.1416
ans = 2.7183
ans = 2.2204e-016
"ans" steht übrigens für den Begriff "answer" (auf Deutsch "Antwort"). Mit "ans" kann wie mit jeder anderen Variable oder Konstanten weitergerechnet werden, z.B.:
Eingabe:
% Der Kreisradius sei 10
10
% Der Kreis-Umfang mit diesem Radius sei folgendes
2 * pi * ans
Ausgabe:
ans = 10
ans = 62.832
Die Ausgabe eines Befehls am Bildschirm (das "Echo") kann übrigens durch Anwendung des Semikolons (;) unterdrückt werden. Gezeigt werden soll dies nun mit Hilfe des obigen Beispiels. Es soll nur der Umfang ausgegeben werden, nicht der Radius.
Eingabe:
% Der Kreisradius sei 10
10;
% Der Kreis-Umfang mit diesem Radius sei folgendes
2 * pi * ans
Ausgabe:
ans = 62.832
Vielleicht ist manchem die Genauigkeit, mit der Echo bzw. der Befehl disp Werte ausgibt, nicht ausreichend. Dem kann Abhilfe verschafft werden und zwar so:
Eingabe:
format short
pi
format long
pi
format longe
pi
% usw.
Ausgabe:
ans = 3.1416
ans = 3.14159265358979
ans = 3.14159265358979e+00
Beenden lässt sich das Octave-Programm durch Eingabe von quit oder exit (und natürlich zur Bestätigung die RETURN-Taste drücken).
== Die Hilfefunktion von Octave ==
Die Eingabe von help mit Angabe eines Funktionsnamens liefert detaillierte Infos zu der gesuchten Funktion.
Eingabe:
help sin
Ausgabe:
'sin' is a built-in function from the file libinterp/corefcn/mappers.cc
-- Y = sin (X)
Compute the sine for each element of X in radians.
See also: asin, sind, sinh.
Additional help for built-in functions and operators is
available in the online version of the manual. Use the command
'doc <topic>' to search the manual index.
Help and information about Octave is also available on the WWW
at https://www.octave.org and via the help@octave.org
mailing list.
Auch gibt es die doc-Funktion für eine vollständige Dokumentation des Octave-Systems, z.B.:
Eingabe:
doc
Ausgabe:
[[Datei:Octave_730_doc_screenshot.jpg]]
== Sonstige einfache Berechnungen ==
In octave gibt es eine "umgekehrte" Division:
11 / 2 % normale Division (Rechtsdivision)
11 \ 2 % umgekehrte Division (Linksdivision)
Ausgabe:
ans = 5.5000
ans = 0.1818
Potenzieren kann man so:
12^5
Ausgabe:
ans = 248832
Den Modulo-Operator % wie in C/C++, Java oder Python gibt es in Octave '''nicht'''. Das Prozentzeichen ist dem Kommentar vorbehalten. Man kann aber eine Funktion hierfür benutzen
y = mod(20, 3)
Ausgabe:
y = 2
Runden mit und auf Ganzzahlen kann man in Octave so:
a = int32(10);
b = int32(3);
x = a / b
y = int32(15) / int32(4)
Ausgabe:
x = 3
y = 4
Siehe dazu aber auch die Funktionen <code>floor</code>, <code>ceil</code> und <code>idivide</code>.
Mittels <code>int32()</code> werden Zahlen als 32-Bit-Ganzzahlen dargestellt. Standardmäßig ist der Datentyp nämlich <code>double</code>. Das ist zu beachten, es ergeben sich unterschiedliche Ergebnisse.
Beispiel:
clear();
a = int32(10);
b = int32(3);
x = a / b
c = 10;
d = 3;
y = c / d
whos()
Ausgabe:
x = 3
y = 3.3333
Variables visible from the current scope:
variables in scope: top scope
Attr Name Size Bytes Class
==== ==== ==== ===== =====
a 1x1 4 int32
b 1x1 4 int32
c 1x1 8 double
d 1x1 8 double
x 1x1 4 int32
y 1x1 8 double
Total is 6 elements using 36 bytes
Ist der Wertebereich von <code>int32</code> zu klein (4 Bytes, <math>-2^{31}</math> bis <math>2^{31} - 1</math>), so gibt es auch <code>int64</code> (8 Bytes, <math>-2^{63}</math> bis <math>2^{63} - 1</math>).
<code>clear</code> löscht Namen und gibt den Speicherplatz wieder frei. <code>whos()</code> liefert detaillierte Informationen der aktuell definierten Variablen.
== Aufgaben ==
* Berechnen Sie mit Octave den Ausdruck <math>\frac{1}{2}\cdot e^2 \cdot \tan(\pi/3)</math>.
* Berechnen Sie mit Octave den Ausdruck <math>2\; \text{cosd}(60) - 3\sin(\pi/5)</math>. Anmerkung: cosd erwartet den Parameter im Gradmaß (d für "degree"), sin erwartet den Parameter im Bogenmaß.
* Erkunden Sie die Fehlerfunktion "erf" mittels Octave-Hilfe.
* Welche Zahl ergibt sich durch <code>3 / 4 \ 2</code>?
* Welche Zahlen werden durch die folgenden Anweisungen ausgegeben?
idivide(int32(10), int32(3), "fix")
idivide(int32(10), int32(3), "round")
idivide(int32(10), int32(3), "floor")
idivide(int32(10), int32(3), "ceil")
floor(10.3)
ceil(10.3)
= Octave als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.m
% Das ist ein Kommentar
# und das auch
disp "Hallo Welt!"
Skriptdateien müssen mit der Dateiendung .m versehen werden. In der Octave-Konsole fügen Sie den Dateipfad mittels
octave-3.0.3.exe:1> addpath("c:/tmp")
hinzu (es ist der UNIX-spezifische Slash (/) zu benutzen). Alternativ können Sie zumindest unter MS Windows auch einen Doppel-Backslash (\\) einsetzen. Oder Sie wechseln mittels <code>cd c:/tmp</code> direkt ins Verzeichnis <code>c:/tmp</code>.
Danach bringen Sie die Skriptdatei test1.m (sozusagen das Hauptprogramm) zur Ausführung
octave-3.0.3.exe:2> test1
Achtung: Die Datei (die Funktion oder das Hauptprogramm) ist in der Octave-Kommandozeile ohne .m-Dateiendung anzugeben. Wie erwartet ergibt sich folgende Ausgabe am Bildschirm
Hallo Welt!
Zumindest unter Linux können Sie z.B. auch komfortabel den {{W|Shebang|Shebang}} (<code>#!</code>) nutzen. Gegeben sei das Octave-Script
#!/usr/bin/octave
disp("Hallo Welt!");
Gepeichert sei es ebenfalls als <code>test1.m</code>. Starten Sie ein Terminal, wechseln Sie in das entsprechende Arbeitsverzeichnis und geben Sie
./test1.m
ein, so erhalten Sie wieder
Hallo Welt!
als Ausgabe auf dem Terminal. Die Zugriffsberechtigung muss natürlich mittels <code>chmod</code> richtig gesetzt werden. Oder Sie führen direkt Octave mit der Datei <code>test1.m</code> aus:
octave test1.m
Sie sehen, mehrere Wege führen zum Ziel.
== Blockkommentare ==
In neueren Octave-Versionen ab dem Jahr 2009 sind auch Blockkommentare möglich. Blockkommentare werden wie normale Kommentare vom Octave-Interpreter ignoriert.
%{
Das ist ein
Blockkommentar
%}
#{
und das auch
#}
Achtung! Folgendes wäre kein Blockkommentar, sondern ergibt einen Fehler.
#{ Das ist kein
Blockkommentar
#}
Die erste Zeile würde zwar durch das # auskommentiert (Zeilenkommentar), die zweite Zeile aber nicht. Die dritte Zeile ist wieder ein Zeilenkommentar.
== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen.
Gültige Variablenbezeichner wären also:
xyz
x1
_wert
name_anzahl
Da Octave case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
xyz
XYZ
xYz
Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.m gespeichert.
x = 5
y = 10
z = x*y
Bringen Sie die Datei test1.m zur Ausführung, so erhalten Sie folgende Bildschirmausgabe
x = 5
y = 10
z = 50
Normalerweise will man aber nur z anzeigen, die Werte von x und y sind ja bereits bekannt. Dazu fügen Sie an den Anweisungsenden, wie bereits weiter oben erwähnt, bei x und y jeweils ein Semikolon (;) an, um das Anweisungsende explizit zu markieren.
x = 5;
y = 10;
z = x*y
Nun erhalten Sie als Ergebnis nur noch
z = 50
Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben.
x = 5; y = 10; z = x*y
Ausgabe:
z = 50
Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
x = 5;
% inkrementiere x
++x
% x = x - 2
x -= 2
Bildschirmausgabe:
ans = 6
x = 4
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist.
Soll eine Anweisung auf mehrere Zeilen verteilt werden, z.B. weil sie zu lang ist, so kann dies durch Verwendung von drei Punkten (...) geschehen, wie nachfolgend dargestellt.
x = 5;
y = 1000 * x + ...
sin(x/2)
Ausgabe:
y = 5000.6
Diese Drei-Punkte-Methode soll nicht für in Anführungszeichen (") eingeschlossene Strings verwendet werden. Diese Methode ist seit geraumer Zeit "deprecated" und funktioniert mit der Version 9.1.0 gar nicht mehr. Benutzen Sie statt dessen den Backslash (\):
txt = "xxxxxxxxxxxxxxxxxxxx\
yyyyyyyyyyyyyyyyy"
Ausgabe:
txt = xxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyy
Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist in Octave problemlos möglich:
wert = 10
wert = 35.5
wert = "Hallo"
wert = pi
Ausgabe:
wert = 10
wert = 35.500
wert = Hallo
wert = 3.1416
Der Befehl <code>who</code>, bzw. <code>whos</code> listet die gegenwärtig definierten Variablen, z.B.:
clear;
a = 10.5;
v = [1 2 3 4 5 12 13];
m = ["s1", "s2"; "s3", "s4"];
disp "***** Der Befehl who *****"
who
disp "***** Der Befehl whos *****"
whos
Ausgabe:
***** Der Befehl who *****
Variables visible from the current scope:
a m v
***** Der Befehl whos *****
Variables visible from the current scope:
variables in scope: top scope
Attr Name Size Bytes Class
==== ==== ==== ===== =====
a 1x1 8 double
m 2x4 8 char
v 1x7 56 double
Total is 16 elements using 72 bytes
==Hexadezimale und binäre Zahlen==
% Hexadezimale Zahl
disp( 0xABC )
% Binäre Zahl
disp( 0b1000011 )
Ausgabe (als Dezimalzahlen):
2748
67
Octave kann auch dezimale in binäre Zahlen etc. umwandeln:
dec2bin( 214 )
Ausgabe:
ans = 11010110
Siehe dazu in der Octave-Hilfe auch folgende Funktionen:
bin2dec, dec2base, dec2hex, hex2dec, base2dec
== Zahlenkolonnen ==
Eine Zahlenkolonne (oder ein Vektor) mit gleichen Abständen der Werte kann folgendermaßen erzeugt werden:
% a ... Startwert
% b ... Schrittweite
% c ... Endwert
a = 0;
b = 10;
c = 100;
x = a : b : c;
disp(x);
Ausgabe:
0 10 20 30 40 50 60 70 80 90 100
Ähnliche Resultate lassen sich auch durch Anwendung der linspace-Funktion erhalten, z.B.:
% a ... Startwert
% b ... Endwert
% c ... Anzahl der Werte
a = 0;
b = 100;
c = 11;
v = linspace(a, b, c)
Ausgabe:
v =
0 10 20 30 40 50 60 70 80 90 100
== Verzweigungen ==
=== Die IF-Verzweigung ===
Die IF-Verzweigung ist aus anderen Programmiersprachen bereits bekannt. In Pseudocode lässt sie sich folgendermaßen darstellen:
WENN bedingung TRUE
führe block1 aus
SONST
führe block2 aus
ENDE
Die test1.m-Datei laute also wie folgt:
x = 5;
if x < 4
disp "x ist kleiner als 4";
else
disp "Der else-Zweig wird ausgefuehrt";
disp "x ist groesser oder gleich 4";
end
Ausgabe:
Der else-Zweig wird ausgefuehrt
x ist groesser oder gleich 4
Octave kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:
* <, <= ... kleiner (gleich)
* >, >= ... größer (gleich)
* == ... gleich
* ~=, != ... ungleich
* &, && ... AND
* |, || ... OR
* ~, ! ... NOT
Beispielsweise:
a = 5;
b = 9;
if a<=10 & b!=7
disp("OK");
else
disp("Nicht OK");
end
Ausgabe:
OK
Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen <math>\varepsilon</math>-Wert) vorgeben.
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:
i = 0.1 + 0.2;
disp(i)
if(i == 0.3)
disp("OK");
else
disp("NOK");
end
Ausgabe:
0.3000
NOK
Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist. Auch die Ausgabe gaukelt das vor.
Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:
ist = 0.1 + 0.2;
soll = 0.3;
epsilon = 0.000001;
disp(ist);
if(abs(ist-soll) < epsilon)
disp("OK");
else
disp("NOK");
end
Ausgabe:
0.3000
OK
=== Die SWITCH-Verzweigung ===
In Pseudocode:
WECHSLE ZU var
FALLS wert1 == var
führe block1 aus
FALLS wert2 == var
führe block2 aus
...
SONST
führe blockn aus
ENDE
Eine Beispielsimplementierung in Octave könnte so aussehen:
x = "g";
switch(x)
case "k"
disp("klein");
case "g"
disp("gross");
otherwise
disp("sonstiges")
end
Ausgabe:
gross
Anmerkungen für C-Programmierer:
* in Octave darf zum Abschluß von ''case'' kein Doppelpunkt folgen (würde einen Syntaxfehler auslösen).
* ein ''break'' als Abschluß eines ''case''-Blocks ist nicht erlaubt (würde in Octave einen parse error auslösen). ''break'' ist Schleifen vorbehalten. ''switch'' hat in Octave keinen "Durchfall" und ähnelt somit eher der Fortran-Anweisung ''select case''.
Mehrere Fälle in einem ''case'' können wie nachfolgend behandelt werden:
x = "K";
switch(x)
case {"k" "K"}
disp("klein");
case {"g" "G"}
disp("gross");
otherwise
disp("sonstiges")
end
Ausgabe:
klein
== Schleifen ==
=== Die WHILE-Schleife ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt.
In Pseudocode:
SOLANGE bedingung TRUE
führe block aus
ENDE
In Octave:
x = 0;
while x <= 10
disp(x);
x++;
end
Ausgabe:
0
1
2
3
4
5
6
7
8
9
10
=== Die DO-UNTIL-Schleife ===
Die DO-UNTIL-Schleife ist fußgesteuert. Beachte: Diese Schleife ist nicht äquivalent zu der aus anderen Programmiersprachen bekannten DO-WHILE-Schleife. DO-WHILE bedeutet "TUE SOLANGE", DO-UNTIL bedeutet "TUE BIS". Sie wird mindestens einmal ausgeführt.
Pseudocode:
TUE
führe block aus
BIS bedingung TRUE
Mittels Octave:
x = 0;
do
disp(x);
x++;
until(x >= 5)
Ausgabe:
0
1
2
3
4
=== Die FOR-Schleife ===
for x = 0 : 2 : 10
disp(x);
end
Ausgabe:
0
2
4
6
8
10
Der FOR-Schleifenkopf ist in Form einer Zahlenkolonne folgendermaßen aufgebaut:
for variable = startwert : schrittweite : endwert
Man beachte, dass Vektorisierung gegenüber einem Schleifendurchlauf eine erhebliche Zeiteinsparung bewirken kann (man siehe in der [https://docs.octave.org/latest/Vectorization-and-Faster-Code-Execution.html Octave-Dokumentation das Kapitel 19 "Vectorization and Faster Code Execution"]). Folgendes Beispiel ist an genanntes Octave-Kapitel angelehnt. Zuerst wird eine Berechnung mittels Schleifendurchlauf durchgeführt und der Zeitbedarf ausgegeben. Dieser Zeitbedarf hängt natürlich auch von der verwendeten Hardware etc. ab.
Eingabe:
n = m = 500;
a = b = eye(500);
t1 = time();
for i = 1:n
for j = 1:m
c(i,j) = a(i,j) + b(i,j);
endfor
endfor
t2 = time();
t_diff = t2-t1
Ausgabe:
t_diff = 3.7566
Der Zeitverbrauch beträgt hier also ca. 4 Sekunden. Im Gegensatz dazu
Eingabe:
a = b = eye(500);
t1 = time();
c = a + b;
t2 = time();
t_diff = t2-t1
Ausgabe:
t_diff = 1.5974e-05
ist der Zeitverbrauch hier sehr gering. Vektoren und Matrizen werden etwas später in diesem Text detailliert behandelt. Hier nur soviel: Mittels ''eye'' wird eine Einheitsmatrix kreiert.
Octave hat im Gegensatz zu MATLAB keinen {{W|Just-in-time-Kompilierung|JIT-Compiler}} (JIT ... '''J'''ust '''i'''n '''T'''ime). Darum ist Vektorisierung gerade hier von eminenter Bedeutung.
=== Schleifen abbrechen ===
Zum Abbrechen einer Schleife gibt es den Befehl "break".
for var = 0 : 1 : 100
disp (var);
if var == 5
break;
end
end
Ausgabe:
0
1
2
3
4
5
"continue" setzt mit dem nächsten Schleifendurchlauf fort, z.B.
for var = 0 : 1 : 10
if var == 5
continue;
end
disp (var);
end
Ausgabe:
0
1
2
3
4
6
7
8
9
10
== Aufgaben ==
* Berechnen Sie die Summe der ersten 10000 natürlichen Zahlen (bei 1 beginnend)
** in Form einer WHILE-Schleife
** in Form einer DO-UNTIL-Schleife
** in Form einer FOR-Schleife
** mittels sum-Befehl (siehe dazu auch die von Octave zur Verfügung gestellte Hilfefunktion).
** mittels gaußscher Summenformel (<math>\sum_{i=1}^n{i} = 1+2+...+n = n(n+1) / 2</math>)
* Schreiben Sie für obige Alternativen Programme mit denen der Zeitbedarf der Schleifen, Befehle bzw. Formeln gemessen werden kann. Welche Alternativen sind aus Zeitgründen (minimale Laufzeit) empfehlenswert?
= Grafiken zeichnen =
== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall <math>x\in[-3,3]</math> gezeichnet werden. Der Programmcode lautet in der einfachsten Form:
x = -3 : .1: 3;
y = cosh(x);
plot(x,y);
grid on;
Ausgabe:
[[Datei:octave_cosh.jpg]]
Der Code ist quasi selbsterklärend. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. "plot" ist der Zeichenbefehl. "grid on" schaltet ein Zeichengitter ein.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen.
Sie könnten nun auf die Idee kommen, obiges Script unter Linux mit der Shebang-Zeile zu erweitern, um es direkt als Programm auszuführen.
#!/usr/bin/octave
x = -3 : .1: 3;
y = cosh(x);
plot(x,y);
grid on;
Die Enttäuschung folgt auf dem Fuß. Außer einem kurzen Aufblinken des Grafikfensters ist nicht viel zu sehen. Das Programm läuft einfach durch und wird nach der letzten Anweisung beendet. Abhilfe kann z.B. der <code>input</code>-Befehl schaffen:
#!/usr/bin/octave
x = -3 : .1: 3;
y = cosh(x);
plot(x,y);
grid on;
refresh();
input("Zum Beenden RETURN-Taste drücken");
Das Programm wartet somit, bis Sie im Terminal die RETURN-Taste drücken. <code>refresh()</code> dient dazu, das Grafikfenster unmittelbar zu aktualisieren. Sonst würde das Ausgabefenster leer bleiben, bis es durch externe Anreize aktualisiert wird (z.B. durch Fenster minimieren/maximieren). Gleiches gilt für die <code>octave test1.m</code>-Variante.
Ein etwas komplexeres Beispiel ist Folgendes
x = -3 : .1: 3;
y = cosh(x) + 2.^x;
plot(x,y);
grid on;
Man beachte den Punkt bei 2.^x (2 hoch x). Vergisst man den Punkt, dann erhält man eine Fehlermeldung (ähnlich dieser):
error: for x^y, only square matrix arguments are permitted and one argument must be scalar. Use .^ for elementwise power.
error: called from
test1 at line 2 column 3
Ausgabe:
[[Datei:octave_cosh2.jpg]]
Der Funktionsgraph kann auch als Fläche eingefärbt werden:
x = -3 : .1: 3;
y = cosh(x) + 2.^x;
fill (x, y, "b");
Ausgabe:
[[Datei:octave_cosh3.jpg | 500px]]
=== Graphen mehrerer Funktionen und weiteres ===
Mehrere Graphen lassen sich folgendermaßen in ein Fenster zeichnen:
x = -3 : .1: 3;
y1 = cosh(x) + 2.^x;
y2 = sin(x) .* cos(x);
plot(x,y1, x,y2);
title("Funktionsgraphen");
legend("cosh ...", "sin ...");
xlabel("x");
ylabel("y");
grid on;
[[Bild:octave_cosh14.jpg|600px]]
Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht:
x = -3 : .1: 3;
y1 = cosh(x) + 2.^x;
y2 = sin(x) .* cos(x);
plot(x,y1,"*r", x,y2,"ob");
title("Funktionsgraphen");
legend("cosh ...", "sin ...");
xlabel("x");
ylabel("y");
grid on;
[[Datei:octave_cosh4.jpg]]
Bei plot kann auch der Linienstil des jeweiligen Graphen angegeben werden, z.B. steht
* für Sternchenlinie
o für Kreise in der Linie
r für rot
b für blau
Ein ähnliches Resultat liefert der Code:
x = -3 : .1: 3;
y1 = cosh(x) + 2.^x;
y2 = sin(x) .* cos(x);
plot(x,y1, "Color", "red", "*", x,y2, "Color", "blue", "o");
title("Funktionsgraphen");
legend("cosh ...", "sin ...");
xlabel("x");
ylabel("y");
grid on;
Will man mehrere Graphen in ein Fenster zeichnen, aber nicht alles in einen plot-Befehl quetschen, so kann die "hold on"-Anweisung die Lösung des Problems sein:
%Lösche alle benutzerdefinierten Variablen aus der Symboltabelle
clear;
%Schließe alle Fenster
close all;
%Lösche Konsolenfenster und setze Cursor zurück
clc;
x = -3 : .1: 3;
y1 = cosh(x) + 2.^x;
y2 = sin(x) .* cos(x);
plot(x,y1, "Color", "red");
hold on;
plot(x,y2, "Color", "blue");
title("Funktionsgraphen");
legend("cosh ...", "sin ...");
xlabel("x");
ylabel("y");
grid on;
[[Datei:octave_coshsin1.jpg]]
Bei diesem Program wurden auch einige Möglichkeiten (clear, close, clc) gezeigt, um das System aufzuräumen. Ein "hold off" würde natürlich die hold-Funktion wieder ausschalten.
=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale <math>x = t \cos(t), y = t \sin(t)</math> im Intervall <math>[0, 6\pi]</math> gezeichnet werden.
clear;
close all;
clc;
t = 0 : .1: 6*pi;
x = t .* cos(t);
y = t .* sin(t);
plot(x,y);
grid on;
[[Datei:octave_spirale1.jpg]]
Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den axis-Befehl verwenden (axis muss nach plot erscheinen).
t = 0 : .1: 6*pi;
x = t .* cos(t);
y = t .* sin(t);
plot(x,y);
grid on;
axis equal;
[[Datei:octave_spirale222.jpg]]
=== Strichstärke ===
Für manche Zwecke ist es sinnvoll die Strichstärke des Graphen zu erhöhen. Dies kann über den Parameter "LineWidth" der plot-Funktion geschehen.
t = 0 : .1: 6*pi;
x = t .* cos(t);
y = t .* sin(t);
plot(x,y, "LineWidth", 2);
grid on;
axis equal;
Ausgabe:
[[Datei:octave_spirale3.jpg]]
=== Beliebigen Text ausgeben ===
x = -10:0.1:10;
plot (x, sin (x), "LineWidth", 2);
text (2.7, 0.8, "Das ist die sin-Funktion");
Ausgabe:
[[Datei:octave_text1.jpg]]
=== Logarithmische Achseneinteilung ===
x = -3 : .1: 3;
y = cosh(x) + 2.^x;
% Halblogarithmische Darstellung
semilogy(x,y);
grid on;
Ausgabe:
[[Datei:octave_semilog1.jpg]]
Auch die x-Achse kann mit "semilogx" logarithmisch skaliert werden. Mit "loglog" werden beide Achsen logarithmisch skaliert.
=== Aufgaben ===
* Zeichnen Sie die Strophoide <math>x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3</math>. Das Ganze sollte in etwa so aussehen wie folgende Grafik:
[[Datei:octave_strophoide.jpg]]
* Zeichnen Sie die verschlungene Hypozykloide <math>x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15</math>. Das Ganze sollte in etwa so aussehen wie folgende Grafik:
[[Datei:octave_hypozykloide.jpg]]
* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben (Hinweis: Siehe dazu auch die Octave-Hilfefunktion für den plot-Befehl).
* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.
* Erkunden Sie in der Octave-Hilfe den ezplot-Befehl.
== Gitterlinien und Koordinatenachsen ==
* Zwischengitterlinien aktivieren: <code>grid minor;</code>
* Gitterabstände exakt selbst festlegen, z.B.: <code>set(gca, "XTick", -10 : 1 : 10);</code>
* Gitterfarben und -linienstile anpassen, z.B.:
set(gca, 'GridColor', [0.1, 0.1, 0.1]);
set(gca, 'GridLineStyle', '-');
set(gca, 'MinorGridColor', [0.2, 0.2, 0.2]);
set(gca, 'MinorGridLineStyle', '--');
* Koordinatenachsen selbst festlegen, z.B.
axis([-2, 10, -3, 8]); % x-Achse von -2 bis 10, y-Achse von -3 bis 8
* Markierungen auf den Achsen einstellen, z.B. <code>xticks(0:1:10);</code>
* Achsenkreuz auf 0 setzen:
set(gca, "xaxislocation", "origin");
set(gca, "yaxislocation", "origin");
* Umhüllende Linien abschalten: <code>box off;</code>
<code>gca</CODE> steht übrigens für '''g'''et '''c'''urrent '''a'''xes. Analog dazu gibt es auch <code>gcf</code> ('''g'''et '''c'''urrent '''f'''igure) und <code>gco</code> ('''g'''et '''c'''urrent '''o'''bject). Das ist aber alles schon sehr speziell und wird hier nicht vertieft.
=== Aufgabe ===
Probieren Sie die oben stichpunktartig angegebenen Möglichkeiten an konkreten Programmbeispielen aus.
== 3D ==
=== Räumliche Kurven ===
Mittels "plot3" lassen sich Raumkurven zeichnen.
t = 0 : .1 : 9*pi;
x = cos(t);
y = sin(t);
z = 1.3 .^ t;
plot3(x,y,z);
grid on;
[[Datei:octave_raumkurve1.jpg]]
=== Flächen ===
==== ezsurf ====
Die wahrscheinlich einfachste Möglichkeit 3D-Flächen zu erzeugen, besteht in der Verwendung des ezsurf-Befehls. Beachten Sie beim folgenden Beispiel auch wieder den Punkt beim Multiplikationssymbol (elementweise Multiplikation soll verwendet werden, keine Matrizenmultiplikation) in der anonymen Funktion. Was eine anonyme Funktion ist, wird weiter hinten in diesem Text kurz erklärt. Fürs Erste reicht es zu wissen, dass die Funktion f(x, y) jeweils im Intervall [0, 10] gezeichnet werden soll.
clear; close all; clc; clf;
f = @(x, y) sin(x) + 3.*cos(y);
ezsurf (f, [0, 10]);
[[Bild:octave_ezsurf1.jpg|600px]]
Dieses Bild wurde mit der Octave-Version 5.2 erstellt. Es ist im Prinzip identisch zu jenen des folgenden Abschnitts, die mit der Version 3.0.3 erstellt wurden, nur die Farbschattierung ist anders. Ändern lässt sich diese Eigenschaft mit dem colormap-Befehl (siehe auch Octave-Hilfe):
clear; close all; clc; clf;
colormap(hot);
f = @(x, y) sin(x) + 3.*cos(y);
ezsurf (f, [0, 10]);
[[Bild:octave_colormap_hot.jpg|600px]]
==== surf und mesh ====
Für das Zeichnen von Flächen existiert der surf-Befehl. Der meshgrid-Befehl kreiert ein Netz in der xy-Zeichenebene. Beachten Sie beim folgenden Beispiel auch wieder den Punkt beim Multiplikationssymbol der Formel für z.
x = 0 : .1 : 10;
y = 0 : .1 : 10;
[x_grid, y_grid] = meshgrid(x, y);
z = sin(x_grid) + 3.*cos(y_grid);
surf(x_grid, y_grid, z);
[[Datei:octave_flaeche1.jpg]]
Auch ein Farbstreifen kann via "colorbar" zur Grafik hinzugefügt werden.
x = 0 : .1 : 10;
y = 0 : .1 : 10;
[x_grid, y_grid] = meshgrid(x, y);
z = sin(x_grid) + 3.*cos(y_grid);
surf(x_grid, y_grid, z);
colorbar("East");
[[Datei:octave_flaeche2.jpg]]
Das Ganze in Netzdarstellung läßt sich so programmieren:
x = 0 : .2 : 10;
y = 0 : .2 : 10;
[x_grid, y_grid] = meshgrid(x, y);
z = sin(x_grid) + 3.*cos(y_grid);
mesh(x_grid, y_grid, z);
Ausgabe:
[[Datei:octave_mesh1.jpg]]
==== Ellipsoide und Kegel ====
Für das Zeichnen von Kugeln oder Ellipsoiden stellt Octave den "sphere"-Befehl bzw. den "ellipsoid"-Befehl zur Verfügung.
clear; close all; clc;
% Ellipsoiden zeichnen
[x, y, z] = sphere(30);
surf(5*x, 4*y, 3*z);
hold on;
[x, y, z] = ellipsoid(5, 5, 5, 6, 3, 2, 30);
surf(x, y, z);
axis equal;
[[Bild:octave_ellipsoid2.jpg|600px]]
Für Zylinder und Kegel ist der "cylinder"-Befehl zuständig.
clear; close all; clc;
% Kegel und Zylinder zeichnen
[x, y, z] = cylinder([1 2], 100);
surf(x, y, z*3);
hold on;
[x, y, z] = cylinder([0.5 0.5], 50);
surf(x+3, y, z*2);
axis equal;
[[Bild:octave_cylinder2.jpg|600px]]
=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve <math>x = 2 \cdot \cosh(t)</math>, <math>y = 5 \cdot \sin(t)</math>, <math> z = t^{2} - t</math>, <math>0 \leq t \leq 3\pi</math>. Das Ganze sollte etwa wie folgt aussehen:
[[Datei:octave_kurve10.jpg]]
* Zeichnen Sie die Fläche <math>z = \log(x) + \cos(y)</math>. Das Ganze sollte etwa wie folgt aussehen:
[[Datei:octave_flaeche10.jpg]]
== Weiteres ==
=== subplot ===
Zeichnen mit Untergrafiken: Hier wird z.B. ein Fenster mit drei Untergrafiken gezeichnet.
Eingabe:
t = 0 : .5 : 10;
[x_grid, y_grid] = meshgrid(t, t);
subplot(311);
surf(x_grid, y_grid, sin(x_grid) + cos(y_grid) );
subplot(312);
surf(x_grid, y_grid, sin(x_grid) + log(y_grid) );
subplot(313);
surf(x_grid, y_grid, x_grid + cos(y_grid) );
Ausgabe:
[[Datei:octave_subplot2.jpg]]
Die dreistellige Ziffer beim subplot-Befehl bedeutet folgendes:
* Die erste Ziffer ist die Zeilenanzahl
* Die zweite Ziffer ist die Reihenanzahl und
* Die dritte Ziffer ist der Index.
Beim obigen Beispiel ist die z-Achse ein bisschen zusammengedrückt. Dies wollen wir mit nachfolgendem Code ansatzweise "verbessern" und ein paar weitere Spielereien mit Subplots durchführen.
t = 0 : .5 : 10;
[x_grid, y_grid] = meshgrid(t, t);
% fig = figure();
ax1 = subplot(4, 1, 1:2);
surf(x_grid, y_grid, sin(x_grid) + cos(y_grid) );
grid(ax1, "minor");
axis(ax1, [0, 10, 0, 20, -2, 2]);
ax2 = subplot(413);
surf(x_grid, y_grid, sin(x_grid) + log(y_grid) );
ax3 = subplot(414);
surf(x_grid, y_grid, x_grid + cos(y_grid) );
% refresh();
% input();
[[Datei:octave_subplot105.svg| 400px]]
Nun sei ein Beispiel mit 3x2-Untergrafiken angeführt.
clear;
close all;
clc;
x = 0 : .1 : 10;
subplot(321);
plot(x, sin(x));
text(2, -0.5, "Index 1");
subplot(322);
plot(x, tan(x));
text(2, 2, "Index 2");
subplot(323);
plot(x, cosh(x) );
text(2, 3000, "Index 3");
subplot(324);
plot(x, gamma(x) )
text(2, 100000, "Index 4");
subplot(325);
plot(x, log(x) );
text(2, 0, "Index 5");
subplot(326);
plot(x, exp(x) );
text(2, 10000, "Index 6");
Ausgabe:
[[Datei:octave_subplot3.jpg]]
Hier ist sehr gut zu sehen, in welcher Reihenfolge der Index läuft.
Will man bspw. die Hintergrundfarbe eines Subplots setzen (z.B. auf die Farbe rot), so kann dies über folgende Befehle geschehen:
ax1 = subplot(321);
set(ax1, "color", [1.0, 0.0, 0.0]);
=== figure ===
Zeichnen in verschiedene Fenster, z.B.
clear;
close all;
clc;
x = 0 : .1 : 10;
y = 0 : .1 : 10;
[x_grid, y_grid] = meshgrid(x, y);
figure(1)
surf(x_grid, y_grid, sin(x_grid) + cos(y_grid));
figure(2)
surf(x_grid, y_grid, sin(x_grid) + log(y_grid));
Ausgabe:
[[Datei:octave_figure111.jpg|700px]]
Die Größe und Position eines Fensters können festgelegt werden:
f1 = figure(1, "Position", [100, 100, 800, 600]);
Hintergrundfarbe setzen
f2 = figure(2, 'Color', [1.0, 0.0, 0.0]);
oder auch per
set(f1, 'Color', [1.0, 0.0, 0.0]);
=== Linien zeichnen ===
Zeichnen Sie eine Linie von der Koordinate [-15, 0] zu [15, 5]:
clear;
close all;
clc;
x = line([-15 15], [0, 5], "Color", "black", "LineWidth", 2);
Ausgabe:
[[Datei:octave_linie1.jpg]]
Man beachte, dass Octave nicht Punkte P1(x1, y1), P2(x2, y2) erwartet, sondern einen x-Vektor [x1 x2] und einen y-Vektor [y1 y2].
Ein allgemeines Viereck wird z.B. mit folgendem Befehl gezeichnet.
line([-15 15 10 -5, -15], [0, 5, 20, 15, 0], "LineWidth", 2);
[[Datei:octave_viereck2.jpg]]
Auch dreidimensionale Formen lassen sich mit dem line-Befehl zeichnen:
clear; close all; clc;
line([-15 15 10 -5, -15], [0, 5, 20, 15, 0], [10, 20, 30, 40, 50], "LineWidth", 2);
[[Datei:octave_dreidim2.jpg]]
=== Aufgaben ===
* Zeichnen Sie mittels "subplot" die Funktionsgrafen <math>y_1=\tan(x), y_2=\tan(2x), y_3=\tan\sqrt x, y_4=x\cdot \tan(x)</math> in folgender Form in ein Fenster:
** in 2x2-Darstellung
** in 1x4-Darstellung.
* Zeichnen Sie die im obigen Beispiel angegebenen Funktionsgrafen mittels "figure" jeweils in ein eigenes Fenster.
= Vektoren und Matrizen =
== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein.
=== Zeilen- und Spaltenvektoren ===
% Ein Zeilenvektor
v1 = [1, 2, 3]
% Ein Spaltenvektor
v2 = [6; 7; 8]
Ausgabe:
v1 =
1 2 3
v2 =
6
7
8
Alternative Schreibweisen:
% Ein Zeilenvektor
v1 = [1 2 3]
% Ein Spaltenvektor
v2 = [6
7
8]
Die Ausgabe entspricht der obigen Darstellung.
=== Zugriff auf Vektorelemente ===
Nachfolgend seien einige Zugriffsmöglichkeiten auf die einzelnen Vektorelemente erläutert.
Auf ein einzelnes Element kann via Index zugegriffen werden. Der Index startet bei 1:
v1 = [1 2 4 8 16];
v2 = v1(3)
Ausgabe:
v2 = 4
Mehrere Elemente werden folgendermaßen angesprochen:
v1 = [1 2 4 8 16];
v2 = v1(3:4)
Ausgabe:
v2 =
4 8
Liefere den Teilvektor von einem gegebenen Index bis zum letzten Element:
v1 = [1 2 4 8 16];
v2 = v1(3:end)
Ausgabe:
v2 =
4 8 16
=== Addition und Subtraktion von Vektoren ===
v1 = [1, 2, 3];
v2 = [5, 7, 9];
res = v1 + v2
res = v1 - v2
Ausgabe:
res =
6 9 12
res =
-4 -5 -6
=== Multiplikation mit Skalaren ===
faktor = 3;
v = [1, 2, 3];
res = faktor * v
Ausgabe:
res =
3 6 9
=== Skalarprodukt ===
Das Skalarprodukt ist bekanntermaßen als <math>v_1 \cdot v_2 = |v_1| |v_2| \cos(\angle(v_1, v_2))</math> definiert. In Octave sieht das so aus:
v1 = [1, 2, 3];
v2 = [5, 6, 7];
res = dot(v1, v2)
Ausgabe:
res = 38
=== Vektorprodukt ===
v1 = [1, 2, 3];
v2 = [5, 6, 7];
res = cross(v1, v2)
Ausgabe:
res =
-4 8 -4
Enger an die mathematische Darstellung lehnt sich folgender Code an. Die zu multiplizierenden Vektoren seien in Form von Spaltenvektoren gegeben.
Mathematisch:
<math>a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
</math>
Octave-Code:
a = [1
2
3];
b = [5
6
7];
res = cross(a, b)
Ausgabe:
res =
-4
8
-4
=== Transponierter Vektor ===
v1 = [1, 2, 3];
v2 = [5; 6; 7];
res1 = v1'
res2 = v2'
Ausgabe:
res1 =
1
2
3
res2 =
5 6 7
=== Einige weitere Vektorfunktionen ===
Beispiel:
% 1 + 2 + 3
v = [1 2 3];
sum(v)
Ausgabe:
ans = 6
Beispiel:
% 1 * 2 * 3 * 4
v = [1 2 3 4];
prod(v)
Ausgabe:
ans = 24
Beispiel:
% 1^2 + 2^2 + 3^2
v = [1 2 3];
sumsq (v)
Ausgabe:
ans = 14
== Matrizen ==
Gegeben sei folgende 2x3-Matrix <math>m=\left(\begin{array}{ccc}
1 & 2 & 3\\
4 & 5 & 6
\end{array}\right)</math>.
Eingabe:
m = [1, 2, 3; 4, 5, 6]
Ausgabe:
m =
1 2 3
4 5 6
Alternativ und anschaulicher kann diese 2x3-Matrix auch so eingegeben werden:
m = [1 2 3
4 5 6]
Dies ist schon sehr nahe an der mathematischen Darstellungsweise.
=== Zugriff auf Matrizenelemente ===
m = [1 2 3
4 5 6];
% Element aus Zeile 2 und Spalte 3
m(2,3)
Ausgabe:
ans = 6
Eine andere Zugriffsmöglichkeit ist diese:
m = [1 2 3
4 5 6];
% Auf das fünfte Element soll zugegriffen werden
m(5)
Ausgabe:
ans = 3
Die Matrix wird also spaltenweise durchlaufen (nicht zeilenweise). Dies ist vielleicht auf den ersten Blick etwas ungewöhnlich, wird aber z.B. auch in Fortran so gehandhabt.
Auch Teilmatrizen können einfach gebildet werden:
m = [1 2 3
4 5 6];
m(2:end, 2:end)
Ausgabe:
ans =
5 6
Siehe zu diesem Thema auch etwas weiter hinten in diesem Text den Abschnitt "Teilmatrizen".
=== Addition und Subtraktion von Matrizen ===
m1 = [1, 2, 3; 4, 5, 6];
m2 = [-4, -2, 0; 2, 4, 6];
m1 + m2
m1 - m2
Ausgabe:
ans =
-3 0 3
6 9 12
ans =
5 4 3
2 1 0
=== Transponierte Matrix ===
m = [1, 2, 3; 4, 5, 6];
m'
Ausgabe:
ans =
1 4
2 5
3 6
=== Rang einer Matrix ===
Der Rang einer Matrix Rg(M) ist die maximale Anzahl der linear unabhängigen Zeilenvektoren (Spaltenvektoren).
m1 = [1, 2, 3; 4, 5, 6];
m2 = [1, 2; 2, 4];
rank(m1)
rank(m2)
Ausgabe:
ans = 2
ans = 1
Regulär ist eine nxn-Matrix, wenn der Rg(M) = n. D.h. die erste Matrix m1 ist regulär, die zweite m2 singulär.
=== Inverse Matrix ===
m1 = [1, 3; 0, -5 ];
m2 = [1, 2; 2, 4];
inv(m1)
inv(m2)
Ausgabe:
ans =
1.00000 0.60000
0.00000 -0.20000
warning: matrix singular to machine precision
warning: called from
test1 at line 4 column 1
ans =
Inf Inf
Inf Inf
Die Matrix m2 in diesem Beispiel ist singulär (d.h. die Determinante ist 0). Determinanten werden etwas weiter unten in diesem Text behandelt. Inf steht für Infinity (= Unendlich).
=== Multiplikation von Matrizen (falksches Schema) ===
m1 = [1, 3, 4; 0, -5, 1];
m2 = [1, 2; 2, 3; 0, 2];
m1 * m2
Ausgabe:
ans =
7 19
-10 -13
Will man aus irgendwelchen Gründen nicht das falksche Schema ausführen, sondern elementweise Multiplikation, so funktioniert das mit dem Punkt-Operator, z.B.
m1 = [1, 3; 0, -5];
m2 = [1, 2; 4, 2];
% falksches Schema
m1 * m2
% elementweise Multiplikation
m1 .* m2
Ausgabe:
ans =
13 8
-20 -10
ans =
1 6
0 -10
Verifikation, falksches Schema (Zeile*Spalte):
[ 1 3 ] [ 1 2 ] [ 1*1+3*4 1*2+3*2 ] [ 13 8 ]
[ 0 -5 ] [ 4 2 ] = [ 0*1-4*5 0*2-5*2 ] = [ -20 -10 ]
Verifikation, elementweise Multiplikation (homologe Elemente):
[ 1 3 ] [ 1 2 ] [ 1*1 3*2 ] [ 1 6 ]
[ 0 -5 ] [ 4 2 ] = [ 0*4 -5*2 ] = [ 0 -10 ]
=== Determinante einer Matrix ===
m1 = [1, 3; 0, -5 ];
m2 = [1, 2; 2, 4];
det(m1)
det(m2)
Ausgabe:
ans = -5
ans = 0
m1 ist regulär, m2 ist singulär. Determinanten können nur von quadratischen Matrizen gebildet werden.
=== Teilmatrizen ===
m = [1, 2, 3; 0, 5, 1];
% Die Matrix in einen Spaltenvektor umwandeln
m1 = m(:)
% Das Element aus der 1. Zeile und der 2. Spalte extrahieren
m2 = m(1,2)
% Erste Zeile extrahieren
m3 = m(1, 1:3)
m4 = m(1, :)
% Zweite Spalte extrahieren
m5 = m(1:2, 2)
m6 = m(:, 2)
Ausgabe:
m1 =
1
0
2
5
3
1
m2 = 2
m3 =
1 2 3
m4 =
1 2 3
m5 =
2
5
m6 =
2
5
=== Einheitsmatrizen ===
eye(3,2)
Ausgabe:
ans =
1 0
0 1
0 0
=== Nullmatrizen ===
zeros(2,3)
Ausgabe:
ans =
0 0 0
0 0 0
=== Diagonalmatrizen ===
diag([1, 2, 3])
Ausgabe:
ans =
1 0 0
0 2 0
0 0 3
=== Spur einer Matrix ===
trace([1,2,3; 6,9, 0])
Ausgabe:
ans = 10
=== LR-Zerlegung einer Matrix ===
Führen Sie die LR-Faktorisierung (LR ... links/rechts bzw. LU ... left/upper) einer Matrix m aus. l sei die linke Dreiecksmatrix, r die rechte Dreiecksmatrix und p die Permutationsmatrix
m = [1 0 5
-1 1 -2
0 0 3];
[l, r, p] = lu(m)
Ausgabe:
l =
1 0 0
-1 1 0
0 0 1
r =
1 0 5
0 1 3
0 0 3
p =
1 0 0
0 1 0
0 0 1
=== Eigenwerte ===
a = [5 8
1 3];
% Eigenvektoren und Eigenwerte
[ev, ew] = eig(a)
Ausgabe:
ev =
0.9701 -0.8944
0.2425 0.4472
ew =
Diagonal Matrix
7 0
0 1
Die Eigenwerte sind hier <math>\lambda_1 = 7</math> und <math>\lambda_2 = 1</math>. Die Eigenvektoren sind [0.9701 0.2425] bzw. [-0.8944 0.4472]. Da das Gleichungssystem <math>(A - \lambda_i E) x_i = 0</math> singulär ist, sind alle Lösungsvektoren Vielfache dieser Eigenvektoren.
=== Schwach besetzte Matrizen ===
{{Wikipedia | Dünnbesetzte Matrix}}
Gegeben sei die schwach besetzte Matrix
m = [0 1 0 0 0
0 0 0 3 0
4 0 0 2 0
0 0 1 0 0
0 0 0 1 7]
Mittels dem sparse-Befehl kann man einfach die Elemente != 0 nach folgendem Schema eingeben.
sparse ([zeilenindizes] [spaltenindizes] [werte])
also in unserem Fall:
ms = sparse([1 2 3 3 4 5 5], [2 4 1 4 3 4 5], [1 3 4 2 1 1 7])
Ausgabe:
ms =
Compressed Column Sparse (rows = 5, cols = 5, nnz = 7)
(3, 1) -> 4
(1, 2) -> 1
(4, 3) -> 1
(2, 4) -> 3
(3, 4) -> 2
(5, 4) -> 1
(5, 5) -> 7
Die volle Matrix erhält man mit dem Befehl full:
m = full(ms)
Ausgabe:
m =
0 1 0 0 0
0 0 0 3 0
4 0 0 2 0
0 0 1 0 0
0 0 0 1 7
Grafisch anzeigen lassen kann man sich die Besetzung von Matrizen mit dem spy-Befehl:
spy(ms);
oder (für allgemeine Matrizen auch mittels)
spy(m);
Ausgabe:
[[Datei:octave_sparse1.jpg]]
Wirklich interessant ist der spy-Befehl für größere Matrizen, z.B. um die Bandstruktur zu visualisieren.
e = eye(200);
es = sparse(e);
% Auf sparse-Matrizen kann genauso zugegriffen werden wie auf normalen Matrizen
es(100, 15) = 100;
spy(es);
Ausgabe:
[[Datei:octave_sparse2.jpg]]
=== Matrizen mit Zufallswerten ===
Insbesondere für Testzwecke kann es manchmal sinnvoll sein größere Matrizen mit Zufallswerten zu bilden. Dazu stellt Octave u.a. den rand-Befehl zur Verfügung.
m = rand(5, 6)
Ausgabe:
m =
0.86605 0.61108 0.71347 0.97119 0.52428 0.21993
0.74059 0.49062 0.56073 0.68592 0.74737 0.62680
0.20790 0.84874 0.36834 0.31102 0.25813 0.28933
0.84732 0.98777 0.91512 0.42240 0.87891 0.63757
0.76823 0.80367 0.24639 0.78208 0.77170 0.95281
Die Zufallszahlen liegen gleichverteilt zwischen 0 und 1 und werden nach dem Mersenne-Twister-Verfahren mit einer Periode von <math>2^{19937}-1</math> gebildet.
Andere Verfahren sind:
* randn: Normalverteilte Pseudozufallselemente mit Mittelwert=0 und Varianz=1
* rande: Exponentialverteilte Zufallselemente
* randg: Gammaverteilte Zufallselemente
* randp: Poissonverteilte Zufallselemente
Details dazu siehe in der Octave-Hilfefunktion.
== Aufgaben ==
* Berechnen Sie den Winkel zwischen den beiden Vektoren a = [1 2 0] und b = [2 1 1]. Hinweis: Siehe diesbezüglich auch im Oktave-Hilfesystem den Befehl "norm".
* Gegeben seien Vektoren a = [1 2 5], b = [0 0 -1] und c = [-1 -2 2]. Berechnen Sie das Spatprodukt aus diesen drei Vektoren.
* Multiplizieren Sie die beiden Matrizen A und B (mit Octave und zur Kontrolle händisch)
A = [0 0 1
1 2 1]
B = [1 1
1 2
0 4]
* Ist die Matrix C regulär? Wenn ja, dann bilden Sie die inverse Matrix.
C = [-1 0 0 -4
2 0 1 5
7 6 2 0
3 0 2 6]
* Ist die Matrix D regulär? Wenn ja, dann bilden Sie die inverse Matrix.
D = [2 1 0 0
0 0 2 1
0 0 0 2
1 1 0 0]
* Berechnen Sie die Konditionszahl der folgenden Matrix. Hinweis: Siehe diesbezüglich im Oktave-Hilfesystem den Befehl cond
[3 4 -5
6 0 3
1 1 2]
* Berechnen Sie die Eigenwerte und Eigenvektoren der folgenden Matrix
[6 -3 4 0
0 7 -1 1
0 10 -3 -2
0 1 -2 1]
= Komplexe Zahlen =
Die imaginäre Einheit wird in Octave durch den Buchstaben i, j, I oder J symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung <math>z = \Re(z) + i \cdot \Im(z)</math>
* Polardarstellungen <math>z = r \cdot (\cos(\phi) + i \cdot \sin(\phi)) = r \cdot e^{i\cdot \phi}</math>
Die konjugiert komplexe Zahl ist <math>z^* = \Re(z) - i \cdot \Im(z)</math>
== Mit komplexen Zahlen rechnen ==
z1 = 2 + 5i; % kartesische Darstellung
z2 = 3 * exp(3j); % Polardarstellung
% Addition
res = z1 + z2;
disp("z1 + z2 = "); disp(res);
% Multiplikation
res = z1 * z2;
disp("z1 * z2 = "); disp(res);
% Realteil
res = real(z2);
disp("Realteil von z2 = "); disp(res);
% Imaginärteil
res = imag(z2);
disp("Imaginaerteil von z2 = "); disp(res);
% Betrag
res = abs(z1);
disp("Betrag von z1 = "); disp(res);
% Argument
res = angle(z1);
disp("Argument von z1 = "); disp(res);
% Konjugiert komplexe Zahl
res = conj(z1);
disp("Konjugiert komplexe Zahl von z1 = "); disp(res);
Ausgabe:
z1 + z2 =
-0.96998 + 5.42336i
z1 * z2 =
-8.0568 - 14.0032i
Realteil von z2 =
-2.9700
Imaginaerteil von z2 =
0.42336
Betrag von z1 =
5.3852
Argument von z1 =
1.1903
Konjugiert komplexe Zahl von z1 =
2 - 5i
== Die gaußsche Zahlenebene ==
clear; close all; clc;
z1 = 3 + 5i;
z2 = 5 * exp(0.5i);
hold on;
plot(z1, "*");
compass(z1);
plot(z2, "o");
compass(z2);
grid on;
[[Datei:octave_komplex1.jpg]]
== Aufgaben ==
* Berechnen Sie die Quadratwurzel der komplexen Zahl <math>z = 3 + 2i</math>.
* Verwandeln Sie folgende Zahlen in die Polarkoordinatendarstellung: <math>-11 - 3i</math> und <math>(1+i)^{10}</math>
* Verwandeln Sie folgende Zahlen in die Normaldarstellung: <math>12 \cdot e^{i\cdot \pi / 4}</math> und <math>3 \cdot (\cos(\pi / 3) + i \cdot \sin(\pi / 3))</math>
* Zeichnen Sie die Zahl <math>3 + 5i</math> in der gaußschen Zahlenebene als Zeiger.
= Funktionen =
Um Programme zu strukturieren und einfacher zu gestalten können Programmteile in Funktionen ausgelagert werden. Eingebaute Funktionen haben wir schon kennengelernt (z.B. die Sinus-Funktion sin). Nun wollen wir sehen, wie man selbst solche Funktionen schreiben kann.
== Eine einfache Funktion schreiben ==
Datei addiere.m:
function res = addiere(a, b)
% Addiere zwei Zahlen a + b
res = a + b;
end
Datei test1.m:
addiere(10, 15)
Ausgabe:
ans = 25
* Jede Funktion sollte in einer eigenen m-Datei stehen.
* Der Dateiname sollte mit dem Funktionsnamen (natürlich ohne Dateiendung .m) übereinstimmen.
* Der Kommentar unter dem Funktionskopf wird als Hilfstext angezeigt, wenn die help-Funktion (hier "help addiere") aufgerufen wird.
== Inline-Funktionen ==
Kurze Funktionen können auch als Inline-Funktionen geschrieben werden.
addiere = inline("a + b");
x = 5;
y = 10;
z = addiere(x, y)
Oder in diesem Fall noch kürzer
addiere = inline("a + b");
z = addiere(5, 10)
Ausgabe:
z = 15
Bei neueren Octave-Versionen kann bei der Verwendung von Inline-Funktionen die Warnung
warning: inline is obsolete; use anonymous functions instead
erscheinen. Ein Blick in die Hilfe-Funktion
help inline
zeigt das selbe Ergebnis. Es sollen also anonyme Funktionen (siehe etwas weiter unten in diesem Text) anstelle von Inline-Funktionen verwendet werden.
== Funktionsstring ==
addiere = "a + b";
a = 5;
b = 10;
z = eval(addiere)
Ausgabe:
z = 15
== Anonyme Funktionen ==
{{Wikipedia | Anonyme Funktion}}
addiere = @(a, b) a + b;
x = 10;
y = 20;
z = addiere(x, y)
oder kürzer
addiere = @(a, b) a + b;
z = addiere(10, 20)
Ausgabe:
z = 30
oder noch kürzer
(@(a,b) a+b)(10, 20)
Ausgabe:
ans = 30
== Nullstellen von Funktionen bestimmen ==
sinh2 = @(x) sinh(x) + 2;
z = fzero(sinh2, 1)
Ausgabe:
z = -1.4436
Zur Kontrolle soll hier der Graph der Funktion dargestellt werden
clear;
close all;
clc;
sinh2 = @(x) sinh(x) + 2;
x = -2 : 0.1 : 0;
y = sinh2(x);
z = fzero(sinh2, 1)
plot(x, y);
hold on;
plot(z, 0, "o", "Color", "red", "LineWidth", 2);
text (-1.8, 0.8, "Nullstelle");
line([z -1.7], [0, .7], "Color", "black");
grid on;
Ausgabe:
[[Datei:octave_funktion5.jpg]]
Weiter unten im Text wird die ähnliche Funktion "fsolve" beschrieben. "fzero" benutzt zwei verschiedene Funktionen zur Problemlösung, darunter eben auch "fsolve".
Für die Nullstellenbestimmung von Polynomen gibt es die Funktion "roots". Näheres dazu folgt im nächsten Kapitel.
== Globale Variablen ==
Datei addiere.m:
function res = addiere()
global a b;
res = a + b;
end
Datei test1.m:
clear;
close all;
clc;
global a b;
a = 5;
b = 3;
addiere()
Ausgabe:
ans = 8
== Aufgaben ==
* Schreiben Sie eine Funktion "ellipse", welche eine Ellipse am Bildschirm darstellt. Zur Erinnerung: Die Parameterdarstellung der Ellipse lautet <math>x = a\cdot\cos(t), y = b\cdot\sin(t), 0 \leq t \leq 2\pi</math>, Funktionsargumente seien a und b.
* Schreiben Sie <math>y = 2\cdot\sin(x) + 3\cdot\cos(x/2)</math>
** als normale Funktion
** als Funktionsstring
** als Inlinefunktion
** als anonyme Funktion
** stellen Sie diese Funktion grafisch am Bildschirm dar.
= Polynome =
== Einzelne Polynomwerte berechnen ==
% y = 2*x^3 + 5*x^2 + 4 für x = 2 berechnen
p = [2, 5, 0, 4];
polyval(p, 2)
Ausgabe:
ans = 40
== Polynome zeichnen ==
% y = 2*x^3 - 5*x^2 + 4 für das Intervall -5 <= x <= 5 grafisch darstellen
x = -5 : .1 : 5;
p = [2, 5, 0, 4];
y = polyval(p, x);
plot(x,y);
grid on;
Ausgabe:
[[Datei:octave_polynom1.jpg]]
== Nullstellen bestimmen ==
Für Polynome existiert die Funktion "roots" zur Nullstellenbestimmung.
% Nullstellen für y = 2*x^3 - 5*x^2 + 4 bestimmen
p = [2, 5, 0, 4];
r = roots(p)
Ausgabe:
r =
-2.76214 + 0.00000i
0.13107 + 0.84077i
0.13107 - 0.84077i
Dieses Polynom hat nur eine reelle Nullstelle. Diese liegt, wie am obigen Grafen zu ersehen ist, in der Nähe von -2.762. Die beiden anderen Nullstellen sind konjugiert komplex zueinander (wie es auch sein sollte).
== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms <math>y = 2x^4 - 3x^3 - x + 7</math>.
* Berechnen Sie die Nullstellen von <math>y = 7x^5 - 3x^2 + 12</math>.
* Zeichnen Sie das Polynom <math>y = 12x^4 - 70x</math> im Intervall <math>-5 \leq x \leq 5</math>.
= Lineare Gleichungssysteme =
Sei <math>Ax = b</math> ein lineares Gleichungssystem. <math>A</math> sei die Koeffizientenmatrix, <math>x</math> der Lösungsvektor und <math>b</math> ein bekannter Vektor.
== Einfache Berechnung mittels Gauß-Verfahren ==
{{Wikipedia | Gaußsches Eliminationsverfahren}}
Beispiel:
A = [5 1
0 2];
b = [1
2];
x = A \ b
Ausgabe:
x =
0
1
== Das gmres-Verfahren ==
gmres steht für Generalized Minimal Residual.
{{Wikipedia | GMRES-Verfahren}}
A = [5 1
0 2];
b = [1
2];
x = gmres(A, b)
Ausgabe:
gmres converged at iteration 2 to a solution with relative residual 2.22045e-16
x =
-1.6653e-16
1.0000e+00
Das Ergebnis weicht etwas vom gaußschen Verfahren ab, ist aber trotzdem im Rahmen der Näherung korrekt.
Weiters kennt Octave noch andere iterative Verfahren, z.B. cgs (Conjugate Gradient Squared) oder bicgstab (Bi-Conjugate Gradient Stabilized). Näheres zu diesen Verfahren siehe in der weiterführenden Literatur (z.B. bei Meister: Numerik linearer Gleichungssysteme, Vieweg+Teubner, 2011)
{{Wikipedia | CGS-Verfahren}}
== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Octave (und zur Kontrolle auch händisch):
5x + 6y - 2z = 12
3x - y - 3z = 6
2x + 2y + 4z = 5
= Nichtlineare Gleichungssysteme =
== fsolve und fzero ==
Löse eine beliebige Gleichung f(x) = 0, z.B. <math> f(x) = x^2 - 5\cos(x) - 10 = 0 </math>:
f = @(x) x^2 - 5*cos(x) - 10;
xstart = 1;
[x, fval, info] = fsolve(f, xstart)
Ausgabe:
x = 2.4681
fval = -1.7764e-015
info = 1
* x ist eine Nullstelle in der Nähe vom Startwert xstart.
* fval ist die Abweichung, den f bei x aufweist.
* info ist ein "Fehlercode": 1 bedeutet, dass der relative Fehler in der spezifizierten Toleranz liegt (wie es sein soll). 3 würde bedeuten, dass der Algorithmus nicht konvergiert (z.B. weil keine Nullstelle existiert).
Zur Kontrolle plotten wir den Funktionsgraphen:
x = - 1 : .1 : 3;
y = x.^2 - 5.*cos(x) - 10;
plot(x,y, "LineWidth", 2);
grid on;
Ausgabe:
[[Datei:octave_nichtlin1.jpg]]
Und siehe da, die gesuchte Nullstelle liegt wie berechnet bei einem Wert nahe 2,5. Die Funktion <math>x^2 - 5\cos(x) - 10</math> hat noch eine zweite Nullstelle, wie in der folgenden Abbildung zu erkennen ist.
[[Datei:octave_nichtlin2.jpg]]
Diese zweite Nullstelle erhalten wir, wenn der Startwert in der Nähe dieser zweiten Nullstelle liegt, also z.B. bei -1. Ändern Sie einfach den entsprechenden Startwert im obigen Programmcode, und das Programm sollte die Nullstelle in der Nähe von -2.5 liefern.
Auch die Funktion ''fzero'' kann zur Lösung einer nichtlinearen Gleichung verwendet werden. Die Hilfe-Funktion von Octave empfiehlt dies sogar eindringlich für den Fall einer nichtlinearen Gleichung in einer Variablen. Für das gleiche Beispiel wie oben kann der Programmcode folgendermaßen aussehen:
Eingabe:
f = @(x) x^2 - 5*cos(x) - 10;
[x0, y0] = fzero (f, [0, 3])
Ausgabe:
x0 = 2.4681
y0 = -1.2434e-14
== Gleichungssysteme ==
Folgende Aufgabe ist dem Buch "Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72" entnommen. Zu lösen ist das nichtlineare Gleichungssystem
<math>f_1 = 2x_1 + 4x_2 = 0 </math>
<math>f_2 = 4x_1 + 8x_2^3 = 0</math>
Lösung:
f.m:
function y = f(x)
y(1) = 2*x(1) + 4*x(2);
y(2) = 4*x(1) + 8*x(2)^3;
end
test1.m:
clear;
close all;
clc;
[x, fval, info] = fsolve (@f, [0, 1])
[x, fval, info] = fsolve (@f, [0, -1])
[x, fval, info] = fsolve (@f, [0, 0])
Ausgabe:
x =
-2 1
fval =
0 7.4930e-09
info = 1
x =
2 -1
fval =
0 -7.4930e-09
info = 1
x =
0 0
fval =
0 0
info = 1
== Aufgaben ==
* Bestimmen Sie die Nullstellen von <math>f(x) = x^2 - 3</math>. Plotten Sie den Grafen.
* Bestimmen Sie die Nullstelle von <math>f(x) = sin(x) - x - 1</math>. Plotten Sie den Grafen.
* Lösen Sie das folgende Gleichungssystem (und stellen Sie das Ganze grafisch am Bildschirm dar): <math> f_1 = x_1 + x_2 = 0; f_2 = x_1 + \sin{x_2} = 0</math>
= Interpolation =
== Eindimensionale Interpolation ==
{{Wikipedia | Interpolation (Mathematik)}}
Bezüglich eindimensionaler Interpolation sei auf die [https://docs.octave.org/v11.1.0/One_002ddimensional-Interpolation.html Octave-Dokumentation und Hilfefunktion zum Befehl " interp1"] verwiesen. Dort findet sich auch ein Programmbeispiel, das als Grundlage des folgenden Plots dient:
[[Datei:octave_interpol1.jpg]]
== Mehrdimensionale Interpolation ==
Bezüglich mehrdimensionaler Interpolation siehe die [https://docs.octave.org/v11.1.0/Multi_002ddimensional-Interpolation.html Hilfefunktion zu "interp2", "interp3" und "interpn"].
== Aufgabe ==
* Gegeben seinen die fünf Stützpunkte p1 = [1, 0], p2 = [2, -5], p3 = [3, 2], p4 = [4, 7], p5 = [5, 6]. Legen Sie eine Funktion (die Interpolierende) durch diese Stützpunkte. Eine Lösungsmöglichkeit:
xp = [1 2 3 4 5];
yp = [0, -5, 2, 7, 6];
xf = 1 : .1 : 5;
spl = interp1(xp, yp, xf, "spline");
pch = interp1(xp, yp, xf, "pchip");
plot(xp, yp, "or", "LineWidth", 2, xf, spl, "LineWidth", 2, ...
xf, pch, "LineWidth", 2);
legend("stuetzpunkte", "spline", "pchip", "location", "southeast");
[[Datei:octave_interpol3.jpg]]
= Differenzialrechnung =
== Polynome differenzieren ==
Es soll das Polynom <math>y = 2x^3 - 5x^2 + 7</math> differenziert werden.
% Differenzieren des Polynoms y = 2*x^3 - 5*x^2 + 7
p = [2, -5, 0, 7];
polyder(p)
Ausgabe:
ans =
6 -10 0
D.h. also, die Ableitung von <math>y = 2x^3 - 5x^2 + 7</math> ist <math>y' = 6x^2 - 10x</math>.
== Sonstige Funktionen differenzieren ==
Als Beispiel differenzieren wir <math>y = 5x\sin{x}</math> und stellen das Ganze grafisch dar.
clear;
close all;
clc;
x = 0 : 0.01 : 10;
y = 5 .* x .* sin(x);
y_strich = diff(y) / 0.01;
plot(x, y, "Color", "red", "LineWidth", 2);
hold on;
plot(x(1:length(x)-1), y_strich, "Color", "blue", "LineWidth", 2);
legend("y", "y'");
grid on;
Ausgabe:
[[Datei:octave_diff1.jpg]]
diff(y) ist der Vektor aus den Differenzen y(2)-y(1), ..., y(n)-y(n-1). Für die genaue Arbeitsweise der diff-Funktion siehe "help diff".
== Aufgaben ==
* Differenzieren Sie das Polynom <math>y = 5y^5 - y^4 + 6y - 4</math>.
* Differenzieren Sie die Funktion <math>y = \log(x) + 10x</math> und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion <math>y = \frac{\sinh(x)}{(1+x)}</math> und stellen Sie y, sowie y' grafisch am Bildschirm dar.
= Integralrechnung =
== Polynome integrieren ==
Berechnen Sie das unbestimmte Integral von <math>y = 2x^3 - 7x^2 + 7</math>
p = [2, -7, 0, 7];
p_int = polyint(p)
Ausgabe:
p_int =
0.50000 -2.33333 0.00000 7.00000 0.00000
Das Ergebnis lautet also <math>\int{y dx} = 0.5x^4 - 2.33333x^3 + 7x + C</math> (auf die Integrationskonstante C darf nicht vergessen werden!).
== Gauß-Quadratur ==
{{Wikipedia | Gauß-Quadratur}}
Berechnen Sie das Integral <math>\int_{0}^{3}x^2 dx</math> mittels Gauß-Quadratur.
Datei f.m:
function y = f(x)
y = x^2;
end
Datei test1.m:
[v, ier, nfun, err] = quad ("f", 0, 3)
Ausgabe:
v = 9.0000
ier = 0
nfun = 21
err = 9.9920e-014
Erläuterung zur Ausgabe:
* v ... Resultat der Integration
* ier ... integer error code
* nfun ... Anzahl der Funktionsaufrufe
* err ... Fehler in der Lösung
== Quadratur mittels adaptiver Lobatto-Regel ==
Berechnen Sie diesmal das Integral <math>\int_{0}^{3}x^2 dx</math> mittels Lobatto-Quadratur.
f = inline("x.^2");
v = quadl (f, 0, 3)
Ausgabe:
v = 9
Wie weiter oben bereits angesprochen kann bei der Ausgabe eine Warnung erfolgen. Inline-Funktionen sind inzwischen als obsolet erklärt und es sollen stattdessen anonyme Funktionen verwendet werden.
Zwecks Übung sei nachfolgend nochmals dieses Beispiel berechnet. Diesmal wird aber eine anonyme Funktion verwendet.
v = quadl (@(x) x.^2, 0, 3)
== Aufgaben ==
* Integrieren Sie das Polynom <math>y = 5y^5 - y4 + 6y - 4</math>.
* Integrieren Sie die Funktion <math>y = \log(x) + 10x</math> von -5 bis 5.
* Integrieren Sie die Funktion <math>y = x^3</math> von 0 bis 4. Verwenden Sie hierzu die Simpsonregel (siehe dazu in der Hilfefunktion den Befehl "quadv").
= Gewöhnliche Differenzialgleichungen =
== ode23, ode45 und lsode ==
Für die Lösung von Differenzialgleichungen stehen die Funktionen
* ode23
bzw.
* ode45
zur Verfügung. Diese Funktionen implementieren das Runge-Kutta-Verfahren. "ode" steht für "Ordinary Differential Equation" (also auf Deutsch für "Gewöhnliche Differentialgleichung"). Die Zahlen bei ode23 oder ode45 stehen für die Ordnung.
{{Wikipedia | Runge-Kutta-Verfahren}}
Beispiel <math>y' = x^2 + y^3</math>:
clear;
close all;
clc;
[x, y] = ode45(@(x,y) (x^2+y^3), [0 1], 0);
plot(x, y, "LineWidth", 2);
Ausgabe:
[[Datei:octave_ode1.jpg]]
Bezüglich der genauen Funktionsweise von "ode45" (oder "ode23") siehe die Octave-Hilfe.
Auch die Funktion "lsode" steht zur Lösung von ODEs zur Verfügung.
Beispiel <math>y' = x + y</math>:
clear;
close all;
clc;
t = 0 : .1 : 5;
[y2, istate, msg] = lsode(@(x,y) (x + y), 1, t);
istate
msg
plot(t, y2);
Ausgabe:
istate = 2
msg = successful exit
[[Datei:octave_lsode1.jpg]]
Bezüglich der genauen Funktionsweise von "lsode" siehe die Octave-Hilfe.
== Aufgaben ==
* Lösen Sie die Differenzialgleichung <math>y' = \frac{1}{x\cdot y}</math> mit Octave. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung <math>m' = -k\cdot m</math>. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung <math>y' = \sqrt{|y|}</math>.
= Die Fast-Fourier-Transformation =
{{Wikipedia | Schnelle Fourier-Transformation}}
Für die Funktion "fft" siehe das Octave-Hilfesystem.
= Mengenrechnung =
== Vereinigungsmenge ==
v1 = [1 2 3 4];
v2 = [2 4 6];
union(v1, v2)
Ausgabe:
ans =
1 2 3 4 6
== Schnittmenge ==
v1 = [1 2 3 4];
v2 = [2 4 6];
intersect(v1, v2)
Ausgabe:
ans =
2 4
= Logik =
Logische Operatoren werden oft benötigt, z.B. bei Schleifen und Verzweigungen.
Octave kennt die logischen Operatoren <code>or, and, not</code> und <code>xor</code>. Als Beispiel sei die Wahrheitstabelle für den Operator <code>or</code> dargestellt.
A B A or B
--------------------
true true true
true false true
false true true
false false false
In Octave kann das so ausgedrückt werden:
or( true, true )
or( true, false )
or( false, true )
or( false, false )
Ausgabe:
ans = 1
ans = 1
ans = 1
ans = 0
Zahlen ungleich 0 stehen für true, 0 für false. Z.B.:
or( 22, 0)
Ausgabe:
ans = 1
Äquivalent zu <code>or</code> ist der Operator <code>|</code>:
22 | 0
Ausgabe:
ans = 1
Zwecks näheren Informationen zu den Operatoren <code>and (&, &&), not (~, !)</code> und <code>xor</code> bemühe man Octaves Help-Funktion.
Bitweise logische Funktionen kennt Octave auch, so kann man z.B. zwei Zahlen mit dem bitweisen OR-Operator verknüpfen:
0b1100101
0b0110001
---------
0b1110101
Oder in Dezimalzahlen:
101
49
---
117
In Octave:
bitor( 0b1100101, 0b0110001 )
dec2bin( ans )
Ausgabe:
ans = 117
ans = 1110101
Zu <code>bitand, bitxor</code> usw. siehe die Octave-Hilfe-Funktion.
= Stochastik =
==Deskriptive Statistik ==
=== Lageparameter ===
Arithmetischer Mittelwert:
vec = [1 2 3 4 5 12 13];
mw = mean(vec)
Ausgabe:
mw = 5.7143
Der Median oder Zentralwert läßt sich folgendermaßen berechnen:
vec = [1 2 3 4 5 12 13];
median(vec)
Ausgabe:
ans = 4
Der Modus oder häufigste Wert läßt sich mittels "mode"-Funktion eruieren:
vec = [1 2 1 3 5 1 2 7];
[m, f, c] = mode (vec);
disp(m);
disp(f);
disp(c);
Ausgabe:
1
3
{
[1,1] = 1
}
m (erste Zeile der Ausgabe) ist der Modus. f (zweite Zeile) ist die Häufigkeit. Näheres dazu siehe im Octave-Hilfesystem.
=== Streuungsparameter ===
Varianz:
vec = [1 2 3 1 1 6 7];
v = var(vec)
Ausgabe:
v = 6.3333
Standardabweichung:
vec = [1 2 3 1 1 6 7];
s = std(vec)
Ausgabe:
s = 2.5166
=== Grafiken erzeugen ===
Histogramme:
v = [1 1 2 3 1 6 7 6 1 1 1 2];
hist(v, max(v));
Ausgabe:
[[Datei:octave_histo2.jpg]]
Balkendiagramme:
v = [1 1 2 3 1 6 7 6];
bar(v);
Ausgabe:
[[Datei:octave_bar111.jpg]]
Treppendiagramm:
v = [1 1 2 3 1 6 7 6];
stairs(v);
Ausgabe:
[[Datei:octave_stairs1.jpg]]
Stabdiagramm:
v = [1 1 2 3 1 6 7 6];
stem(v);
Ausgabe:
[[Datei:octave_stem1.jpg]]
=== Aufgaben ===
Gegeben sei folgende Datentabelle mit den Werten:
v1 = [3 4 1 1 7 2 1 9 2 5 9 7 2 2 9 2 2 1 2 8]
v2 = [1 1 0 2 3 4 1 2 7 0 2 1 5 5 5 4 5 2 5 0]
* Berechnen Sie die Lageparameter und Streuungsparameter des Vektors v1.
* Berechnen Sie Kovarianz und Korrelationskoeffizient der beiden zugeordneten Vektoren v1 und v2.
* Zeichnen Sie das Histogramm des Vektors v1.
== Wahrscheinlichkeitsrechnung ==
=== Kombinatorik ===
Der Binomialkoeffizient:
<math>\binom{n}{k}=\frac{n!}{k!(n-k)!}</math>
In Octave z.B.:
n = 30;
k = 4;
n_ueber_k = nchoosek (n, k)
Ausgabe:
n_ueber_k = 27405
Permutationen sind die verschiedenen Anordnungsmöglichkeiten mit der Anzahl n! = n * (n-1) * ... * 2 * 1.
Beispiel:
v = [1, 2, 3];
p = perms(v)
Ausgabe:
p =
1 2 3
2 1 3
1 3 2
2 3 1
3 1 2
3 2 1
n! (n-Fakultät) selbst kann so berechnet werden:
% 10!
n = 10;
factorial (n)
Ausgabe:
ans = 3628800
=== Verteilungen ===
Octave kennt eine ganze Reihe von Dichte- und Verteilungsfunktionen und zwar
* Probability Density Functions (PDF, Dichtefunktionen)
* Cumulative Distribution Functions (CDF, Verteilungsfunktionen)
Z.B.:
* Binomialverteilung:
** binopdf
** binocdf
* Hypergeometrische Verteilung:
** hygepdf
** hygecdf
* Normalverteilung:
** normpdf
** normcdf
* Studentverteilung:
** tpdf
** tcdf
* Weibullverteilung:
** wblpdf
** wblcdf
Ein Codebeispiel zur Binomialverteilung:
clear;
close all;
clc;
x = 0 : 1 : 10;
n = 10;
p = 0.1;
b1 = binopdf (x, n, p);
b2 = binocdf (x, n, p);
subplot(221);
bar(x, b1);
title("binopdf");
text(1, 0.1, "n=10; p=0.1");
subplot(222);
bar(x, b2);
title("binocdf");
text(1, 0.5, "n=10; p=0.1");
n = 10;
p = 0.5;
b1 = binopdf (x, n, p);
b2 = binocdf (x, n, p);
subplot(223);
bar(x, b1);
text(1, 0.1, "n=10; p=0.5");
subplot(224);
bar(x, b2);
text(1, 0.1, "n=10; p=0.5");
Ausgabe:
[[Datei:octave_bino3.jpg]]
Möglicherweise erhalten Sie bei diesem Beispiel eine Fehlermeldung in der Form
error: 'binopdf' undefined near line 8, column 6
The 'binopdf' function belongs to the statistics package from Octave
Forge which you have installed but not loaded. To load the package, run
'pkg load statistics' from the Octave prompt.
Laden Sie einfach das Paket für die Statistikfunktionen, wie in der Fehlermeldung beschrieben.
Ein Codebeispiel zur Normalverteilung:
clear;
close all;
clc;
x = -4 : .1 : 4;
b1 = normpdf(x);
b2 = normcdf(x);
subplot(121);
plot(x, b1);
title("normpdf");
grid on;
subplot(122);
plot(x, b2);
title("normcdf");
grid on;
Ausgabe:
[[Datei:octave_norm111.jpg]]
== Zufallszahlengeneratoren ==
Octave kann Zufallszahlen aus einer großen Anzahl von Verteilungen generieren, z.B.
* Chi-Quadrat-Verteilung: chi2rnd
* Log-Normal-Verteilung: lognrnd
* Normalverteilung: normrnd
Codebeispiel:
mean = 0;
standardabweichung = 1;
zufallszahl = normrnd (mean, standardabweichung)
Ausgabe (gibt eine Zufallszahl rund um den Mittelwert 0 aus), z.B.
zufallszahl = 1.0451
Auch Zufallsvektoren (oder Zufallsmatrizen) können erstellt werden:
mean = [0 0 0 0 0];
standardabweichung = 1;
zufallsvektor = normrnd (mean, standardabweichung)
Ausgabe, z.B.:
zufallsvektor =
1.47108 -0.51280 0.52726 0.31730 -1.04422
= Das symbolic-Paket =
Octave ist kein CAS ('''C'''omputer '''A'''lgebra '''S'''ystem). Stattdessen kann man eine Schnittstelle zu SymPy (Python) etablieren, und zwar über das symbolic-Paket. Es muss vorab installiert werden, z.B. bei openSUSE mittels YaST (octave-forge-symbolic).
== Rechnen mit wirklich großen Zahlen ==
Das symbolic-Paket bietet u.a. die Möglichkeit mit großen Zahlen exakt zu hantieren.
<code>vpa</code> steht nachfolgend für '''v'''ariable-'''p'''recision '''a'''rithmetic.
pkg load symbolic;
digits(50);
vpa(0.1)
vpa("0.1")
Ausgabe:
Symbolic pkg v3.2.2: Python communication link active, SymPy v1.14.0.
ans = (sym) 0.10000000000000000555111512312578270211815834045410
ans = (sym) 0.10000000000000000000000000000000000000000000000000
Hier sieht man, dass es nötig ist, die Zahlen als String an <code>vpa</code> zu übergeben, ansonsten handelt man sich Rundungsfehler ein.
Nun noch ein Beispiel für große Gleitpunktzahlen:
pkg load symbolic;
digits(50);
x = vpa("1.12345e500");
y = vpa("20000.0");
x*y
Ausgabe:
Symbolic pkg v3.2.2: Python communication link active, SymPy v1.14.0.
ans = (sym) 2.2469000000000000000000000000000000000000000000000e+504
Um die Meldung "Symbolic pkg v3.2.2: Python communication link active, SymPy v1.14.0" zu unterdrücken, gibt es den Schalter/Befehl <code>sympref quiet on</code>:
pkg load symbolic;
sympref quiet on;
x = vpa("1.12345e500", 50);
y = vpa("20000.0", 50);
x*y
Ausgabe:
ans = (sym) 2.2469000000000000000000000000000000000000000000000e+504
Mit dem symbolic-Paket können auch noch andere Probleme gelöst werden (z.B. symbolische Integration oder Differentiation). Dies wird aber hier nicht demonstriert, sondern als Aufgabe gestellt.
== Aufgaben ==
* Recherchieren Sie im Internet zur <code>diff()</code>-Funktion von symbolic. Differenzieren Sie mit Octave folgende Funktionen symbolisch:
** <math>f(x) = \sin(x)\cdot x</math> (und zwar ist die 1. Ableitung gesucht)
** <math>g(x) = x^3</math> (die 2. Ableitung ist gesucht)
* Recherchieren Sie im Internet zur <code>int()</code>-Funktion von symbolic. Integrieren sie mit Octave symbolisch:
** <math>\int{x^3 \ d\text{x}}</math>
** <math>\int_0^2{x^3 \ d\text{x}}</math>
* Gegeben sei das lineare Gleichungssystem <math>2x+3y=7</math>; <math>\ -1x-3y=5</math>.
** Recherchieren Sie dazu im Internet zu <code>syms</code> und <code>solve()</code> aus dem symbolic-Paket
** Lösen Sie das gegebene Gleichungssystem symbolisch.
* Bestimmen Sie die Schnittpunkte eines Kreises mit einer Geraden mittels Octave und dem symbolic-Paket (nichtlineares Gleichungssystem). Das funktioniert auch mittels <code>solve()</code>. Gegeben sind die Gerade <math>y = x + 2</math> und der Kreis <math>x^2 + y^2 = 9</math>.
<small> Eine mögliche Lösung wird nachfolgend gezeigt (weil das etwas diffiziler ist und die im Internet angebotenen Lösungen teils in die Irre führen - Warnungen und Fehlermeldungen beim Ausführen der Scripte):
pkg load symbolic;
syms x y;
gerade = -y + x + 2;
kreis = x^2 + y^2 - 9;
lsg = solve([gerade, kreis], [x, y]);
disp(lsg{1}.x);
disp(lsg{1}.y);
disp("---------------");
disp(lsg{2}.x);
disp(lsg{2}.y);
Ausgabe:
Symbolic pkg v3.2.2: Python communication link active, SymPy v1.14.0.
√14
-1 + ───
2
√14
1 + ───
2
---------------
√14
- ─── - 1
2
√14
1 - ───
2
Dass das Ergebnis stimmt, kann man grafisch nachvollziehen:
% Kreis
t = 0 : .1: 2*pi+.1;
x = 3 * cos(t);
y = 3 * sin(t);
plot(x,y);
grid on;
axis equal;
% Gerade
hold on;
x = -4 : .1 : 4;
y = x+2;
plot(x,y);
% Schnittpunkte
plot(-1+sqrt(14)/2., 1+sqrt(14)/2., 'r.', 'MarkerSize', 20);
plot(-1-sqrt(14)/2., 1-sqrt(14)/2., 'r.', 'MarkerSize', 20);
% refresh();
% input("");
Ausgabe:
</small>
[[Bild:octave_nlin_gs1.svg|350px]]
* Führen Sie symbolische Laplace-Transformationen durch:
** Recherchieren Sie dazu im Internet zum Thema "Wie führt man eine Laplace-Transformation mit dem Octave-Paket symbolic aus?". Dies führt auf die Funktion <code>laplace()</code>.
** Gegeben ist die Sprungfunktion (1). Gesucht ist die Laplace-Transformierte.
** Gegeben ist die Sinusfunktion (<math>\sin{\omega t}</math>). Gesucht ist die Laplace-Transformierte.
= Regelungstechnische Aufgabenstellungen =
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket <code>control</code>. Dieses muss vorab installiert werden (z.B. bei openSUSE mittels YaST). Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms gezeigt werden. Gegeben sei <math>G(s)= \frac{1}{30s^3+20s^2+10s+1,5}</math>.
Octave-Code:
pkg load control;
zaehler = [1];
nenner = [30., 20., 10., 1.5];
G = tf(zaehler, nenner);
bode(G);
grid on;
% refresh();
% input("");
Ausgabe:
[[Bild:octave_rt1.jpg|400px]]
<code>tf()</code> steht für '''t'''ransfer '''f'''unction (engl. für Übertragungsfunktion). Die Dokumentation für das <code>control</code>-Paket findet sich [https://gnu-octave.github.io/pkg-control/doc_control.html hier].
= Einfache Benutzeroberflächen erstellen=
== Input ==
fflush (stdout);
x = input("Gib eine Zahl ein: ");
disp(2 * x);
Ein-/Ausgabe:
Gib eine Zahl ein: 12
24
Der "fflush"-Befehl sollte immer vor dem Aufruf des input-Befehls aufgerufen werden. Näheres zu "fflush" siehe im Octave-Hilfesystem.
== Diverse einfache vorgefertigte Dialoge ==
Fehlermeldung:
errordlg("Fehlermeldung");
[[Bild:octave_fehlermeldung1.jpg]]
Warnung:
warndlg("Warnung");
[[Bild:octave_warnung1.jpg]]
Hilfedialog:
helpdlg
[[Bild:octave_hilfe1.jpg]]
Abfragedialog:
button = questdlg ("Frage")
[[Bild:octave_abfrage1.jpg]]
Eingabedialog:
in = inputdlg("Eingabe")
[[Bild:octave_eingabe1.jpg]]
Messagebox:
h = msgbox ("Eine Mitteilung!");
[[Bild:octave_messagebox1.jpg]]
== Komplexere vorgefertigte Dialogboxen ==
=== Menübox ===
auswahl = menu("Auswahl", "Affe", "Elefant", "Loewe", "Sonstiges");
switch(auswahl)
case 1
disp "Affe quietscht"
case 2
disp "Elefant trompetet"
case 3
disp "Loewe bruellt"
otherwise
disp "Sonstiges"
end
Ausgabe:
[[Bild:octave_menu1.jpg]]
Es werde beispielsweise die Nummer 2 gewählt.
Ausgabe:
Elefant trompetet
=== Dialogliste ===
clear;
close all;
clc;
opt = {"Eins", "Zwei", "Drei"};
[sel, ok] = listdlg ("ListString", opt, "SelectionMode", "Multiple");
if (ok == 1)
for i = 1 : numel(sel)
disp(opt{sel(i)});
end
else
disp("Cancel");
end
[[Bild:octave_dialog1.jpg]]
Es werden beispielsweise alle Optionen ausgewählt.
Ausgabe:
Eins
Zwei
Drei
=== Fortschrittsbalken ===
h = waitbar ([0.5])
[[Bild:octave_fortschritt1.jpg]]
=== Datei- und Verzeichnisdialoge ===
Dateidialog:
[fname, fpath, fltidx] = uigetfile ()
[[Bild:octave_dateidialog2.jpg]]
Ähnlich sind die Befehle "uiputfile" und "uigetdir". Dazu sei auf die Octave-Hilfe verwiesen.
== Eigene Dialoge kreieren ==
Dieses Thema sei hier nur kurz angerissen.
Programmcode:
d = dialog("Position", [300, 300, 250, 150], "Name", "Dialog");
txt = uicontrol("Parent", d, ...
"Style", "text", ...
"Position", [20, 80, 210, 40], ...
"String", "Hallo Welt");
btn_servus = uicontrol("Parent", d, ...
"Position", [30, 20, 80, 30], ...
"String", "Servus", ...
"Callback", "disp('Servus angeklickt!');");
btn_hallo = uicontrol("Parent", d, ...
"Position", [140, 20, 80, 30], ...
"String", "Hallo", ...
"Callback", "disp('Hallo angeklickt!');");
uiwait(d);
Ausgegebenes Dialogfenster:
[[Bild:octave_dialog100.jpg]]
Ausgabe auf der Konsole (je nach gedrücktem Button), z.B.:
Servus angeklickt!
Die Position wird als [links, unten, breite, höhe] angegeben. Der Koordinatennullpunkt liegt, bezogen auf das Elternfenster, links unten. Es sind auch negative Koordinatenwerte möglich. Sinnvoll ist das z.B. bei einem dynamischen Ausblenden ohne zu löschen, oder für Animationen.
[[Bild:Cartesian-coordinate-system.svg | 150px]]
Wer mehr dazu wissen will, sei auf die Octave-Dokumentation verwiesen. Insbesondere siehe
* dialog
* uicontrol
* uipanel
* uibuttongroup
* uitable
* uimenu
* uitoolbar
== Aufgaben ==
=== Aufgabe 1 ===
Erzeugen Sie ein Dialogfenster mit einem Texteingabefeld und einem Button. Beim Klicken auf den Button soll der Eingabetext auf der Konsole ausgegeben werden. Das Dialogfenster soll also in etwa so aussehen:
[[Bild:octave_dialog105.jpg]]
Da dies etwas komplizierter als das oben gezeigte Beispiel ist, werden nachfolgend ein paar Codefragmente zwecks Lösung angegeben:
Datei button_callback.m:
function button_callback(editHandle)
eingegText = get(editHandle, "String");
disp(eingegText);
end
Codefragement in test1.m:
% ...
edit = uicontrol(% ...
"Style", "edit", ...
%, ...
"HorizontalAlignment", "left");
btn = uicontrol(% ...
"Callback", @(src, event) button_callback(edit));
% ...
Aufruf mit:
octave test1.m
Eingabe von z.B. "Hallo Welt!":
[[Bild:octave_dialog106.jpg]]
Ausgabe auf der Konsole nach dem Drücken des Buttons:
Hallo Welt!
=== Aufgabe 2 ===
Erzeugen Sie ein Dialogfenster mit zwei Eingabefeldern und einem Button. Eingegeben in diese zwei Eingabefelder werden vom Benutzer Zahlen. Auf der Konsole ausgegeben werden soll, nach Drücken des Buttons, das Produkt dieser zwei Zahlen.
Auch hier werden wieder Codefragemente angegeben.
Datei button_callback.m:
function button_callback(edit1, edit2)
zahl1 = str2double(get(edit1, 'String'));
zahl2 = str2double(get(edit2, 'String'));
disp(zahl1 * zahl2);
end
Codefragment Datei test1.m:
% ...
btn = uicontrol("Parent", d, ...
% ...
"Callback", @(src, event) button_callback(edit1, edit2));
% ...
Was passiert, wenn der Benutzer keine Zahlen, sondern beliebige Strings eingibt?
= Fehlerhandling mit try/catch =
Die try/catch-Anweisung entspricht weitgehend jener, die aus höheren Programmiersprachen wie C++ oder Java bekannt sind. Aufgebaut ist diese Anweisungsfolge so:
try
BODY
catch
CLEANUP
end
Beispiel:
clear;
close all;
clc;
try
a = 10 / "zahl";
disp(a);
disp("Weiter im try-Block");
catch
disp("Catch: Kann nicht durch einen String dividieren");
end
Ausgabe:
Catch: Kann nicht durch einen String dividieren
Sinnvoll ist die try/catch-Folge, wenn z.B. auch in einem Fehlerfall Dateien wieder geschlossen werden sollen.
= Ein- und Ausgabe =
== Formatierte Ausgabe am Bildschirm, formatiertes Lesen von der Tastatur ==
Folgendes Beispiel ist der Octave-Hilfe (von Octave 3.0.3) entnommen:
pct = 37;
filename = "foo.txt";
printf ("Processed %d%% of `%s'.\nPlease be patient.\n", pct, filename);
Ausgabe:
Processed 37% of `foo.txt'.
Please be patient.
"printf" gibt einen formatierten String am Bildschirm (genauer in den Stream stdout) aus. Wie man sieht, orientiert sich das Format an der Programmiersprache C.
Für das formatierte Lesen vom Stream stdin (normalerweise also von der Tastatur) steht das Pendant "scanf" bereit.
== Von einem String lesen bzw. in einen String schreiben ==
Bezüglich der Funktionen
* sprintf
und
* sscanf
sei auf die Octave-Hilfefunktion verwiesen.
== Lesen und Schreiben von einer Datei ==
=== Datei schreiben ===
% Datei c:\tmp\datei.test zum Schreiben öffnen
datei = fopen ("c:/tmp/datei.test", "w");
% Etwas in die Datei schreiben
fprintf(datei, "Hallo, Welt!");
% Datei schließen
fclose(datei);
=== Datei lesen ===
% Datei c:\tmp\datei.test zum Lesen öffnen
datei = fopen ("c:/tmp/datei.test", "r");
% Etwas aus der Datei lesen
[string] = fscanf(datei, "%s");
disp(string);
% Datei schließen
fclose(datei);
Ausgabe:
Hallo,Welt!
=== Dateiende prüfen ===
Mittels des Befehls
feof(FID);
kann das Dateiende geprüft werden. Wenn die EOF-Bedingung zutrifft, dann wird 1 zurückgegeben, wenn nicht dann 0. Ein Beispiel folgt später als Lösung einer Aufgabe.
=== warning und error ===
Eine Warnung kann man am stderr-Stream ausgeben. Die warning-Funktion entspricht ansonsten der printf-Funktion. Nach Ausgabe der Warnung wird das Programm normal fortgesetzt.
m = [1 2
3 6];
if(det(m) == 0)
warning("Matrix ist singulaer");
end
disp("Weiter geht's");
Ausgabe:
warning: Matrix ist singulaer
warning: called from
test1 at line 5 column 3
Weiter geht's
Schärfer ist der error-Befehl. Die Fehlermeldung wird am stderr-Stream ausgegeben. Vom Format her entspricht diese Funktion dem printf-Befehl. Nach Ausgabe der Fehlermeldung wird das Programm beendet.
m = [1 2
3 6];
if(det(m) == 0)
error("Matrix ist singulaer");
end
disp("Weiter geht's");
Ausgabe:
error: Matrix ist singulaer
error: called from
test1 at line 5 column 3
== Aufgaben ==
* Schreiben Sie ein Programm, das die Zahlen 1 bis 10 zeilenweise in eine Datei ausgibt.
* Lesen Sie diese Zeilen wieder von der Datei ein und geben Sie sie am Bildschirm aus.
* Gegeben sei eine Datei. Lesen Sie die Daten aus dieser Datei ein und rechnen Sie per Octave-Programm den Gesamtpreis für alle Tiere aus. Die Anzahl der Zeilen und der genaue Dateinhalt sei Ihnen vorab nicht bekannt. Bekannt ist nur das Datenformat wie folgt:
Nr. Name Einzelpreis Stueck
1 Affe 15000.50 2
2 Loewe 11000.90 1
3 Nashorn 45000.10 1
4 Elefant 51245.90 3
5 Tiger 9000.70 2
6 Maus 34.90 12
Eine einfache Lösung ohne Schnickschnack (Fehlerüberprüfungen etc.) für dieses Beispiel könnte wie folgt aussehen:
clear;
close all;
clc;
datei = fopen ("c:/tmp/daten1.txt", "r");
gesamtpreis = 0;
% Kopfzeile einlesen
[nr, name, preis, stk] = fscanf(datei, "%s %s %s %s", "C");
while(feof(datei) == 0)
% Datensätze einlesen
[nr, name, preis, stk] = fscanf(datei, "%d %s %f %d", "C");
gesamtpreis += preis*stk;
end
fclose(datei);
disp("Gesamtpreis = ");
format long;
disp(gesamtpreis);
Ausgabe:
Gesamtpreis =
258159.900000000
= Datencontainer =
== Datenstrukturen ==
Pseudocode:
STRUKTUR s
ZAHL a
VEKTOR b
STRING c
END
Octave-Code:
s.a = 45.9;
s.b = [1 2 3 4 5];
s.c = "Hallo!";
s
Ausgabe:
s =
scalar structure containing the fields:
a = 45.90000000000000
b =
1 2 3 4 5
c = Hallo!
Um ein paar weitere Möglichkeiten zum Handling mit Datenstrukturen aufzuzeigen, sei folgender Code aufgeführt.
Datei addsub.m
function res = addsub(a, b)
res.x = a + b;
res.y = a - b;
end
Datei test1.m
clear;
clc;
addsub(10, 50)
r = addsub(30, 70)
r.x
r.y
++r.x
Ausgabe:
ans =
scalar structure containing the fields:
x = 60
y = -40
r =
scalar structure containing the fields:
x = 100
y = -40
ans = 100
ans = -40
ans = 101
Die Funktion "addsub" liefert die Struktur res mit zwei Zahlenwerten. Die Elemente der Datenstruktur können auch außerhalb der Funktion angesprochen werden. Auch gerechnet werden kann mit diesen Elementen.
== Cell Arrays ==
Manchmal kann es sinnvoll sein mehrere Variablen verschiedenen Typs und Größe in einer Variablen zu speichern. Dies funktioniert ähnlich wie bei Vektoren. Es werden aber geschweifte Klammern verwendet.
Eingabe:
c = {"Hallo Welt!", [2 2], 44}
c{1}
c{1:2}
Ausgabe:
c =
{
[1,1] = Hallo Welt!
[1,2] =
2 2
[1,3] = 44
}
ans = Hallo Welt!
ans = Hallo Welt!
ans =
2 2
Elemente des Cell Arrays können auch wieder mit Variablen anderen Typs überschrieben werden.
c = {"Hallo Welt!", [2 2], 44};
c{1} = 5;
c
Ausgabe:
c =
{
[1,1] = 5
[1,2] =
2 2
[1,3] = 44
}
= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}
* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse "erbt" Attribute und Methoden von der Superklasse. Octave unterstützt (so wie C++ und Python, aber im Gegensatz zu Java) Mehrfachvererbung.
== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.
[[File:UmlCd Klasse-3.svg|300px]]
* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private (privat)
** # ... protected (geschützt)
* Vererbung:
<gallery>
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
</gallery>
Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0
== Klassen und Vererbung ==
Octave unterstützt auch objektorientierte Programmierung mit dem Schlüsselwort <code>classdef</code> (ab Version 4.0). Dieses Thema ist zwar etwas fortgeschritten, wird aber trotzdem kurz behandelt.
[[Bild:octave_oop1.svg|200px]]
Datei Auto.m:
classdef Auto
properties
marke1 = "Beemweh"
endproperties
methods
function zeige1(obj)
disp(["Marke: ", obj.marke1]);
endfunction
endmethods
endclassdef
Datei Cabrio.m:
classdef Cabrio < Auto
properties
marke2 = "Cabrio"
endproperties
methods
function zeige2(obj)
disp(["Marke: ", obj.marke2]);
endfunction
endmethods
endclassdef
Datei test1.m:
obj = Cabrio();
obj.zeige1();
obj.zeige2();
Ausgabe (Aufruf mittels "octave test1.m"):
Marke: Beemweh
Marke: Cabrio
GNU Octave kann auch Mehrfachvererbung:
[[Bild:octave_oop2.svg|200px]]
classdef Unterklasse < Oberklasse1 & Oberklasse2
Für die Reihenfolge der Vererbung gilt: Die zuerst genannte Klasse hat Vorrang.
Man kann mittels <code>private, protected, public</code> Daten auch kapseln:
properties(SetAccess = private, GetAccess = public)
methods (Access = public)
Standardmäßig sind alle Methoden und Attribute <code>public</code>.
Weiterführendes siehe z.B. in der [https://docs.octave.org/latest/Object-Oriented-Programming.html Octave-Dokumentation].
= Octave im Zusammenspiel mit anderen Programmiersprachen =
Man kann GNU Octave zur Kommunikation mit anderen Programmiersprachen bewegen, und das in beide Richtungen:
* GNU Octave -> andere Programmiersprache
* andere Programmiersprache -> GNU Octave
Hier die ganzen Möglichkeiten detailliert zu beschreiben würde zu weit führen. Wir beschränken uns im Wesentlichen auf die Erstellung von .oct-Files (C/C++; Fortran würde auch gehen, ist aber komplizierter) und zählen im Anschluss daran ein paar weitere Varianten auf.
== .oct-Dateien ==
Eine .oct-Datei in GNU Octave ist eine kompilierte C/C++-Datei, die als dynamisch ladbares Objekt direkt in Octave ausgeführt werden kann. oct-Dateien sind meist schneller als nativer Octave-Code.
1. Schritt: Erstelle z.B. eine C++-Datei ''quadrat.cc'' (es soll das Quadrat einer Zahl berechnet werden)
#include <octave/oct.h>
DEFUN_DLD(quadrat, args, nargout, "Quadrat einer Zahl berechnen")
{
double x = args(0).double_value();
double res = x*x;
return octave_value(res);
}
* <code>DEFUN_DLD</code> ist ein Makro. Damit wird angezeigt, dass es sich um eine dynamisch ladbare Funktion handelt ('''De'''fine '''Fun'''ction – '''D'''ynamically '''L'''inked '''D'''istribution).
* Der erste Parameter muss mit dem Namen der Funktion und der erstellten oct-Datei übereinstimmen, also hier <code>quadrat</code>.
* <code>args</code>: Argumente die beim Aufruf in Octave übergeben werden.
* <code>nargout</code>: Anzahl der Rückgabewerte.
* "Quadrat einer Zahl berechnen": Dokumentationsstring
2. Schritt: ''quadrat.cc'' kompilieren
# Terminal öffnen
# In das quadrat.cc-Verzeichnis wechseln
# Octave aufrufen
# cc-Datei zu einer oct-Datei kompilieren: <code>mkoctfile quadrat.cc</code>
# Wenn das ohne Fehlermeldung durchläuft, so sollte im Anschluss eine (relativ große) ''quadrat.oct''-Datei im entsprechenden Verzeichnis zu finden sein.
3. Schritt: Funktion <code>quadrat()</code> in Octave aufrufen, z.B.:
y = quadrat(5)
Es ergibt sich folgende Ausgabe:
y = 25
Damit das funktioniert, müssen natürlich die entsprechenden Werkzeuge (Compiler etc.) installiert sein. Darauf wird hier aber nicht näher eingegangen.
Die Dokumentation zu den .oct-Dateien findet sich auf [https://docs.octave.org/v11.1.0/Oct_002dFiles.html].
== Andere Möglichkeiten ==
* .mex-Dateien ('''M'''ATLAB '''Ex'''ecutables): Wenn man kompatibel zu MATLAB bleiben muss
* Java- oder Python-Schnittstelle (Nachteil: langsamer als .oct-Dateien)
Bevor man aber diese Möglichkeiten in Anspruch nimmt, sollte man vektorisieren. Damit lassen sich oft schon höhere Geschwindigkeiten erzielen. Dieses Thema wurde früher schon kurz behandelt ([[Ing_Mathematik:_Numerische_Mathematiksysteme_am_Beispiel_von_Octave#Die_FOR-Schleife|FOR-Schleife]]).
= Octave und die Tabellenkalkulation =
== Lesen ==
GNU Octave kann auch CSV-, LibreOffice Calc- oder MS Excel-Dateien einlesen.
Gegeben sei folgende schematisierte Datei im LibreOffice Calc-Format (test1.ods):
Februar März
Freitag 23 26
Samstag 17 41
Sonntag 34 37
=== Direkt als ODS-Datei einlesen ===
Die odsread-Funktion muss via io-Package geladen werden. Dieses Package ist nicht standardmäßig installiert, sondern kann z.B. bei openSUSE Tumbleweed mittels YaST als octave-forge-io installiert werden. Danach wird das Package geladen (pkg load io) und die Daten mittels odsread eingelesen.
pkg load io
[num, txt, raw] = odsread('test1.ods');
disp(num)
disp("------------")
disp(txt);
disp("------------")
disp(raw);
Ausgabe:
23 26
17 41
34 37
------------
{
[1,1] =
[2,1] = Freitag
[3,1] = Samstag
[4,1] = Sonntag
[1,2] = Februar
[2,2] =
[3,2] =
[4,2] =
[1,3] = März
[2,3] =
[3,3] =
[4,3] =
}
------------
{
[1,1] = [](0x0)
[2,1] = Freitag
[3,1] = Samstag
[4,1] = Sonntag
[1,2] = Februar
[2,2] = 23
[3,2] = 17
[4,2] = 34
[1,3] = März
[2,3] = 26
[3,3] = 41
[4,3] = 37
}
=== Als CSV-Datei einlesen ===
Die Datei test1.ods wird per LibreOffice Calc als CSV-Datei test1.csv (Trennzeichen ist der Strichpunkt) gespeichert (Achtung: gespeichert, nicht exportiert!):
;Februar;März
Freitag;23;26
Samstag;17;41
Sonntag;34;37
==== Mit csv2cell ====
Wir wollen hier den Strichpunkt als Trennzeichen verwenden. Per Default wird nämlich der Beistrich als Trennzeichen interpretiert.
pkg load io;
data = csv2cell("test1.csv", ";");
disp(data);
disp("---------------");
disp(data{2, 2});
Ausgabe:
{
[1,1] =
[2,1] = Freitag
[3,1] = Samstag
[4,1] = Sonntag
[1,2] = Februar
[2,2] = 23
[3,2] = 17
[4,2] = 34
[1,3] = März
[2,3] = 26
[3,3] = 41
[4,3] = 37
}
---------------
23
==== Mit dlmread ====
data = dlmread("test1.csv", ";");
disp(data);
disp("---------------");
disp(data(2, 2));
Ausgabe:
0 0 0
0 23 26
0 17 41
0 34 37
---------------
23
==== Mit importdata ====
data = importdata("test1.csv");
disp(data)
disp("------------")
disp(data.data);
disp("------------")
disp(data.data(2,2));
Ausgabe:
data =
23 26
17 41
34 37
textdata =
{
[1,1] = ;Februar;März
[2,1] = Freitag
[3,1] = Samstag
[4,1] = Sonntag
}
rowheaders =
{
[1,1] = Freitag
[2,1] = Samstag
[3,1] = Sonntag
}
------------
23 26
17 41
34 37
------------
41
Damit haben wir schon etliche Funktionen zu diesem Zweck kennengelernt. Weitere Funktionen zu
diesem Zweck sind z.B.
* csvread
* textscan
=== Als XLSX-Datei einlesen ===
Wir speichern unsere test1.ods-Datei als test1.xlsx-Datei. Dies ist das MS Excel-Standardformat. Und schon können wir den xlsread-Befehl zum Einlesen der Daten verwenden.
pkg load io
[num, txt, raw] = xlsread('test1.xlsx');
disp(num)
disp("------------")
disp(txt);
disp("------------")
disp(raw);
Die Ausgabe ist gleich wie oben bei der odsread-Funktion.
== Schreiben ==
=== Direkt als ODS-Datei schreiben ===
pkg load io
data = {
"", "Februar", "März";
"Freitag", 23, 26;
"Samstag", 17, 41;
"Sonntag", 34, 37
};
odswrite('test1.ods', data);
=== Als XLSX-Datei schreiben ===
pkg load io
data = {
"", "Februar", "März";
"Freitag", 23, 26;
"Samstag", 17, 41;
"Sonntag", 34, 37
};
xlswrite('test1.xlsx', data);
=== Als CSV-Datei schreiben ===
* dlmwrite
* csvwrite
* fprintf
= Octave GUI =
Das GUI-Programm ('''G'''raphical '''U'''ser '''I'''nterface) von Octave entspricht im Wesentlichen anderen Programmier-Benutzeroberflächen (IDEs ... '''I'''ntegrated '''D'''evelopment '''E'''nvironments), wie z.B. Eclipse (Java), Code::Blocks (C/C++) oder Spyder (Python). Nachfolgend ist ein Screenshot des Octave-GUI mit einigen Anmerkungen dargestellt.
[[Bild:octave_gui2.jpg|600px]]
Probieren Sie einfach die Möglichkeiten der zur Verfügung gestellten GUI/IDE aus.
= Komplexere Aufgaben =
* Berechnen Sie die Fläche, den Umfang, die Seitenlängen, den Inkreis und den Umkreis eines Dreiecks. Stellen Sie das Dreieck inklusive In- und Umkreis grafisch dar. Speichern Sie die Daten in einer Datei. Die drei Eckpunkte dieses Dreiecks sollen vom Benutzer beliebig vorgegeben werden.
* Die Werte einer beliebig großen quadratischen Matrix seien in einer Datei gespeichert. Lesen Sie diese Datei ein und berechnen Sie daraus die Determinante der Matrix, die inverse Matrix, die Eigenvektoren und -werte, die Spur. Führen Sie die LR-Zerlegung durch. Geben Sie diese Werte am Bildschirm aus.
= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Octave. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechende weiterführende Literatur, die Octave-Hilfefunktion und die Octave-Dokumentation verwiesen. Octave kennt noch viel mehr Befehle, als hier dargestellt wurden. Aber auch Octave selbst ist erweiterbar. Man siehe z.B. Octave Packages (https://gnu-octave.github.io/packages/) oder man schreibt selbst Erweiterungen.
{{Navigation_zurückhochvor_buch|
zurücktext=Maxima|
zurücklink=Ing Mathematik: Computeralgebrasysteme am Beispiel von Maxima|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Julia für Ingenieure|
vorlink=Ing Mathematik: Julia}}
laq46i0jop3xamztdwk9yngq56q9oh3
1092411
1092410
2026-10-24T09:25:39Z
Intruder
1513
/* Die IF-Verzweigung */
1092411
wikitext
text/x-wiki
{{Navigation_zurückhochvor_buch|
zurücktext=Maxima|
zurücklink=Ing Mathematik: Computeralgebrasysteme am Beispiel von Maxima|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Julia für Ingenieure|
vorlink=Ing Mathematik: Julia}}
= Hallo Welt und allgemeine Hinweise =
== Was ist Octave ==
* Octave ist eine Software zur numerischen Lösung mathematischer Probleme.
* Octave ist Open-Source (GPL-Lizenz).
* Octave ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Octave ist weitgehend kompatibel zum Numerik-Standardprogramm {{W|Matlab|MATLAB}}.
* Octave ist ein Interpreter.
* Octave als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
{{Wikipedia | GNU Octave}}
== Octave installieren ==
=== MS Windows ===
Laden Sie das aktuelle Octave-Paket von der Webseite [https://octave.org/download] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.
=== Linux ===
Entweder ist Octave bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Dazu gehen Sie auf die Seite [https://wiki.octave.org/Category:Installation], wählen die vorhandene Linux-Variante und folgen der angegebenen Beschreibung (z.B. <code>zypper ... </code> für openSUSE. Oder Sie benutzen unter openSUSE Tumbleweed direkt das Setup-Programm {{W|YaST}}).
== Octave starten ==
=== MS Windows ===
Das Icon für das Octave-Programm doppelklicken (für das Konsolenprogramm ... CLI, für die grafische Benutzeroberfläche ... GUI). Und schon startet das Programm.
[[Datei:octavestart1.jpg]]
=== Linux ===
In einer Linux-Konsole den Befehl "octave" eintippen, mit der RETURN-Taste bestätigen, und das Programm (CLI) startet:
GNU Octave (x86_64-suse-linux-gnu) version 11.1.0
Copyright (C) 1993-2026 The Octave Project Developers.
License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>
This is free software; see the source code for copying conditions.
There is NO WARRANTY, to the extent permitted by law. For details, type 'warranty'.
Home page: <https://octave.org>
Support resources: <https://octave.org/support>
Improve Octave: <https://octave.org/get-involved>
For changes from previous versions, type 'news'.
octave:1>
Um Octave mit der eingebauten GUI zu starten, kann der Befehl <code>octave --force-gui</code> verwendet werden:
[[File:Gnu_Octave_IDE.png|600px]]
Alternativ kann, z.B. unter openSUSE Tumbleweed (mit {{W|KDE Plasma 6|KDE-Plasma}}), die Octave-IDE auch über den Application Launcher im Menü ''Education -> GNU Octave'' gestartet werden.
== Ein paar Worte zur Erklärung ==
Im Folgenden wird immer das Konsolenprogramm (CLI ... Command Line Interface) für die Eingabe von Befehlen benutzt. Erst gegen Ende dieses Textes wird auch kurz auf das GUI von Octave eingegangen.
Teilweise werden Ergebnisse der älteren Octave-Version 3.0.3 dargestellt. Die dargestellten Grafiken und Ausgabetexte können je nach Version leicht voneinander abweichen. Der Text wurde ursprünglich mit der Octave-Version 3.0.3 erstellt und anschließend auf die Versionen 5.2 bis 11.1.0 aktualisiert. Dieser Mischmasch sollte aber kein Problem darstellen.
Getestet wurden die Beispiele ursprünglich unter dem Betriebssystem MS Windows 10, später auch mit MS Windows 11, bzw. mit openSUSE Leap 15.6 (Octave 6.4.0, nur vereinzelt) und ab März 2026 auch mit openSUSE Tumbleweed (ab Octave 10.3.0, nur vereinzelt).
== Ein erstes Programm ==
Kommentare werden in Octave mit dem Prozentzeichen (%) oder alternativ mit der Raute (#) eingeleitet. Sie werden vom Octave-Interpreter ignoriert. Will man kompatibel mit MATLAB bleiben, so ist die Version mit dem %-Zeichen vorzuziehen. Text kann mit der disp-Funktion ausgegeben werden. Starten Sie Octave und geben sie folgende Anweisungen zeilenweise ein
octave-3.0.3.exe:1> % Das ist ein Kommentar
octave-3.0.3.exe:2> # und das auch
octave-3.0.3.exe:3> disp "Hallo Welt!"
Als Ergebnis erhalten Sie
Hallo Welt!
Der Prompt (z.B. octave-3.0.3.exe:1>) ist natürlich abhängig von der Octave-Version und den schon eingegebenen Zeilen. Er ist selbstverständlich nicht einzutippen, sondern wird vom Octave-System geliefert.
Strings können in Octave entweder in Anführungszeichen (") gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.
= Octave als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Octave. Geben Sie dann die Formel
octave-3.0.3.exe:1> 3 * 5
ein, drücken die Taste ENTER/RETURN und erhalten als Ergebnis
ans = 15
Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck <math>\sin\sqrt{15}</math> berechnen :
octave-3.0.3.exe:2> sin(sqrt(15))
ans = -0.6679
Octave kennt eine Handvoll von Konstanten, z.B.:
Zeilenweise Eingabe:
% Die Kreiszahl PI
pi
% Die Eulersche Zahl
e
% Zur Maschinengenauigkeit
eps
Ausgabe:
ans = 3.1416
ans = 2.7183
ans = 2.2204e-016
"ans" steht übrigens für den Begriff "answer" (auf Deutsch "Antwort"). Mit "ans" kann wie mit jeder anderen Variable oder Konstanten weitergerechnet werden, z.B.:
Eingabe:
% Der Kreisradius sei 10
10
% Der Kreis-Umfang mit diesem Radius sei folgendes
2 * pi * ans
Ausgabe:
ans = 10
ans = 62.832
Die Ausgabe eines Befehls am Bildschirm (das "Echo") kann übrigens durch Anwendung des Semikolons (;) unterdrückt werden. Gezeigt werden soll dies nun mit Hilfe des obigen Beispiels. Es soll nur der Umfang ausgegeben werden, nicht der Radius.
Eingabe:
% Der Kreisradius sei 10
10;
% Der Kreis-Umfang mit diesem Radius sei folgendes
2 * pi * ans
Ausgabe:
ans = 62.832
Vielleicht ist manchem die Genauigkeit, mit der Echo bzw. der Befehl disp Werte ausgibt, nicht ausreichend. Dem kann Abhilfe verschafft werden und zwar so:
Eingabe:
format short
pi
format long
pi
format longe
pi
% usw.
Ausgabe:
ans = 3.1416
ans = 3.14159265358979
ans = 3.14159265358979e+00
Beenden lässt sich das Octave-Programm durch Eingabe von quit oder exit (und natürlich zur Bestätigung die RETURN-Taste drücken).
== Die Hilfefunktion von Octave ==
Die Eingabe von help mit Angabe eines Funktionsnamens liefert detaillierte Infos zu der gesuchten Funktion.
Eingabe:
help sin
Ausgabe:
'sin' is a built-in function from the file libinterp/corefcn/mappers.cc
-- Y = sin (X)
Compute the sine for each element of X in radians.
See also: asin, sind, sinh.
Additional help for built-in functions and operators is
available in the online version of the manual. Use the command
'doc <topic>' to search the manual index.
Help and information about Octave is also available on the WWW
at https://www.octave.org and via the help@octave.org
mailing list.
Auch gibt es die doc-Funktion für eine vollständige Dokumentation des Octave-Systems, z.B.:
Eingabe:
doc
Ausgabe:
[[Datei:Octave_730_doc_screenshot.jpg]]
== Sonstige einfache Berechnungen ==
In octave gibt es eine "umgekehrte" Division:
11 / 2 % normale Division (Rechtsdivision)
11 \ 2 % umgekehrte Division (Linksdivision)
Ausgabe:
ans = 5.5000
ans = 0.1818
Potenzieren kann man so:
12^5
Ausgabe:
ans = 248832
Den Modulo-Operator % wie in C/C++, Java oder Python gibt es in Octave '''nicht'''. Das Prozentzeichen ist dem Kommentar vorbehalten. Man kann aber eine Funktion hierfür benutzen
y = mod(20, 3)
Ausgabe:
y = 2
Runden mit und auf Ganzzahlen kann man in Octave so:
a = int32(10);
b = int32(3);
x = a / b
y = int32(15) / int32(4)
Ausgabe:
x = 3
y = 4
Siehe dazu aber auch die Funktionen <code>floor</code>, <code>ceil</code> und <code>idivide</code>.
Mittels <code>int32()</code> werden Zahlen als 32-Bit-Ganzzahlen dargestellt. Standardmäßig ist der Datentyp nämlich <code>double</code>. Das ist zu beachten, es ergeben sich unterschiedliche Ergebnisse.
Beispiel:
clear();
a = int32(10);
b = int32(3);
x = a / b
c = 10;
d = 3;
y = c / d
whos()
Ausgabe:
x = 3
y = 3.3333
Variables visible from the current scope:
variables in scope: top scope
Attr Name Size Bytes Class
==== ==== ==== ===== =====
a 1x1 4 int32
b 1x1 4 int32
c 1x1 8 double
d 1x1 8 double
x 1x1 4 int32
y 1x1 8 double
Total is 6 elements using 36 bytes
Ist der Wertebereich von <code>int32</code> zu klein (4 Bytes, <math>-2^{31}</math> bis <math>2^{31} - 1</math>), so gibt es auch <code>int64</code> (8 Bytes, <math>-2^{63}</math> bis <math>2^{63} - 1</math>).
<code>clear</code> löscht Namen und gibt den Speicherplatz wieder frei. <code>whos()</code> liefert detaillierte Informationen der aktuell definierten Variablen.
== Aufgaben ==
* Berechnen Sie mit Octave den Ausdruck <math>\frac{1}{2}\cdot e^2 \cdot \tan(\pi/3)</math>.
* Berechnen Sie mit Octave den Ausdruck <math>2\; \text{cosd}(60) - 3\sin(\pi/5)</math>. Anmerkung: cosd erwartet den Parameter im Gradmaß (d für "degree"), sin erwartet den Parameter im Bogenmaß.
* Erkunden Sie die Fehlerfunktion "erf" mittels Octave-Hilfe.
* Welche Zahl ergibt sich durch <code>3 / 4 \ 2</code>?
* Welche Zahlen werden durch die folgenden Anweisungen ausgegeben?
idivide(int32(10), int32(3), "fix")
idivide(int32(10), int32(3), "round")
idivide(int32(10), int32(3), "floor")
idivide(int32(10), int32(3), "ceil")
floor(10.3)
ceil(10.3)
= Octave als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.m
% Das ist ein Kommentar
# und das auch
disp "Hallo Welt!"
Skriptdateien müssen mit der Dateiendung .m versehen werden. In der Octave-Konsole fügen Sie den Dateipfad mittels
octave-3.0.3.exe:1> addpath("c:/tmp")
hinzu (es ist der UNIX-spezifische Slash (/) zu benutzen). Alternativ können Sie zumindest unter MS Windows auch einen Doppel-Backslash (\\) einsetzen. Oder Sie wechseln mittels <code>cd c:/tmp</code> direkt ins Verzeichnis <code>c:/tmp</code>.
Danach bringen Sie die Skriptdatei test1.m (sozusagen das Hauptprogramm) zur Ausführung
octave-3.0.3.exe:2> test1
Achtung: Die Datei (die Funktion oder das Hauptprogramm) ist in der Octave-Kommandozeile ohne .m-Dateiendung anzugeben. Wie erwartet ergibt sich folgende Ausgabe am Bildschirm
Hallo Welt!
Zumindest unter Linux können Sie z.B. auch komfortabel den {{W|Shebang|Shebang}} (<code>#!</code>) nutzen. Gegeben sei das Octave-Script
#!/usr/bin/octave
disp("Hallo Welt!");
Gepeichert sei es ebenfalls als <code>test1.m</code>. Starten Sie ein Terminal, wechseln Sie in das entsprechende Arbeitsverzeichnis und geben Sie
./test1.m
ein, so erhalten Sie wieder
Hallo Welt!
als Ausgabe auf dem Terminal. Die Zugriffsberechtigung muss natürlich mittels <code>chmod</code> richtig gesetzt werden. Oder Sie führen direkt Octave mit der Datei <code>test1.m</code> aus:
octave test1.m
Sie sehen, mehrere Wege führen zum Ziel.
== Blockkommentare ==
In neueren Octave-Versionen ab dem Jahr 2009 sind auch Blockkommentare möglich. Blockkommentare werden wie normale Kommentare vom Octave-Interpreter ignoriert.
%{
Das ist ein
Blockkommentar
%}
#{
und das auch
#}
Achtung! Folgendes wäre kein Blockkommentar, sondern ergibt einen Fehler.
#{ Das ist kein
Blockkommentar
#}
Die erste Zeile würde zwar durch das # auskommentiert (Zeilenkommentar), die zweite Zeile aber nicht. Die dritte Zeile ist wieder ein Zeilenkommentar.
== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen.
Gültige Variablenbezeichner wären also:
xyz
x1
_wert
name_anzahl
Da Octave case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
xyz
XYZ
xYz
Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.m gespeichert.
x = 5
y = 10
z = x*y
Bringen Sie die Datei test1.m zur Ausführung, so erhalten Sie folgende Bildschirmausgabe
x = 5
y = 10
z = 50
Normalerweise will man aber nur z anzeigen, die Werte von x und y sind ja bereits bekannt. Dazu fügen Sie an den Anweisungsenden, wie bereits weiter oben erwähnt, bei x und y jeweils ein Semikolon (;) an, um das Anweisungsende explizit zu markieren.
x = 5;
y = 10;
z = x*y
Nun erhalten Sie als Ergebnis nur noch
z = 50
Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben.
x = 5; y = 10; z = x*y
Ausgabe:
z = 50
Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
x = 5;
% inkrementiere x
++x
% x = x - 2
x -= 2
Bildschirmausgabe:
ans = 6
x = 4
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist.
Soll eine Anweisung auf mehrere Zeilen verteilt werden, z.B. weil sie zu lang ist, so kann dies durch Verwendung von drei Punkten (...) geschehen, wie nachfolgend dargestellt.
x = 5;
y = 1000 * x + ...
sin(x/2)
Ausgabe:
y = 5000.6
Diese Drei-Punkte-Methode soll nicht für in Anführungszeichen (") eingeschlossene Strings verwendet werden. Diese Methode ist seit geraumer Zeit "deprecated" und funktioniert mit der Version 9.1.0 gar nicht mehr. Benutzen Sie statt dessen den Backslash (\):
txt = "xxxxxxxxxxxxxxxxxxxx\
yyyyyyyyyyyyyyyyy"
Ausgabe:
txt = xxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyy
Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist in Octave problemlos möglich:
wert = 10
wert = 35.5
wert = "Hallo"
wert = pi
Ausgabe:
wert = 10
wert = 35.500
wert = Hallo
wert = 3.1416
Der Befehl <code>who</code>, bzw. <code>whos</code> listet die gegenwärtig definierten Variablen, z.B.:
clear;
a = 10.5;
v = [1 2 3 4 5 12 13];
m = ["s1", "s2"; "s3", "s4"];
disp "***** Der Befehl who *****"
who
disp "***** Der Befehl whos *****"
whos
Ausgabe:
***** Der Befehl who *****
Variables visible from the current scope:
a m v
***** Der Befehl whos *****
Variables visible from the current scope:
variables in scope: top scope
Attr Name Size Bytes Class
==== ==== ==== ===== =====
a 1x1 8 double
m 2x4 8 char
v 1x7 56 double
Total is 16 elements using 72 bytes
==Hexadezimale und binäre Zahlen==
% Hexadezimale Zahl
disp( 0xABC )
% Binäre Zahl
disp( 0b1000011 )
Ausgabe (als Dezimalzahlen):
2748
67
Octave kann auch dezimale in binäre Zahlen etc. umwandeln:
dec2bin( 214 )
Ausgabe:
ans = 11010110
Siehe dazu in der Octave-Hilfe auch folgende Funktionen:
bin2dec, dec2base, dec2hex, hex2dec, base2dec
== Zahlenkolonnen ==
Eine Zahlenkolonne (oder ein Vektor) mit gleichen Abständen der Werte kann folgendermaßen erzeugt werden:
% a ... Startwert
% b ... Schrittweite
% c ... Endwert
a = 0;
b = 10;
c = 100;
x = a : b : c;
disp(x);
Ausgabe:
0 10 20 30 40 50 60 70 80 90 100
Ähnliche Resultate lassen sich auch durch Anwendung der linspace-Funktion erhalten, z.B.:
% a ... Startwert
% b ... Endwert
% c ... Anzahl der Werte
a = 0;
b = 100;
c = 11;
v = linspace(a, b, c)
Ausgabe:
v =
0 10 20 30 40 50 60 70 80 90 100
== Verzweigungen ==
=== Die IF-Verzweigung ===
Die IF-Verzweigung ist aus anderen Programmiersprachen bereits bekannt. In Pseudocode lässt sie sich folgendermaßen darstellen:
WENN bedingung TRUE
führe block1 aus
SONST
führe block2 aus
ENDE
Die test1.m-Datei laute also wie folgt:
x = 5;
if x < 4
disp "x ist kleiner als 4";
else
disp "Der else-Zweig wird ausgefuehrt";
disp "x ist groesser oder gleich 4";
end
Ausgabe:
Der else-Zweig wird ausgefuehrt
x ist groesser oder gleich 4
Octave kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:
* <, <= ... kleiner (gleich)
* >, >= ... größer (gleich)
* == ... gleich
* ~=, != ... ungleich
* &, && ... AND
* |, || ... OR
* ~, ! ... NOT
Beispielsweise:
a = 5;
b = 9;
if a<=10 & b!=7
disp("OK");
else
disp("Nicht OK");
end
Ausgabe:
OK
Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen <math>\varepsilon</math>-Wert) vorgeben.
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:
i = 0.1 + 0.2;
disp(i)
if(i == 0.3)
disp("OK");
else
disp("NOK");
end
Ausgabe:
0.3000
NOK
Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist. Auch die Ausgabe <code>disp(i)</code> gaukelt das vor.
Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:
ist = 0.1 + 0.2;
soll = 0.3;
epsilon = 0.000001;
disp(ist);
if(abs(ist-soll) < epsilon)
disp("OK");
else
disp("NOK");
end
Ausgabe:
0.3000
OK
=== Die SWITCH-Verzweigung ===
In Pseudocode:
WECHSLE ZU var
FALLS wert1 == var
führe block1 aus
FALLS wert2 == var
führe block2 aus
...
SONST
führe blockn aus
ENDE
Eine Beispielsimplementierung in Octave könnte so aussehen:
x = "g";
switch(x)
case "k"
disp("klein");
case "g"
disp("gross");
otherwise
disp("sonstiges")
end
Ausgabe:
gross
Anmerkungen für C-Programmierer:
* in Octave darf zum Abschluß von ''case'' kein Doppelpunkt folgen (würde einen Syntaxfehler auslösen).
* ein ''break'' als Abschluß eines ''case''-Blocks ist nicht erlaubt (würde in Octave einen parse error auslösen). ''break'' ist Schleifen vorbehalten. ''switch'' hat in Octave keinen "Durchfall" und ähnelt somit eher der Fortran-Anweisung ''select case''.
Mehrere Fälle in einem ''case'' können wie nachfolgend behandelt werden:
x = "K";
switch(x)
case {"k" "K"}
disp("klein");
case {"g" "G"}
disp("gross");
otherwise
disp("sonstiges")
end
Ausgabe:
klein
== Schleifen ==
=== Die WHILE-Schleife ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt.
In Pseudocode:
SOLANGE bedingung TRUE
führe block aus
ENDE
In Octave:
x = 0;
while x <= 10
disp(x);
x++;
end
Ausgabe:
0
1
2
3
4
5
6
7
8
9
10
=== Die DO-UNTIL-Schleife ===
Die DO-UNTIL-Schleife ist fußgesteuert. Beachte: Diese Schleife ist nicht äquivalent zu der aus anderen Programmiersprachen bekannten DO-WHILE-Schleife. DO-WHILE bedeutet "TUE SOLANGE", DO-UNTIL bedeutet "TUE BIS". Sie wird mindestens einmal ausgeführt.
Pseudocode:
TUE
führe block aus
BIS bedingung TRUE
Mittels Octave:
x = 0;
do
disp(x);
x++;
until(x >= 5)
Ausgabe:
0
1
2
3
4
=== Die FOR-Schleife ===
for x = 0 : 2 : 10
disp(x);
end
Ausgabe:
0
2
4
6
8
10
Der FOR-Schleifenkopf ist in Form einer Zahlenkolonne folgendermaßen aufgebaut:
for variable = startwert : schrittweite : endwert
Man beachte, dass Vektorisierung gegenüber einem Schleifendurchlauf eine erhebliche Zeiteinsparung bewirken kann (man siehe in der [https://docs.octave.org/latest/Vectorization-and-Faster-Code-Execution.html Octave-Dokumentation das Kapitel 19 "Vectorization and Faster Code Execution"]). Folgendes Beispiel ist an genanntes Octave-Kapitel angelehnt. Zuerst wird eine Berechnung mittels Schleifendurchlauf durchgeführt und der Zeitbedarf ausgegeben. Dieser Zeitbedarf hängt natürlich auch von der verwendeten Hardware etc. ab.
Eingabe:
n = m = 500;
a = b = eye(500);
t1 = time();
for i = 1:n
for j = 1:m
c(i,j) = a(i,j) + b(i,j);
endfor
endfor
t2 = time();
t_diff = t2-t1
Ausgabe:
t_diff = 3.7566
Der Zeitverbrauch beträgt hier also ca. 4 Sekunden. Im Gegensatz dazu
Eingabe:
a = b = eye(500);
t1 = time();
c = a + b;
t2 = time();
t_diff = t2-t1
Ausgabe:
t_diff = 1.5974e-05
ist der Zeitverbrauch hier sehr gering. Vektoren und Matrizen werden etwas später in diesem Text detailliert behandelt. Hier nur soviel: Mittels ''eye'' wird eine Einheitsmatrix kreiert.
Octave hat im Gegensatz zu MATLAB keinen {{W|Just-in-time-Kompilierung|JIT-Compiler}} (JIT ... '''J'''ust '''i'''n '''T'''ime). Darum ist Vektorisierung gerade hier von eminenter Bedeutung.
=== Schleifen abbrechen ===
Zum Abbrechen einer Schleife gibt es den Befehl "break".
for var = 0 : 1 : 100
disp (var);
if var == 5
break;
end
end
Ausgabe:
0
1
2
3
4
5
"continue" setzt mit dem nächsten Schleifendurchlauf fort, z.B.
for var = 0 : 1 : 10
if var == 5
continue;
end
disp (var);
end
Ausgabe:
0
1
2
3
4
6
7
8
9
10
== Aufgaben ==
* Berechnen Sie die Summe der ersten 10000 natürlichen Zahlen (bei 1 beginnend)
** in Form einer WHILE-Schleife
** in Form einer DO-UNTIL-Schleife
** in Form einer FOR-Schleife
** mittels sum-Befehl (siehe dazu auch die von Octave zur Verfügung gestellte Hilfefunktion).
** mittels gaußscher Summenformel (<math>\sum_{i=1}^n{i} = 1+2+...+n = n(n+1) / 2</math>)
* Schreiben Sie für obige Alternativen Programme mit denen der Zeitbedarf der Schleifen, Befehle bzw. Formeln gemessen werden kann. Welche Alternativen sind aus Zeitgründen (minimale Laufzeit) empfehlenswert?
= Grafiken zeichnen =
== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall <math>x\in[-3,3]</math> gezeichnet werden. Der Programmcode lautet in der einfachsten Form:
x = -3 : .1: 3;
y = cosh(x);
plot(x,y);
grid on;
Ausgabe:
[[Datei:octave_cosh.jpg]]
Der Code ist quasi selbsterklärend. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. "plot" ist der Zeichenbefehl. "grid on" schaltet ein Zeichengitter ein.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen.
Sie könnten nun auf die Idee kommen, obiges Script unter Linux mit der Shebang-Zeile zu erweitern, um es direkt als Programm auszuführen.
#!/usr/bin/octave
x = -3 : .1: 3;
y = cosh(x);
plot(x,y);
grid on;
Die Enttäuschung folgt auf dem Fuß. Außer einem kurzen Aufblinken des Grafikfensters ist nicht viel zu sehen. Das Programm läuft einfach durch und wird nach der letzten Anweisung beendet. Abhilfe kann z.B. der <code>input</code>-Befehl schaffen:
#!/usr/bin/octave
x = -3 : .1: 3;
y = cosh(x);
plot(x,y);
grid on;
refresh();
input("Zum Beenden RETURN-Taste drücken");
Das Programm wartet somit, bis Sie im Terminal die RETURN-Taste drücken. <code>refresh()</code> dient dazu, das Grafikfenster unmittelbar zu aktualisieren. Sonst würde das Ausgabefenster leer bleiben, bis es durch externe Anreize aktualisiert wird (z.B. durch Fenster minimieren/maximieren). Gleiches gilt für die <code>octave test1.m</code>-Variante.
Ein etwas komplexeres Beispiel ist Folgendes
x = -3 : .1: 3;
y = cosh(x) + 2.^x;
plot(x,y);
grid on;
Man beachte den Punkt bei 2.^x (2 hoch x). Vergisst man den Punkt, dann erhält man eine Fehlermeldung (ähnlich dieser):
error: for x^y, only square matrix arguments are permitted and one argument must be scalar. Use .^ for elementwise power.
error: called from
test1 at line 2 column 3
Ausgabe:
[[Datei:octave_cosh2.jpg]]
Der Funktionsgraph kann auch als Fläche eingefärbt werden:
x = -3 : .1: 3;
y = cosh(x) + 2.^x;
fill (x, y, "b");
Ausgabe:
[[Datei:octave_cosh3.jpg | 500px]]
=== Graphen mehrerer Funktionen und weiteres ===
Mehrere Graphen lassen sich folgendermaßen in ein Fenster zeichnen:
x = -3 : .1: 3;
y1 = cosh(x) + 2.^x;
y2 = sin(x) .* cos(x);
plot(x,y1, x,y2);
title("Funktionsgraphen");
legend("cosh ...", "sin ...");
xlabel("x");
ylabel("y");
grid on;
[[Bild:octave_cosh14.jpg|600px]]
Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht:
x = -3 : .1: 3;
y1 = cosh(x) + 2.^x;
y2 = sin(x) .* cos(x);
plot(x,y1,"*r", x,y2,"ob");
title("Funktionsgraphen");
legend("cosh ...", "sin ...");
xlabel("x");
ylabel("y");
grid on;
[[Datei:octave_cosh4.jpg]]
Bei plot kann auch der Linienstil des jeweiligen Graphen angegeben werden, z.B. steht
* für Sternchenlinie
o für Kreise in der Linie
r für rot
b für blau
Ein ähnliches Resultat liefert der Code:
x = -3 : .1: 3;
y1 = cosh(x) + 2.^x;
y2 = sin(x) .* cos(x);
plot(x,y1, "Color", "red", "*", x,y2, "Color", "blue", "o");
title("Funktionsgraphen");
legend("cosh ...", "sin ...");
xlabel("x");
ylabel("y");
grid on;
Will man mehrere Graphen in ein Fenster zeichnen, aber nicht alles in einen plot-Befehl quetschen, so kann die "hold on"-Anweisung die Lösung des Problems sein:
%Lösche alle benutzerdefinierten Variablen aus der Symboltabelle
clear;
%Schließe alle Fenster
close all;
%Lösche Konsolenfenster und setze Cursor zurück
clc;
x = -3 : .1: 3;
y1 = cosh(x) + 2.^x;
y2 = sin(x) .* cos(x);
plot(x,y1, "Color", "red");
hold on;
plot(x,y2, "Color", "blue");
title("Funktionsgraphen");
legend("cosh ...", "sin ...");
xlabel("x");
ylabel("y");
grid on;
[[Datei:octave_coshsin1.jpg]]
Bei diesem Program wurden auch einige Möglichkeiten (clear, close, clc) gezeigt, um das System aufzuräumen. Ein "hold off" würde natürlich die hold-Funktion wieder ausschalten.
=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale <math>x = t \cos(t), y = t \sin(t)</math> im Intervall <math>[0, 6\pi]</math> gezeichnet werden.
clear;
close all;
clc;
t = 0 : .1: 6*pi;
x = t .* cos(t);
y = t .* sin(t);
plot(x,y);
grid on;
[[Datei:octave_spirale1.jpg]]
Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den axis-Befehl verwenden (axis muss nach plot erscheinen).
t = 0 : .1: 6*pi;
x = t .* cos(t);
y = t .* sin(t);
plot(x,y);
grid on;
axis equal;
[[Datei:octave_spirale222.jpg]]
=== Strichstärke ===
Für manche Zwecke ist es sinnvoll die Strichstärke des Graphen zu erhöhen. Dies kann über den Parameter "LineWidth" der plot-Funktion geschehen.
t = 0 : .1: 6*pi;
x = t .* cos(t);
y = t .* sin(t);
plot(x,y, "LineWidth", 2);
grid on;
axis equal;
Ausgabe:
[[Datei:octave_spirale3.jpg]]
=== Beliebigen Text ausgeben ===
x = -10:0.1:10;
plot (x, sin (x), "LineWidth", 2);
text (2.7, 0.8, "Das ist die sin-Funktion");
Ausgabe:
[[Datei:octave_text1.jpg]]
=== Logarithmische Achseneinteilung ===
x = -3 : .1: 3;
y = cosh(x) + 2.^x;
% Halblogarithmische Darstellung
semilogy(x,y);
grid on;
Ausgabe:
[[Datei:octave_semilog1.jpg]]
Auch die x-Achse kann mit "semilogx" logarithmisch skaliert werden. Mit "loglog" werden beide Achsen logarithmisch skaliert.
=== Aufgaben ===
* Zeichnen Sie die Strophoide <math>x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3</math>. Das Ganze sollte in etwa so aussehen wie folgende Grafik:
[[Datei:octave_strophoide.jpg]]
* Zeichnen Sie die verschlungene Hypozykloide <math>x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15</math>. Das Ganze sollte in etwa so aussehen wie folgende Grafik:
[[Datei:octave_hypozykloide.jpg]]
* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben (Hinweis: Siehe dazu auch die Octave-Hilfefunktion für den plot-Befehl).
* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.
* Erkunden Sie in der Octave-Hilfe den ezplot-Befehl.
== Gitterlinien und Koordinatenachsen ==
* Zwischengitterlinien aktivieren: <code>grid minor;</code>
* Gitterabstände exakt selbst festlegen, z.B.: <code>set(gca, "XTick", -10 : 1 : 10);</code>
* Gitterfarben und -linienstile anpassen, z.B.:
set(gca, 'GridColor', [0.1, 0.1, 0.1]);
set(gca, 'GridLineStyle', '-');
set(gca, 'MinorGridColor', [0.2, 0.2, 0.2]);
set(gca, 'MinorGridLineStyle', '--');
* Koordinatenachsen selbst festlegen, z.B.
axis([-2, 10, -3, 8]); % x-Achse von -2 bis 10, y-Achse von -3 bis 8
* Markierungen auf den Achsen einstellen, z.B. <code>xticks(0:1:10);</code>
* Achsenkreuz auf 0 setzen:
set(gca, "xaxislocation", "origin");
set(gca, "yaxislocation", "origin");
* Umhüllende Linien abschalten: <code>box off;</code>
<code>gca</CODE> steht übrigens für '''g'''et '''c'''urrent '''a'''xes. Analog dazu gibt es auch <code>gcf</code> ('''g'''et '''c'''urrent '''f'''igure) und <code>gco</code> ('''g'''et '''c'''urrent '''o'''bject). Das ist aber alles schon sehr speziell und wird hier nicht vertieft.
=== Aufgabe ===
Probieren Sie die oben stichpunktartig angegebenen Möglichkeiten an konkreten Programmbeispielen aus.
== 3D ==
=== Räumliche Kurven ===
Mittels "plot3" lassen sich Raumkurven zeichnen.
t = 0 : .1 : 9*pi;
x = cos(t);
y = sin(t);
z = 1.3 .^ t;
plot3(x,y,z);
grid on;
[[Datei:octave_raumkurve1.jpg]]
=== Flächen ===
==== ezsurf ====
Die wahrscheinlich einfachste Möglichkeit 3D-Flächen zu erzeugen, besteht in der Verwendung des ezsurf-Befehls. Beachten Sie beim folgenden Beispiel auch wieder den Punkt beim Multiplikationssymbol (elementweise Multiplikation soll verwendet werden, keine Matrizenmultiplikation) in der anonymen Funktion. Was eine anonyme Funktion ist, wird weiter hinten in diesem Text kurz erklärt. Fürs Erste reicht es zu wissen, dass die Funktion f(x, y) jeweils im Intervall [0, 10] gezeichnet werden soll.
clear; close all; clc; clf;
f = @(x, y) sin(x) + 3.*cos(y);
ezsurf (f, [0, 10]);
[[Bild:octave_ezsurf1.jpg|600px]]
Dieses Bild wurde mit der Octave-Version 5.2 erstellt. Es ist im Prinzip identisch zu jenen des folgenden Abschnitts, die mit der Version 3.0.3 erstellt wurden, nur die Farbschattierung ist anders. Ändern lässt sich diese Eigenschaft mit dem colormap-Befehl (siehe auch Octave-Hilfe):
clear; close all; clc; clf;
colormap(hot);
f = @(x, y) sin(x) + 3.*cos(y);
ezsurf (f, [0, 10]);
[[Bild:octave_colormap_hot.jpg|600px]]
==== surf und mesh ====
Für das Zeichnen von Flächen existiert der surf-Befehl. Der meshgrid-Befehl kreiert ein Netz in der xy-Zeichenebene. Beachten Sie beim folgenden Beispiel auch wieder den Punkt beim Multiplikationssymbol der Formel für z.
x = 0 : .1 : 10;
y = 0 : .1 : 10;
[x_grid, y_grid] = meshgrid(x, y);
z = sin(x_grid) + 3.*cos(y_grid);
surf(x_grid, y_grid, z);
[[Datei:octave_flaeche1.jpg]]
Auch ein Farbstreifen kann via "colorbar" zur Grafik hinzugefügt werden.
x = 0 : .1 : 10;
y = 0 : .1 : 10;
[x_grid, y_grid] = meshgrid(x, y);
z = sin(x_grid) + 3.*cos(y_grid);
surf(x_grid, y_grid, z);
colorbar("East");
[[Datei:octave_flaeche2.jpg]]
Das Ganze in Netzdarstellung läßt sich so programmieren:
x = 0 : .2 : 10;
y = 0 : .2 : 10;
[x_grid, y_grid] = meshgrid(x, y);
z = sin(x_grid) + 3.*cos(y_grid);
mesh(x_grid, y_grid, z);
Ausgabe:
[[Datei:octave_mesh1.jpg]]
==== Ellipsoide und Kegel ====
Für das Zeichnen von Kugeln oder Ellipsoiden stellt Octave den "sphere"-Befehl bzw. den "ellipsoid"-Befehl zur Verfügung.
clear; close all; clc;
% Ellipsoiden zeichnen
[x, y, z] = sphere(30);
surf(5*x, 4*y, 3*z);
hold on;
[x, y, z] = ellipsoid(5, 5, 5, 6, 3, 2, 30);
surf(x, y, z);
axis equal;
[[Bild:octave_ellipsoid2.jpg|600px]]
Für Zylinder und Kegel ist der "cylinder"-Befehl zuständig.
clear; close all; clc;
% Kegel und Zylinder zeichnen
[x, y, z] = cylinder([1 2], 100);
surf(x, y, z*3);
hold on;
[x, y, z] = cylinder([0.5 0.5], 50);
surf(x+3, y, z*2);
axis equal;
[[Bild:octave_cylinder2.jpg|600px]]
=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve <math>x = 2 \cdot \cosh(t)</math>, <math>y = 5 \cdot \sin(t)</math>, <math> z = t^{2} - t</math>, <math>0 \leq t \leq 3\pi</math>. Das Ganze sollte etwa wie folgt aussehen:
[[Datei:octave_kurve10.jpg]]
* Zeichnen Sie die Fläche <math>z = \log(x) + \cos(y)</math>. Das Ganze sollte etwa wie folgt aussehen:
[[Datei:octave_flaeche10.jpg]]
== Weiteres ==
=== subplot ===
Zeichnen mit Untergrafiken: Hier wird z.B. ein Fenster mit drei Untergrafiken gezeichnet.
Eingabe:
t = 0 : .5 : 10;
[x_grid, y_grid] = meshgrid(t, t);
subplot(311);
surf(x_grid, y_grid, sin(x_grid) + cos(y_grid) );
subplot(312);
surf(x_grid, y_grid, sin(x_grid) + log(y_grid) );
subplot(313);
surf(x_grid, y_grid, x_grid + cos(y_grid) );
Ausgabe:
[[Datei:octave_subplot2.jpg]]
Die dreistellige Ziffer beim subplot-Befehl bedeutet folgendes:
* Die erste Ziffer ist die Zeilenanzahl
* Die zweite Ziffer ist die Reihenanzahl und
* Die dritte Ziffer ist der Index.
Beim obigen Beispiel ist die z-Achse ein bisschen zusammengedrückt. Dies wollen wir mit nachfolgendem Code ansatzweise "verbessern" und ein paar weitere Spielereien mit Subplots durchführen.
t = 0 : .5 : 10;
[x_grid, y_grid] = meshgrid(t, t);
% fig = figure();
ax1 = subplot(4, 1, 1:2);
surf(x_grid, y_grid, sin(x_grid) + cos(y_grid) );
grid(ax1, "minor");
axis(ax1, [0, 10, 0, 20, -2, 2]);
ax2 = subplot(413);
surf(x_grid, y_grid, sin(x_grid) + log(y_grid) );
ax3 = subplot(414);
surf(x_grid, y_grid, x_grid + cos(y_grid) );
% refresh();
% input();
[[Datei:octave_subplot105.svg| 400px]]
Nun sei ein Beispiel mit 3x2-Untergrafiken angeführt.
clear;
close all;
clc;
x = 0 : .1 : 10;
subplot(321);
plot(x, sin(x));
text(2, -0.5, "Index 1");
subplot(322);
plot(x, tan(x));
text(2, 2, "Index 2");
subplot(323);
plot(x, cosh(x) );
text(2, 3000, "Index 3");
subplot(324);
plot(x, gamma(x) )
text(2, 100000, "Index 4");
subplot(325);
plot(x, log(x) );
text(2, 0, "Index 5");
subplot(326);
plot(x, exp(x) );
text(2, 10000, "Index 6");
Ausgabe:
[[Datei:octave_subplot3.jpg]]
Hier ist sehr gut zu sehen, in welcher Reihenfolge der Index läuft.
Will man bspw. die Hintergrundfarbe eines Subplots setzen (z.B. auf die Farbe rot), so kann dies über folgende Befehle geschehen:
ax1 = subplot(321);
set(ax1, "color", [1.0, 0.0, 0.0]);
=== figure ===
Zeichnen in verschiedene Fenster, z.B.
clear;
close all;
clc;
x = 0 : .1 : 10;
y = 0 : .1 : 10;
[x_grid, y_grid] = meshgrid(x, y);
figure(1)
surf(x_grid, y_grid, sin(x_grid) + cos(y_grid));
figure(2)
surf(x_grid, y_grid, sin(x_grid) + log(y_grid));
Ausgabe:
[[Datei:octave_figure111.jpg|700px]]
Die Größe und Position eines Fensters können festgelegt werden:
f1 = figure(1, "Position", [100, 100, 800, 600]);
Hintergrundfarbe setzen
f2 = figure(2, 'Color', [1.0, 0.0, 0.0]);
oder auch per
set(f1, 'Color', [1.0, 0.0, 0.0]);
=== Linien zeichnen ===
Zeichnen Sie eine Linie von der Koordinate [-15, 0] zu [15, 5]:
clear;
close all;
clc;
x = line([-15 15], [0, 5], "Color", "black", "LineWidth", 2);
Ausgabe:
[[Datei:octave_linie1.jpg]]
Man beachte, dass Octave nicht Punkte P1(x1, y1), P2(x2, y2) erwartet, sondern einen x-Vektor [x1 x2] und einen y-Vektor [y1 y2].
Ein allgemeines Viereck wird z.B. mit folgendem Befehl gezeichnet.
line([-15 15 10 -5, -15], [0, 5, 20, 15, 0], "LineWidth", 2);
[[Datei:octave_viereck2.jpg]]
Auch dreidimensionale Formen lassen sich mit dem line-Befehl zeichnen:
clear; close all; clc;
line([-15 15 10 -5, -15], [0, 5, 20, 15, 0], [10, 20, 30, 40, 50], "LineWidth", 2);
[[Datei:octave_dreidim2.jpg]]
=== Aufgaben ===
* Zeichnen Sie mittels "subplot" die Funktionsgrafen <math>y_1=\tan(x), y_2=\tan(2x), y_3=\tan\sqrt x, y_4=x\cdot \tan(x)</math> in folgender Form in ein Fenster:
** in 2x2-Darstellung
** in 1x4-Darstellung.
* Zeichnen Sie die im obigen Beispiel angegebenen Funktionsgrafen mittels "figure" jeweils in ein eigenes Fenster.
= Vektoren und Matrizen =
== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein.
=== Zeilen- und Spaltenvektoren ===
% Ein Zeilenvektor
v1 = [1, 2, 3]
% Ein Spaltenvektor
v2 = [6; 7; 8]
Ausgabe:
v1 =
1 2 3
v2 =
6
7
8
Alternative Schreibweisen:
% Ein Zeilenvektor
v1 = [1 2 3]
% Ein Spaltenvektor
v2 = [6
7
8]
Die Ausgabe entspricht der obigen Darstellung.
=== Zugriff auf Vektorelemente ===
Nachfolgend seien einige Zugriffsmöglichkeiten auf die einzelnen Vektorelemente erläutert.
Auf ein einzelnes Element kann via Index zugegriffen werden. Der Index startet bei 1:
v1 = [1 2 4 8 16];
v2 = v1(3)
Ausgabe:
v2 = 4
Mehrere Elemente werden folgendermaßen angesprochen:
v1 = [1 2 4 8 16];
v2 = v1(3:4)
Ausgabe:
v2 =
4 8
Liefere den Teilvektor von einem gegebenen Index bis zum letzten Element:
v1 = [1 2 4 8 16];
v2 = v1(3:end)
Ausgabe:
v2 =
4 8 16
=== Addition und Subtraktion von Vektoren ===
v1 = [1, 2, 3];
v2 = [5, 7, 9];
res = v1 + v2
res = v1 - v2
Ausgabe:
res =
6 9 12
res =
-4 -5 -6
=== Multiplikation mit Skalaren ===
faktor = 3;
v = [1, 2, 3];
res = faktor * v
Ausgabe:
res =
3 6 9
=== Skalarprodukt ===
Das Skalarprodukt ist bekanntermaßen als <math>v_1 \cdot v_2 = |v_1| |v_2| \cos(\angle(v_1, v_2))</math> definiert. In Octave sieht das so aus:
v1 = [1, 2, 3];
v2 = [5, 6, 7];
res = dot(v1, v2)
Ausgabe:
res = 38
=== Vektorprodukt ===
v1 = [1, 2, 3];
v2 = [5, 6, 7];
res = cross(v1, v2)
Ausgabe:
res =
-4 8 -4
Enger an die mathematische Darstellung lehnt sich folgender Code an. Die zu multiplizierenden Vektoren seien in Form von Spaltenvektoren gegeben.
Mathematisch:
<math>a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
</math>
Octave-Code:
a = [1
2
3];
b = [5
6
7];
res = cross(a, b)
Ausgabe:
res =
-4
8
-4
=== Transponierter Vektor ===
v1 = [1, 2, 3];
v2 = [5; 6; 7];
res1 = v1'
res2 = v2'
Ausgabe:
res1 =
1
2
3
res2 =
5 6 7
=== Einige weitere Vektorfunktionen ===
Beispiel:
% 1 + 2 + 3
v = [1 2 3];
sum(v)
Ausgabe:
ans = 6
Beispiel:
% 1 * 2 * 3 * 4
v = [1 2 3 4];
prod(v)
Ausgabe:
ans = 24
Beispiel:
% 1^2 + 2^2 + 3^2
v = [1 2 3];
sumsq (v)
Ausgabe:
ans = 14
== Matrizen ==
Gegeben sei folgende 2x3-Matrix <math>m=\left(\begin{array}{ccc}
1 & 2 & 3\\
4 & 5 & 6
\end{array}\right)</math>.
Eingabe:
m = [1, 2, 3; 4, 5, 6]
Ausgabe:
m =
1 2 3
4 5 6
Alternativ und anschaulicher kann diese 2x3-Matrix auch so eingegeben werden:
m = [1 2 3
4 5 6]
Dies ist schon sehr nahe an der mathematischen Darstellungsweise.
=== Zugriff auf Matrizenelemente ===
m = [1 2 3
4 5 6];
% Element aus Zeile 2 und Spalte 3
m(2,3)
Ausgabe:
ans = 6
Eine andere Zugriffsmöglichkeit ist diese:
m = [1 2 3
4 5 6];
% Auf das fünfte Element soll zugegriffen werden
m(5)
Ausgabe:
ans = 3
Die Matrix wird also spaltenweise durchlaufen (nicht zeilenweise). Dies ist vielleicht auf den ersten Blick etwas ungewöhnlich, wird aber z.B. auch in Fortran so gehandhabt.
Auch Teilmatrizen können einfach gebildet werden:
m = [1 2 3
4 5 6];
m(2:end, 2:end)
Ausgabe:
ans =
5 6
Siehe zu diesem Thema auch etwas weiter hinten in diesem Text den Abschnitt "Teilmatrizen".
=== Addition und Subtraktion von Matrizen ===
m1 = [1, 2, 3; 4, 5, 6];
m2 = [-4, -2, 0; 2, 4, 6];
m1 + m2
m1 - m2
Ausgabe:
ans =
-3 0 3
6 9 12
ans =
5 4 3
2 1 0
=== Transponierte Matrix ===
m = [1, 2, 3; 4, 5, 6];
m'
Ausgabe:
ans =
1 4
2 5
3 6
=== Rang einer Matrix ===
Der Rang einer Matrix Rg(M) ist die maximale Anzahl der linear unabhängigen Zeilenvektoren (Spaltenvektoren).
m1 = [1, 2, 3; 4, 5, 6];
m2 = [1, 2; 2, 4];
rank(m1)
rank(m2)
Ausgabe:
ans = 2
ans = 1
Regulär ist eine nxn-Matrix, wenn der Rg(M) = n. D.h. die erste Matrix m1 ist regulär, die zweite m2 singulär.
=== Inverse Matrix ===
m1 = [1, 3; 0, -5 ];
m2 = [1, 2; 2, 4];
inv(m1)
inv(m2)
Ausgabe:
ans =
1.00000 0.60000
0.00000 -0.20000
warning: matrix singular to machine precision
warning: called from
test1 at line 4 column 1
ans =
Inf Inf
Inf Inf
Die Matrix m2 in diesem Beispiel ist singulär (d.h. die Determinante ist 0). Determinanten werden etwas weiter unten in diesem Text behandelt. Inf steht für Infinity (= Unendlich).
=== Multiplikation von Matrizen (falksches Schema) ===
m1 = [1, 3, 4; 0, -5, 1];
m2 = [1, 2; 2, 3; 0, 2];
m1 * m2
Ausgabe:
ans =
7 19
-10 -13
Will man aus irgendwelchen Gründen nicht das falksche Schema ausführen, sondern elementweise Multiplikation, so funktioniert das mit dem Punkt-Operator, z.B.
m1 = [1, 3; 0, -5];
m2 = [1, 2; 4, 2];
% falksches Schema
m1 * m2
% elementweise Multiplikation
m1 .* m2
Ausgabe:
ans =
13 8
-20 -10
ans =
1 6
0 -10
Verifikation, falksches Schema (Zeile*Spalte):
[ 1 3 ] [ 1 2 ] [ 1*1+3*4 1*2+3*2 ] [ 13 8 ]
[ 0 -5 ] [ 4 2 ] = [ 0*1-4*5 0*2-5*2 ] = [ -20 -10 ]
Verifikation, elementweise Multiplikation (homologe Elemente):
[ 1 3 ] [ 1 2 ] [ 1*1 3*2 ] [ 1 6 ]
[ 0 -5 ] [ 4 2 ] = [ 0*4 -5*2 ] = [ 0 -10 ]
=== Determinante einer Matrix ===
m1 = [1, 3; 0, -5 ];
m2 = [1, 2; 2, 4];
det(m1)
det(m2)
Ausgabe:
ans = -5
ans = 0
m1 ist regulär, m2 ist singulär. Determinanten können nur von quadratischen Matrizen gebildet werden.
=== Teilmatrizen ===
m = [1, 2, 3; 0, 5, 1];
% Die Matrix in einen Spaltenvektor umwandeln
m1 = m(:)
% Das Element aus der 1. Zeile und der 2. Spalte extrahieren
m2 = m(1,2)
% Erste Zeile extrahieren
m3 = m(1, 1:3)
m4 = m(1, :)
% Zweite Spalte extrahieren
m5 = m(1:2, 2)
m6 = m(:, 2)
Ausgabe:
m1 =
1
0
2
5
3
1
m2 = 2
m3 =
1 2 3
m4 =
1 2 3
m5 =
2
5
m6 =
2
5
=== Einheitsmatrizen ===
eye(3,2)
Ausgabe:
ans =
1 0
0 1
0 0
=== Nullmatrizen ===
zeros(2,3)
Ausgabe:
ans =
0 0 0
0 0 0
=== Diagonalmatrizen ===
diag([1, 2, 3])
Ausgabe:
ans =
1 0 0
0 2 0
0 0 3
=== Spur einer Matrix ===
trace([1,2,3; 6,9, 0])
Ausgabe:
ans = 10
=== LR-Zerlegung einer Matrix ===
Führen Sie die LR-Faktorisierung (LR ... links/rechts bzw. LU ... left/upper) einer Matrix m aus. l sei die linke Dreiecksmatrix, r die rechte Dreiecksmatrix und p die Permutationsmatrix
m = [1 0 5
-1 1 -2
0 0 3];
[l, r, p] = lu(m)
Ausgabe:
l =
1 0 0
-1 1 0
0 0 1
r =
1 0 5
0 1 3
0 0 3
p =
1 0 0
0 1 0
0 0 1
=== Eigenwerte ===
a = [5 8
1 3];
% Eigenvektoren und Eigenwerte
[ev, ew] = eig(a)
Ausgabe:
ev =
0.9701 -0.8944
0.2425 0.4472
ew =
Diagonal Matrix
7 0
0 1
Die Eigenwerte sind hier <math>\lambda_1 = 7</math> und <math>\lambda_2 = 1</math>. Die Eigenvektoren sind [0.9701 0.2425] bzw. [-0.8944 0.4472]. Da das Gleichungssystem <math>(A - \lambda_i E) x_i = 0</math> singulär ist, sind alle Lösungsvektoren Vielfache dieser Eigenvektoren.
=== Schwach besetzte Matrizen ===
{{Wikipedia | Dünnbesetzte Matrix}}
Gegeben sei die schwach besetzte Matrix
m = [0 1 0 0 0
0 0 0 3 0
4 0 0 2 0
0 0 1 0 0
0 0 0 1 7]
Mittels dem sparse-Befehl kann man einfach die Elemente != 0 nach folgendem Schema eingeben.
sparse ([zeilenindizes] [spaltenindizes] [werte])
also in unserem Fall:
ms = sparse([1 2 3 3 4 5 5], [2 4 1 4 3 4 5], [1 3 4 2 1 1 7])
Ausgabe:
ms =
Compressed Column Sparse (rows = 5, cols = 5, nnz = 7)
(3, 1) -> 4
(1, 2) -> 1
(4, 3) -> 1
(2, 4) -> 3
(3, 4) -> 2
(5, 4) -> 1
(5, 5) -> 7
Die volle Matrix erhält man mit dem Befehl full:
m = full(ms)
Ausgabe:
m =
0 1 0 0 0
0 0 0 3 0
4 0 0 2 0
0 0 1 0 0
0 0 0 1 7
Grafisch anzeigen lassen kann man sich die Besetzung von Matrizen mit dem spy-Befehl:
spy(ms);
oder (für allgemeine Matrizen auch mittels)
spy(m);
Ausgabe:
[[Datei:octave_sparse1.jpg]]
Wirklich interessant ist der spy-Befehl für größere Matrizen, z.B. um die Bandstruktur zu visualisieren.
e = eye(200);
es = sparse(e);
% Auf sparse-Matrizen kann genauso zugegriffen werden wie auf normalen Matrizen
es(100, 15) = 100;
spy(es);
Ausgabe:
[[Datei:octave_sparse2.jpg]]
=== Matrizen mit Zufallswerten ===
Insbesondere für Testzwecke kann es manchmal sinnvoll sein größere Matrizen mit Zufallswerten zu bilden. Dazu stellt Octave u.a. den rand-Befehl zur Verfügung.
m = rand(5, 6)
Ausgabe:
m =
0.86605 0.61108 0.71347 0.97119 0.52428 0.21993
0.74059 0.49062 0.56073 0.68592 0.74737 0.62680
0.20790 0.84874 0.36834 0.31102 0.25813 0.28933
0.84732 0.98777 0.91512 0.42240 0.87891 0.63757
0.76823 0.80367 0.24639 0.78208 0.77170 0.95281
Die Zufallszahlen liegen gleichverteilt zwischen 0 und 1 und werden nach dem Mersenne-Twister-Verfahren mit einer Periode von <math>2^{19937}-1</math> gebildet.
Andere Verfahren sind:
* randn: Normalverteilte Pseudozufallselemente mit Mittelwert=0 und Varianz=1
* rande: Exponentialverteilte Zufallselemente
* randg: Gammaverteilte Zufallselemente
* randp: Poissonverteilte Zufallselemente
Details dazu siehe in der Octave-Hilfefunktion.
== Aufgaben ==
* Berechnen Sie den Winkel zwischen den beiden Vektoren a = [1 2 0] und b = [2 1 1]. Hinweis: Siehe diesbezüglich auch im Oktave-Hilfesystem den Befehl "norm".
* Gegeben seien Vektoren a = [1 2 5], b = [0 0 -1] und c = [-1 -2 2]. Berechnen Sie das Spatprodukt aus diesen drei Vektoren.
* Multiplizieren Sie die beiden Matrizen A und B (mit Octave und zur Kontrolle händisch)
A = [0 0 1
1 2 1]
B = [1 1
1 2
0 4]
* Ist die Matrix C regulär? Wenn ja, dann bilden Sie die inverse Matrix.
C = [-1 0 0 -4
2 0 1 5
7 6 2 0
3 0 2 6]
* Ist die Matrix D regulär? Wenn ja, dann bilden Sie die inverse Matrix.
D = [2 1 0 0
0 0 2 1
0 0 0 2
1 1 0 0]
* Berechnen Sie die Konditionszahl der folgenden Matrix. Hinweis: Siehe diesbezüglich im Oktave-Hilfesystem den Befehl cond
[3 4 -5
6 0 3
1 1 2]
* Berechnen Sie die Eigenwerte und Eigenvektoren der folgenden Matrix
[6 -3 4 0
0 7 -1 1
0 10 -3 -2
0 1 -2 1]
= Komplexe Zahlen =
Die imaginäre Einheit wird in Octave durch den Buchstaben i, j, I oder J symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung <math>z = \Re(z) + i \cdot \Im(z)</math>
* Polardarstellungen <math>z = r \cdot (\cos(\phi) + i \cdot \sin(\phi)) = r \cdot e^{i\cdot \phi}</math>
Die konjugiert komplexe Zahl ist <math>z^* = \Re(z) - i \cdot \Im(z)</math>
== Mit komplexen Zahlen rechnen ==
z1 = 2 + 5i; % kartesische Darstellung
z2 = 3 * exp(3j); % Polardarstellung
% Addition
res = z1 + z2;
disp("z1 + z2 = "); disp(res);
% Multiplikation
res = z1 * z2;
disp("z1 * z2 = "); disp(res);
% Realteil
res = real(z2);
disp("Realteil von z2 = "); disp(res);
% Imaginärteil
res = imag(z2);
disp("Imaginaerteil von z2 = "); disp(res);
% Betrag
res = abs(z1);
disp("Betrag von z1 = "); disp(res);
% Argument
res = angle(z1);
disp("Argument von z1 = "); disp(res);
% Konjugiert komplexe Zahl
res = conj(z1);
disp("Konjugiert komplexe Zahl von z1 = "); disp(res);
Ausgabe:
z1 + z2 =
-0.96998 + 5.42336i
z1 * z2 =
-8.0568 - 14.0032i
Realteil von z2 =
-2.9700
Imaginaerteil von z2 =
0.42336
Betrag von z1 =
5.3852
Argument von z1 =
1.1903
Konjugiert komplexe Zahl von z1 =
2 - 5i
== Die gaußsche Zahlenebene ==
clear; close all; clc;
z1 = 3 + 5i;
z2 = 5 * exp(0.5i);
hold on;
plot(z1, "*");
compass(z1);
plot(z2, "o");
compass(z2);
grid on;
[[Datei:octave_komplex1.jpg]]
== Aufgaben ==
* Berechnen Sie die Quadratwurzel der komplexen Zahl <math>z = 3 + 2i</math>.
* Verwandeln Sie folgende Zahlen in die Polarkoordinatendarstellung: <math>-11 - 3i</math> und <math>(1+i)^{10}</math>
* Verwandeln Sie folgende Zahlen in die Normaldarstellung: <math>12 \cdot e^{i\cdot \pi / 4}</math> und <math>3 \cdot (\cos(\pi / 3) + i \cdot \sin(\pi / 3))</math>
* Zeichnen Sie die Zahl <math>3 + 5i</math> in der gaußschen Zahlenebene als Zeiger.
= Funktionen =
Um Programme zu strukturieren und einfacher zu gestalten können Programmteile in Funktionen ausgelagert werden. Eingebaute Funktionen haben wir schon kennengelernt (z.B. die Sinus-Funktion sin). Nun wollen wir sehen, wie man selbst solche Funktionen schreiben kann.
== Eine einfache Funktion schreiben ==
Datei addiere.m:
function res = addiere(a, b)
% Addiere zwei Zahlen a + b
res = a + b;
end
Datei test1.m:
addiere(10, 15)
Ausgabe:
ans = 25
* Jede Funktion sollte in einer eigenen m-Datei stehen.
* Der Dateiname sollte mit dem Funktionsnamen (natürlich ohne Dateiendung .m) übereinstimmen.
* Der Kommentar unter dem Funktionskopf wird als Hilfstext angezeigt, wenn die help-Funktion (hier "help addiere") aufgerufen wird.
== Inline-Funktionen ==
Kurze Funktionen können auch als Inline-Funktionen geschrieben werden.
addiere = inline("a + b");
x = 5;
y = 10;
z = addiere(x, y)
Oder in diesem Fall noch kürzer
addiere = inline("a + b");
z = addiere(5, 10)
Ausgabe:
z = 15
Bei neueren Octave-Versionen kann bei der Verwendung von Inline-Funktionen die Warnung
warning: inline is obsolete; use anonymous functions instead
erscheinen. Ein Blick in die Hilfe-Funktion
help inline
zeigt das selbe Ergebnis. Es sollen also anonyme Funktionen (siehe etwas weiter unten in diesem Text) anstelle von Inline-Funktionen verwendet werden.
== Funktionsstring ==
addiere = "a + b";
a = 5;
b = 10;
z = eval(addiere)
Ausgabe:
z = 15
== Anonyme Funktionen ==
{{Wikipedia | Anonyme Funktion}}
addiere = @(a, b) a + b;
x = 10;
y = 20;
z = addiere(x, y)
oder kürzer
addiere = @(a, b) a + b;
z = addiere(10, 20)
Ausgabe:
z = 30
oder noch kürzer
(@(a,b) a+b)(10, 20)
Ausgabe:
ans = 30
== Nullstellen von Funktionen bestimmen ==
sinh2 = @(x) sinh(x) + 2;
z = fzero(sinh2, 1)
Ausgabe:
z = -1.4436
Zur Kontrolle soll hier der Graph der Funktion dargestellt werden
clear;
close all;
clc;
sinh2 = @(x) sinh(x) + 2;
x = -2 : 0.1 : 0;
y = sinh2(x);
z = fzero(sinh2, 1)
plot(x, y);
hold on;
plot(z, 0, "o", "Color", "red", "LineWidth", 2);
text (-1.8, 0.8, "Nullstelle");
line([z -1.7], [0, .7], "Color", "black");
grid on;
Ausgabe:
[[Datei:octave_funktion5.jpg]]
Weiter unten im Text wird die ähnliche Funktion "fsolve" beschrieben. "fzero" benutzt zwei verschiedene Funktionen zur Problemlösung, darunter eben auch "fsolve".
Für die Nullstellenbestimmung von Polynomen gibt es die Funktion "roots". Näheres dazu folgt im nächsten Kapitel.
== Globale Variablen ==
Datei addiere.m:
function res = addiere()
global a b;
res = a + b;
end
Datei test1.m:
clear;
close all;
clc;
global a b;
a = 5;
b = 3;
addiere()
Ausgabe:
ans = 8
== Aufgaben ==
* Schreiben Sie eine Funktion "ellipse", welche eine Ellipse am Bildschirm darstellt. Zur Erinnerung: Die Parameterdarstellung der Ellipse lautet <math>x = a\cdot\cos(t), y = b\cdot\sin(t), 0 \leq t \leq 2\pi</math>, Funktionsargumente seien a und b.
* Schreiben Sie <math>y = 2\cdot\sin(x) + 3\cdot\cos(x/2)</math>
** als normale Funktion
** als Funktionsstring
** als Inlinefunktion
** als anonyme Funktion
** stellen Sie diese Funktion grafisch am Bildschirm dar.
= Polynome =
== Einzelne Polynomwerte berechnen ==
% y = 2*x^3 + 5*x^2 + 4 für x = 2 berechnen
p = [2, 5, 0, 4];
polyval(p, 2)
Ausgabe:
ans = 40
== Polynome zeichnen ==
% y = 2*x^3 - 5*x^2 + 4 für das Intervall -5 <= x <= 5 grafisch darstellen
x = -5 : .1 : 5;
p = [2, 5, 0, 4];
y = polyval(p, x);
plot(x,y);
grid on;
Ausgabe:
[[Datei:octave_polynom1.jpg]]
== Nullstellen bestimmen ==
Für Polynome existiert die Funktion "roots" zur Nullstellenbestimmung.
% Nullstellen für y = 2*x^3 - 5*x^2 + 4 bestimmen
p = [2, 5, 0, 4];
r = roots(p)
Ausgabe:
r =
-2.76214 + 0.00000i
0.13107 + 0.84077i
0.13107 - 0.84077i
Dieses Polynom hat nur eine reelle Nullstelle. Diese liegt, wie am obigen Grafen zu ersehen ist, in der Nähe von -2.762. Die beiden anderen Nullstellen sind konjugiert komplex zueinander (wie es auch sein sollte).
== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms <math>y = 2x^4 - 3x^3 - x + 7</math>.
* Berechnen Sie die Nullstellen von <math>y = 7x^5 - 3x^2 + 12</math>.
* Zeichnen Sie das Polynom <math>y = 12x^4 - 70x</math> im Intervall <math>-5 \leq x \leq 5</math>.
= Lineare Gleichungssysteme =
Sei <math>Ax = b</math> ein lineares Gleichungssystem. <math>A</math> sei die Koeffizientenmatrix, <math>x</math> der Lösungsvektor und <math>b</math> ein bekannter Vektor.
== Einfache Berechnung mittels Gauß-Verfahren ==
{{Wikipedia | Gaußsches Eliminationsverfahren}}
Beispiel:
A = [5 1
0 2];
b = [1
2];
x = A \ b
Ausgabe:
x =
0
1
== Das gmres-Verfahren ==
gmres steht für Generalized Minimal Residual.
{{Wikipedia | GMRES-Verfahren}}
A = [5 1
0 2];
b = [1
2];
x = gmres(A, b)
Ausgabe:
gmres converged at iteration 2 to a solution with relative residual 2.22045e-16
x =
-1.6653e-16
1.0000e+00
Das Ergebnis weicht etwas vom gaußschen Verfahren ab, ist aber trotzdem im Rahmen der Näherung korrekt.
Weiters kennt Octave noch andere iterative Verfahren, z.B. cgs (Conjugate Gradient Squared) oder bicgstab (Bi-Conjugate Gradient Stabilized). Näheres zu diesen Verfahren siehe in der weiterführenden Literatur (z.B. bei Meister: Numerik linearer Gleichungssysteme, Vieweg+Teubner, 2011)
{{Wikipedia | CGS-Verfahren}}
== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Octave (und zur Kontrolle auch händisch):
5x + 6y - 2z = 12
3x - y - 3z = 6
2x + 2y + 4z = 5
= Nichtlineare Gleichungssysteme =
== fsolve und fzero ==
Löse eine beliebige Gleichung f(x) = 0, z.B. <math> f(x) = x^2 - 5\cos(x) - 10 = 0 </math>:
f = @(x) x^2 - 5*cos(x) - 10;
xstart = 1;
[x, fval, info] = fsolve(f, xstart)
Ausgabe:
x = 2.4681
fval = -1.7764e-015
info = 1
* x ist eine Nullstelle in der Nähe vom Startwert xstart.
* fval ist die Abweichung, den f bei x aufweist.
* info ist ein "Fehlercode": 1 bedeutet, dass der relative Fehler in der spezifizierten Toleranz liegt (wie es sein soll). 3 würde bedeuten, dass der Algorithmus nicht konvergiert (z.B. weil keine Nullstelle existiert).
Zur Kontrolle plotten wir den Funktionsgraphen:
x = - 1 : .1 : 3;
y = x.^2 - 5.*cos(x) - 10;
plot(x,y, "LineWidth", 2);
grid on;
Ausgabe:
[[Datei:octave_nichtlin1.jpg]]
Und siehe da, die gesuchte Nullstelle liegt wie berechnet bei einem Wert nahe 2,5. Die Funktion <math>x^2 - 5\cos(x) - 10</math> hat noch eine zweite Nullstelle, wie in der folgenden Abbildung zu erkennen ist.
[[Datei:octave_nichtlin2.jpg]]
Diese zweite Nullstelle erhalten wir, wenn der Startwert in der Nähe dieser zweiten Nullstelle liegt, also z.B. bei -1. Ändern Sie einfach den entsprechenden Startwert im obigen Programmcode, und das Programm sollte die Nullstelle in der Nähe von -2.5 liefern.
Auch die Funktion ''fzero'' kann zur Lösung einer nichtlinearen Gleichung verwendet werden. Die Hilfe-Funktion von Octave empfiehlt dies sogar eindringlich für den Fall einer nichtlinearen Gleichung in einer Variablen. Für das gleiche Beispiel wie oben kann der Programmcode folgendermaßen aussehen:
Eingabe:
f = @(x) x^2 - 5*cos(x) - 10;
[x0, y0] = fzero (f, [0, 3])
Ausgabe:
x0 = 2.4681
y0 = -1.2434e-14
== Gleichungssysteme ==
Folgende Aufgabe ist dem Buch "Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72" entnommen. Zu lösen ist das nichtlineare Gleichungssystem
<math>f_1 = 2x_1 + 4x_2 = 0 </math>
<math>f_2 = 4x_1 + 8x_2^3 = 0</math>
Lösung:
f.m:
function y = f(x)
y(1) = 2*x(1) + 4*x(2);
y(2) = 4*x(1) + 8*x(2)^3;
end
test1.m:
clear;
close all;
clc;
[x, fval, info] = fsolve (@f, [0, 1])
[x, fval, info] = fsolve (@f, [0, -1])
[x, fval, info] = fsolve (@f, [0, 0])
Ausgabe:
x =
-2 1
fval =
0 7.4930e-09
info = 1
x =
2 -1
fval =
0 -7.4930e-09
info = 1
x =
0 0
fval =
0 0
info = 1
== Aufgaben ==
* Bestimmen Sie die Nullstellen von <math>f(x) = x^2 - 3</math>. Plotten Sie den Grafen.
* Bestimmen Sie die Nullstelle von <math>f(x) = sin(x) - x - 1</math>. Plotten Sie den Grafen.
* Lösen Sie das folgende Gleichungssystem (und stellen Sie das Ganze grafisch am Bildschirm dar): <math> f_1 = x_1 + x_2 = 0; f_2 = x_1 + \sin{x_2} = 0</math>
= Interpolation =
== Eindimensionale Interpolation ==
{{Wikipedia | Interpolation (Mathematik)}}
Bezüglich eindimensionaler Interpolation sei auf die [https://docs.octave.org/v11.1.0/One_002ddimensional-Interpolation.html Octave-Dokumentation und Hilfefunktion zum Befehl " interp1"] verwiesen. Dort findet sich auch ein Programmbeispiel, das als Grundlage des folgenden Plots dient:
[[Datei:octave_interpol1.jpg]]
== Mehrdimensionale Interpolation ==
Bezüglich mehrdimensionaler Interpolation siehe die [https://docs.octave.org/v11.1.0/Multi_002ddimensional-Interpolation.html Hilfefunktion zu "interp2", "interp3" und "interpn"].
== Aufgabe ==
* Gegeben seinen die fünf Stützpunkte p1 = [1, 0], p2 = [2, -5], p3 = [3, 2], p4 = [4, 7], p5 = [5, 6]. Legen Sie eine Funktion (die Interpolierende) durch diese Stützpunkte. Eine Lösungsmöglichkeit:
xp = [1 2 3 4 5];
yp = [0, -5, 2, 7, 6];
xf = 1 : .1 : 5;
spl = interp1(xp, yp, xf, "spline");
pch = interp1(xp, yp, xf, "pchip");
plot(xp, yp, "or", "LineWidth", 2, xf, spl, "LineWidth", 2, ...
xf, pch, "LineWidth", 2);
legend("stuetzpunkte", "spline", "pchip", "location", "southeast");
[[Datei:octave_interpol3.jpg]]
= Differenzialrechnung =
== Polynome differenzieren ==
Es soll das Polynom <math>y = 2x^3 - 5x^2 + 7</math> differenziert werden.
% Differenzieren des Polynoms y = 2*x^3 - 5*x^2 + 7
p = [2, -5, 0, 7];
polyder(p)
Ausgabe:
ans =
6 -10 0
D.h. also, die Ableitung von <math>y = 2x^3 - 5x^2 + 7</math> ist <math>y' = 6x^2 - 10x</math>.
== Sonstige Funktionen differenzieren ==
Als Beispiel differenzieren wir <math>y = 5x\sin{x}</math> und stellen das Ganze grafisch dar.
clear;
close all;
clc;
x = 0 : 0.01 : 10;
y = 5 .* x .* sin(x);
y_strich = diff(y) / 0.01;
plot(x, y, "Color", "red", "LineWidth", 2);
hold on;
plot(x(1:length(x)-1), y_strich, "Color", "blue", "LineWidth", 2);
legend("y", "y'");
grid on;
Ausgabe:
[[Datei:octave_diff1.jpg]]
diff(y) ist der Vektor aus den Differenzen y(2)-y(1), ..., y(n)-y(n-1). Für die genaue Arbeitsweise der diff-Funktion siehe "help diff".
== Aufgaben ==
* Differenzieren Sie das Polynom <math>y = 5y^5 - y^4 + 6y - 4</math>.
* Differenzieren Sie die Funktion <math>y = \log(x) + 10x</math> und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion <math>y = \frac{\sinh(x)}{(1+x)}</math> und stellen Sie y, sowie y' grafisch am Bildschirm dar.
= Integralrechnung =
== Polynome integrieren ==
Berechnen Sie das unbestimmte Integral von <math>y = 2x^3 - 7x^2 + 7</math>
p = [2, -7, 0, 7];
p_int = polyint(p)
Ausgabe:
p_int =
0.50000 -2.33333 0.00000 7.00000 0.00000
Das Ergebnis lautet also <math>\int{y dx} = 0.5x^4 - 2.33333x^3 + 7x + C</math> (auf die Integrationskonstante C darf nicht vergessen werden!).
== Gauß-Quadratur ==
{{Wikipedia | Gauß-Quadratur}}
Berechnen Sie das Integral <math>\int_{0}^{3}x^2 dx</math> mittels Gauß-Quadratur.
Datei f.m:
function y = f(x)
y = x^2;
end
Datei test1.m:
[v, ier, nfun, err] = quad ("f", 0, 3)
Ausgabe:
v = 9.0000
ier = 0
nfun = 21
err = 9.9920e-014
Erläuterung zur Ausgabe:
* v ... Resultat der Integration
* ier ... integer error code
* nfun ... Anzahl der Funktionsaufrufe
* err ... Fehler in der Lösung
== Quadratur mittels adaptiver Lobatto-Regel ==
Berechnen Sie diesmal das Integral <math>\int_{0}^{3}x^2 dx</math> mittels Lobatto-Quadratur.
f = inline("x.^2");
v = quadl (f, 0, 3)
Ausgabe:
v = 9
Wie weiter oben bereits angesprochen kann bei der Ausgabe eine Warnung erfolgen. Inline-Funktionen sind inzwischen als obsolet erklärt und es sollen stattdessen anonyme Funktionen verwendet werden.
Zwecks Übung sei nachfolgend nochmals dieses Beispiel berechnet. Diesmal wird aber eine anonyme Funktion verwendet.
v = quadl (@(x) x.^2, 0, 3)
== Aufgaben ==
* Integrieren Sie das Polynom <math>y = 5y^5 - y4 + 6y - 4</math>.
* Integrieren Sie die Funktion <math>y = \log(x) + 10x</math> von -5 bis 5.
* Integrieren Sie die Funktion <math>y = x^3</math> von 0 bis 4. Verwenden Sie hierzu die Simpsonregel (siehe dazu in der Hilfefunktion den Befehl "quadv").
= Gewöhnliche Differenzialgleichungen =
== ode23, ode45 und lsode ==
Für die Lösung von Differenzialgleichungen stehen die Funktionen
* ode23
bzw.
* ode45
zur Verfügung. Diese Funktionen implementieren das Runge-Kutta-Verfahren. "ode" steht für "Ordinary Differential Equation" (also auf Deutsch für "Gewöhnliche Differentialgleichung"). Die Zahlen bei ode23 oder ode45 stehen für die Ordnung.
{{Wikipedia | Runge-Kutta-Verfahren}}
Beispiel <math>y' = x^2 + y^3</math>:
clear;
close all;
clc;
[x, y] = ode45(@(x,y) (x^2+y^3), [0 1], 0);
plot(x, y, "LineWidth", 2);
Ausgabe:
[[Datei:octave_ode1.jpg]]
Bezüglich der genauen Funktionsweise von "ode45" (oder "ode23") siehe die Octave-Hilfe.
Auch die Funktion "lsode" steht zur Lösung von ODEs zur Verfügung.
Beispiel <math>y' = x + y</math>:
clear;
close all;
clc;
t = 0 : .1 : 5;
[y2, istate, msg] = lsode(@(x,y) (x + y), 1, t);
istate
msg
plot(t, y2);
Ausgabe:
istate = 2
msg = successful exit
[[Datei:octave_lsode1.jpg]]
Bezüglich der genauen Funktionsweise von "lsode" siehe die Octave-Hilfe.
== Aufgaben ==
* Lösen Sie die Differenzialgleichung <math>y' = \frac{1}{x\cdot y}</math> mit Octave. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung <math>m' = -k\cdot m</math>. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung <math>y' = \sqrt{|y|}</math>.
= Die Fast-Fourier-Transformation =
{{Wikipedia | Schnelle Fourier-Transformation}}
Für die Funktion "fft" siehe das Octave-Hilfesystem.
= Mengenrechnung =
== Vereinigungsmenge ==
v1 = [1 2 3 4];
v2 = [2 4 6];
union(v1, v2)
Ausgabe:
ans =
1 2 3 4 6
== Schnittmenge ==
v1 = [1 2 3 4];
v2 = [2 4 6];
intersect(v1, v2)
Ausgabe:
ans =
2 4
= Logik =
Logische Operatoren werden oft benötigt, z.B. bei Schleifen und Verzweigungen.
Octave kennt die logischen Operatoren <code>or, and, not</code> und <code>xor</code>. Als Beispiel sei die Wahrheitstabelle für den Operator <code>or</code> dargestellt.
A B A or B
--------------------
true true true
true false true
false true true
false false false
In Octave kann das so ausgedrückt werden:
or( true, true )
or( true, false )
or( false, true )
or( false, false )
Ausgabe:
ans = 1
ans = 1
ans = 1
ans = 0
Zahlen ungleich 0 stehen für true, 0 für false. Z.B.:
or( 22, 0)
Ausgabe:
ans = 1
Äquivalent zu <code>or</code> ist der Operator <code>|</code>:
22 | 0
Ausgabe:
ans = 1
Zwecks näheren Informationen zu den Operatoren <code>and (&, &&), not (~, !)</code> und <code>xor</code> bemühe man Octaves Help-Funktion.
Bitweise logische Funktionen kennt Octave auch, so kann man z.B. zwei Zahlen mit dem bitweisen OR-Operator verknüpfen:
0b1100101
0b0110001
---------
0b1110101
Oder in Dezimalzahlen:
101
49
---
117
In Octave:
bitor( 0b1100101, 0b0110001 )
dec2bin( ans )
Ausgabe:
ans = 117
ans = 1110101
Zu <code>bitand, bitxor</code> usw. siehe die Octave-Hilfe-Funktion.
= Stochastik =
==Deskriptive Statistik ==
=== Lageparameter ===
Arithmetischer Mittelwert:
vec = [1 2 3 4 5 12 13];
mw = mean(vec)
Ausgabe:
mw = 5.7143
Der Median oder Zentralwert läßt sich folgendermaßen berechnen:
vec = [1 2 3 4 5 12 13];
median(vec)
Ausgabe:
ans = 4
Der Modus oder häufigste Wert läßt sich mittels "mode"-Funktion eruieren:
vec = [1 2 1 3 5 1 2 7];
[m, f, c] = mode (vec);
disp(m);
disp(f);
disp(c);
Ausgabe:
1
3
{
[1,1] = 1
}
m (erste Zeile der Ausgabe) ist der Modus. f (zweite Zeile) ist die Häufigkeit. Näheres dazu siehe im Octave-Hilfesystem.
=== Streuungsparameter ===
Varianz:
vec = [1 2 3 1 1 6 7];
v = var(vec)
Ausgabe:
v = 6.3333
Standardabweichung:
vec = [1 2 3 1 1 6 7];
s = std(vec)
Ausgabe:
s = 2.5166
=== Grafiken erzeugen ===
Histogramme:
v = [1 1 2 3 1 6 7 6 1 1 1 2];
hist(v, max(v));
Ausgabe:
[[Datei:octave_histo2.jpg]]
Balkendiagramme:
v = [1 1 2 3 1 6 7 6];
bar(v);
Ausgabe:
[[Datei:octave_bar111.jpg]]
Treppendiagramm:
v = [1 1 2 3 1 6 7 6];
stairs(v);
Ausgabe:
[[Datei:octave_stairs1.jpg]]
Stabdiagramm:
v = [1 1 2 3 1 6 7 6];
stem(v);
Ausgabe:
[[Datei:octave_stem1.jpg]]
=== Aufgaben ===
Gegeben sei folgende Datentabelle mit den Werten:
v1 = [3 4 1 1 7 2 1 9 2 5 9 7 2 2 9 2 2 1 2 8]
v2 = [1 1 0 2 3 4 1 2 7 0 2 1 5 5 5 4 5 2 5 0]
* Berechnen Sie die Lageparameter und Streuungsparameter des Vektors v1.
* Berechnen Sie Kovarianz und Korrelationskoeffizient der beiden zugeordneten Vektoren v1 und v2.
* Zeichnen Sie das Histogramm des Vektors v1.
== Wahrscheinlichkeitsrechnung ==
=== Kombinatorik ===
Der Binomialkoeffizient:
<math>\binom{n}{k}=\frac{n!}{k!(n-k)!}</math>
In Octave z.B.:
n = 30;
k = 4;
n_ueber_k = nchoosek (n, k)
Ausgabe:
n_ueber_k = 27405
Permutationen sind die verschiedenen Anordnungsmöglichkeiten mit der Anzahl n! = n * (n-1) * ... * 2 * 1.
Beispiel:
v = [1, 2, 3];
p = perms(v)
Ausgabe:
p =
1 2 3
2 1 3
1 3 2
2 3 1
3 1 2
3 2 1
n! (n-Fakultät) selbst kann so berechnet werden:
% 10!
n = 10;
factorial (n)
Ausgabe:
ans = 3628800
=== Verteilungen ===
Octave kennt eine ganze Reihe von Dichte- und Verteilungsfunktionen und zwar
* Probability Density Functions (PDF, Dichtefunktionen)
* Cumulative Distribution Functions (CDF, Verteilungsfunktionen)
Z.B.:
* Binomialverteilung:
** binopdf
** binocdf
* Hypergeometrische Verteilung:
** hygepdf
** hygecdf
* Normalverteilung:
** normpdf
** normcdf
* Studentverteilung:
** tpdf
** tcdf
* Weibullverteilung:
** wblpdf
** wblcdf
Ein Codebeispiel zur Binomialverteilung:
clear;
close all;
clc;
x = 0 : 1 : 10;
n = 10;
p = 0.1;
b1 = binopdf (x, n, p);
b2 = binocdf (x, n, p);
subplot(221);
bar(x, b1);
title("binopdf");
text(1, 0.1, "n=10; p=0.1");
subplot(222);
bar(x, b2);
title("binocdf");
text(1, 0.5, "n=10; p=0.1");
n = 10;
p = 0.5;
b1 = binopdf (x, n, p);
b2 = binocdf (x, n, p);
subplot(223);
bar(x, b1);
text(1, 0.1, "n=10; p=0.5");
subplot(224);
bar(x, b2);
text(1, 0.1, "n=10; p=0.5");
Ausgabe:
[[Datei:octave_bino3.jpg]]
Möglicherweise erhalten Sie bei diesem Beispiel eine Fehlermeldung in der Form
error: 'binopdf' undefined near line 8, column 6
The 'binopdf' function belongs to the statistics package from Octave
Forge which you have installed but not loaded. To load the package, run
'pkg load statistics' from the Octave prompt.
Laden Sie einfach das Paket für die Statistikfunktionen, wie in der Fehlermeldung beschrieben.
Ein Codebeispiel zur Normalverteilung:
clear;
close all;
clc;
x = -4 : .1 : 4;
b1 = normpdf(x);
b2 = normcdf(x);
subplot(121);
plot(x, b1);
title("normpdf");
grid on;
subplot(122);
plot(x, b2);
title("normcdf");
grid on;
Ausgabe:
[[Datei:octave_norm111.jpg]]
== Zufallszahlengeneratoren ==
Octave kann Zufallszahlen aus einer großen Anzahl von Verteilungen generieren, z.B.
* Chi-Quadrat-Verteilung: chi2rnd
* Log-Normal-Verteilung: lognrnd
* Normalverteilung: normrnd
Codebeispiel:
mean = 0;
standardabweichung = 1;
zufallszahl = normrnd (mean, standardabweichung)
Ausgabe (gibt eine Zufallszahl rund um den Mittelwert 0 aus), z.B.
zufallszahl = 1.0451
Auch Zufallsvektoren (oder Zufallsmatrizen) können erstellt werden:
mean = [0 0 0 0 0];
standardabweichung = 1;
zufallsvektor = normrnd (mean, standardabweichung)
Ausgabe, z.B.:
zufallsvektor =
1.47108 -0.51280 0.52726 0.31730 -1.04422
= Das symbolic-Paket =
Octave ist kein CAS ('''C'''omputer '''A'''lgebra '''S'''ystem). Stattdessen kann man eine Schnittstelle zu SymPy (Python) etablieren, und zwar über das symbolic-Paket. Es muss vorab installiert werden, z.B. bei openSUSE mittels YaST (octave-forge-symbolic).
== Rechnen mit wirklich großen Zahlen ==
Das symbolic-Paket bietet u.a. die Möglichkeit mit großen Zahlen exakt zu hantieren.
<code>vpa</code> steht nachfolgend für '''v'''ariable-'''p'''recision '''a'''rithmetic.
pkg load symbolic;
digits(50);
vpa(0.1)
vpa("0.1")
Ausgabe:
Symbolic pkg v3.2.2: Python communication link active, SymPy v1.14.0.
ans = (sym) 0.10000000000000000555111512312578270211815834045410
ans = (sym) 0.10000000000000000000000000000000000000000000000000
Hier sieht man, dass es nötig ist, die Zahlen als String an <code>vpa</code> zu übergeben, ansonsten handelt man sich Rundungsfehler ein.
Nun noch ein Beispiel für große Gleitpunktzahlen:
pkg load symbolic;
digits(50);
x = vpa("1.12345e500");
y = vpa("20000.0");
x*y
Ausgabe:
Symbolic pkg v3.2.2: Python communication link active, SymPy v1.14.0.
ans = (sym) 2.2469000000000000000000000000000000000000000000000e+504
Um die Meldung "Symbolic pkg v3.2.2: Python communication link active, SymPy v1.14.0" zu unterdrücken, gibt es den Schalter/Befehl <code>sympref quiet on</code>:
pkg load symbolic;
sympref quiet on;
x = vpa("1.12345e500", 50);
y = vpa("20000.0", 50);
x*y
Ausgabe:
ans = (sym) 2.2469000000000000000000000000000000000000000000000e+504
Mit dem symbolic-Paket können auch noch andere Probleme gelöst werden (z.B. symbolische Integration oder Differentiation). Dies wird aber hier nicht demonstriert, sondern als Aufgabe gestellt.
== Aufgaben ==
* Recherchieren Sie im Internet zur <code>diff()</code>-Funktion von symbolic. Differenzieren Sie mit Octave folgende Funktionen symbolisch:
** <math>f(x) = \sin(x)\cdot x</math> (und zwar ist die 1. Ableitung gesucht)
** <math>g(x) = x^3</math> (die 2. Ableitung ist gesucht)
* Recherchieren Sie im Internet zur <code>int()</code>-Funktion von symbolic. Integrieren sie mit Octave symbolisch:
** <math>\int{x^3 \ d\text{x}}</math>
** <math>\int_0^2{x^3 \ d\text{x}}</math>
* Gegeben sei das lineare Gleichungssystem <math>2x+3y=7</math>; <math>\ -1x-3y=5</math>.
** Recherchieren Sie dazu im Internet zu <code>syms</code> und <code>solve()</code> aus dem symbolic-Paket
** Lösen Sie das gegebene Gleichungssystem symbolisch.
* Bestimmen Sie die Schnittpunkte eines Kreises mit einer Geraden mittels Octave und dem symbolic-Paket (nichtlineares Gleichungssystem). Das funktioniert auch mittels <code>solve()</code>. Gegeben sind die Gerade <math>y = x + 2</math> und der Kreis <math>x^2 + y^2 = 9</math>.
<small> Eine mögliche Lösung wird nachfolgend gezeigt (weil das etwas diffiziler ist und die im Internet angebotenen Lösungen teils in die Irre führen - Warnungen und Fehlermeldungen beim Ausführen der Scripte):
pkg load symbolic;
syms x y;
gerade = -y + x + 2;
kreis = x^2 + y^2 - 9;
lsg = solve([gerade, kreis], [x, y]);
disp(lsg{1}.x);
disp(lsg{1}.y);
disp("---------------");
disp(lsg{2}.x);
disp(lsg{2}.y);
Ausgabe:
Symbolic pkg v3.2.2: Python communication link active, SymPy v1.14.0.
√14
-1 + ───
2
√14
1 + ───
2
---------------
√14
- ─── - 1
2
√14
1 - ───
2
Dass das Ergebnis stimmt, kann man grafisch nachvollziehen:
% Kreis
t = 0 : .1: 2*pi+.1;
x = 3 * cos(t);
y = 3 * sin(t);
plot(x,y);
grid on;
axis equal;
% Gerade
hold on;
x = -4 : .1 : 4;
y = x+2;
plot(x,y);
% Schnittpunkte
plot(-1+sqrt(14)/2., 1+sqrt(14)/2., 'r.', 'MarkerSize', 20);
plot(-1-sqrt(14)/2., 1-sqrt(14)/2., 'r.', 'MarkerSize', 20);
% refresh();
% input("");
Ausgabe:
</small>
[[Bild:octave_nlin_gs1.svg|350px]]
* Führen Sie symbolische Laplace-Transformationen durch:
** Recherchieren Sie dazu im Internet zum Thema "Wie führt man eine Laplace-Transformation mit dem Octave-Paket symbolic aus?". Dies führt auf die Funktion <code>laplace()</code>.
** Gegeben ist die Sprungfunktion (1). Gesucht ist die Laplace-Transformierte.
** Gegeben ist die Sinusfunktion (<math>\sin{\omega t}</math>). Gesucht ist die Laplace-Transformierte.
= Regelungstechnische Aufgabenstellungen =
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket <code>control</code>. Dieses muss vorab installiert werden (z.B. bei openSUSE mittels YaST). Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms gezeigt werden. Gegeben sei <math>G(s)= \frac{1}{30s^3+20s^2+10s+1,5}</math>.
Octave-Code:
pkg load control;
zaehler = [1];
nenner = [30., 20., 10., 1.5];
G = tf(zaehler, nenner);
bode(G);
grid on;
% refresh();
% input("");
Ausgabe:
[[Bild:octave_rt1.jpg|400px]]
<code>tf()</code> steht für '''t'''ransfer '''f'''unction (engl. für Übertragungsfunktion). Die Dokumentation für das <code>control</code>-Paket findet sich [https://gnu-octave.github.io/pkg-control/doc_control.html hier].
= Einfache Benutzeroberflächen erstellen=
== Input ==
fflush (stdout);
x = input("Gib eine Zahl ein: ");
disp(2 * x);
Ein-/Ausgabe:
Gib eine Zahl ein: 12
24
Der "fflush"-Befehl sollte immer vor dem Aufruf des input-Befehls aufgerufen werden. Näheres zu "fflush" siehe im Octave-Hilfesystem.
== Diverse einfache vorgefertigte Dialoge ==
Fehlermeldung:
errordlg("Fehlermeldung");
[[Bild:octave_fehlermeldung1.jpg]]
Warnung:
warndlg("Warnung");
[[Bild:octave_warnung1.jpg]]
Hilfedialog:
helpdlg
[[Bild:octave_hilfe1.jpg]]
Abfragedialog:
button = questdlg ("Frage")
[[Bild:octave_abfrage1.jpg]]
Eingabedialog:
in = inputdlg("Eingabe")
[[Bild:octave_eingabe1.jpg]]
Messagebox:
h = msgbox ("Eine Mitteilung!");
[[Bild:octave_messagebox1.jpg]]
== Komplexere vorgefertigte Dialogboxen ==
=== Menübox ===
auswahl = menu("Auswahl", "Affe", "Elefant", "Loewe", "Sonstiges");
switch(auswahl)
case 1
disp "Affe quietscht"
case 2
disp "Elefant trompetet"
case 3
disp "Loewe bruellt"
otherwise
disp "Sonstiges"
end
Ausgabe:
[[Bild:octave_menu1.jpg]]
Es werde beispielsweise die Nummer 2 gewählt.
Ausgabe:
Elefant trompetet
=== Dialogliste ===
clear;
close all;
clc;
opt = {"Eins", "Zwei", "Drei"};
[sel, ok] = listdlg ("ListString", opt, "SelectionMode", "Multiple");
if (ok == 1)
for i = 1 : numel(sel)
disp(opt{sel(i)});
end
else
disp("Cancel");
end
[[Bild:octave_dialog1.jpg]]
Es werden beispielsweise alle Optionen ausgewählt.
Ausgabe:
Eins
Zwei
Drei
=== Fortschrittsbalken ===
h = waitbar ([0.5])
[[Bild:octave_fortschritt1.jpg]]
=== Datei- und Verzeichnisdialoge ===
Dateidialog:
[fname, fpath, fltidx] = uigetfile ()
[[Bild:octave_dateidialog2.jpg]]
Ähnlich sind die Befehle "uiputfile" und "uigetdir". Dazu sei auf die Octave-Hilfe verwiesen.
== Eigene Dialoge kreieren ==
Dieses Thema sei hier nur kurz angerissen.
Programmcode:
d = dialog("Position", [300, 300, 250, 150], "Name", "Dialog");
txt = uicontrol("Parent", d, ...
"Style", "text", ...
"Position", [20, 80, 210, 40], ...
"String", "Hallo Welt");
btn_servus = uicontrol("Parent", d, ...
"Position", [30, 20, 80, 30], ...
"String", "Servus", ...
"Callback", "disp('Servus angeklickt!');");
btn_hallo = uicontrol("Parent", d, ...
"Position", [140, 20, 80, 30], ...
"String", "Hallo", ...
"Callback", "disp('Hallo angeklickt!');");
uiwait(d);
Ausgegebenes Dialogfenster:
[[Bild:octave_dialog100.jpg]]
Ausgabe auf der Konsole (je nach gedrücktem Button), z.B.:
Servus angeklickt!
Die Position wird als [links, unten, breite, höhe] angegeben. Der Koordinatennullpunkt liegt, bezogen auf das Elternfenster, links unten. Es sind auch negative Koordinatenwerte möglich. Sinnvoll ist das z.B. bei einem dynamischen Ausblenden ohne zu löschen, oder für Animationen.
[[Bild:Cartesian-coordinate-system.svg | 150px]]
Wer mehr dazu wissen will, sei auf die Octave-Dokumentation verwiesen. Insbesondere siehe
* dialog
* uicontrol
* uipanel
* uibuttongroup
* uitable
* uimenu
* uitoolbar
== Aufgaben ==
=== Aufgabe 1 ===
Erzeugen Sie ein Dialogfenster mit einem Texteingabefeld und einem Button. Beim Klicken auf den Button soll der Eingabetext auf der Konsole ausgegeben werden. Das Dialogfenster soll also in etwa so aussehen:
[[Bild:octave_dialog105.jpg]]
Da dies etwas komplizierter als das oben gezeigte Beispiel ist, werden nachfolgend ein paar Codefragmente zwecks Lösung angegeben:
Datei button_callback.m:
function button_callback(editHandle)
eingegText = get(editHandle, "String");
disp(eingegText);
end
Codefragement in test1.m:
% ...
edit = uicontrol(% ...
"Style", "edit", ...
%, ...
"HorizontalAlignment", "left");
btn = uicontrol(% ...
"Callback", @(src, event) button_callback(edit));
% ...
Aufruf mit:
octave test1.m
Eingabe von z.B. "Hallo Welt!":
[[Bild:octave_dialog106.jpg]]
Ausgabe auf der Konsole nach dem Drücken des Buttons:
Hallo Welt!
=== Aufgabe 2 ===
Erzeugen Sie ein Dialogfenster mit zwei Eingabefeldern und einem Button. Eingegeben in diese zwei Eingabefelder werden vom Benutzer Zahlen. Auf der Konsole ausgegeben werden soll, nach Drücken des Buttons, das Produkt dieser zwei Zahlen.
Auch hier werden wieder Codefragemente angegeben.
Datei button_callback.m:
function button_callback(edit1, edit2)
zahl1 = str2double(get(edit1, 'String'));
zahl2 = str2double(get(edit2, 'String'));
disp(zahl1 * zahl2);
end
Codefragment Datei test1.m:
% ...
btn = uicontrol("Parent", d, ...
% ...
"Callback", @(src, event) button_callback(edit1, edit2));
% ...
Was passiert, wenn der Benutzer keine Zahlen, sondern beliebige Strings eingibt?
= Fehlerhandling mit try/catch =
Die try/catch-Anweisung entspricht weitgehend jener, die aus höheren Programmiersprachen wie C++ oder Java bekannt sind. Aufgebaut ist diese Anweisungsfolge so:
try
BODY
catch
CLEANUP
end
Beispiel:
clear;
close all;
clc;
try
a = 10 / "zahl";
disp(a);
disp("Weiter im try-Block");
catch
disp("Catch: Kann nicht durch einen String dividieren");
end
Ausgabe:
Catch: Kann nicht durch einen String dividieren
Sinnvoll ist die try/catch-Folge, wenn z.B. auch in einem Fehlerfall Dateien wieder geschlossen werden sollen.
= Ein- und Ausgabe =
== Formatierte Ausgabe am Bildschirm, formatiertes Lesen von der Tastatur ==
Folgendes Beispiel ist der Octave-Hilfe (von Octave 3.0.3) entnommen:
pct = 37;
filename = "foo.txt";
printf ("Processed %d%% of `%s'.\nPlease be patient.\n", pct, filename);
Ausgabe:
Processed 37% of `foo.txt'.
Please be patient.
"printf" gibt einen formatierten String am Bildschirm (genauer in den Stream stdout) aus. Wie man sieht, orientiert sich das Format an der Programmiersprache C.
Für das formatierte Lesen vom Stream stdin (normalerweise also von der Tastatur) steht das Pendant "scanf" bereit.
== Von einem String lesen bzw. in einen String schreiben ==
Bezüglich der Funktionen
* sprintf
und
* sscanf
sei auf die Octave-Hilfefunktion verwiesen.
== Lesen und Schreiben von einer Datei ==
=== Datei schreiben ===
% Datei c:\tmp\datei.test zum Schreiben öffnen
datei = fopen ("c:/tmp/datei.test", "w");
% Etwas in die Datei schreiben
fprintf(datei, "Hallo, Welt!");
% Datei schließen
fclose(datei);
=== Datei lesen ===
% Datei c:\tmp\datei.test zum Lesen öffnen
datei = fopen ("c:/tmp/datei.test", "r");
% Etwas aus der Datei lesen
[string] = fscanf(datei, "%s");
disp(string);
% Datei schließen
fclose(datei);
Ausgabe:
Hallo,Welt!
=== Dateiende prüfen ===
Mittels des Befehls
feof(FID);
kann das Dateiende geprüft werden. Wenn die EOF-Bedingung zutrifft, dann wird 1 zurückgegeben, wenn nicht dann 0. Ein Beispiel folgt später als Lösung einer Aufgabe.
=== warning und error ===
Eine Warnung kann man am stderr-Stream ausgeben. Die warning-Funktion entspricht ansonsten der printf-Funktion. Nach Ausgabe der Warnung wird das Programm normal fortgesetzt.
m = [1 2
3 6];
if(det(m) == 0)
warning("Matrix ist singulaer");
end
disp("Weiter geht's");
Ausgabe:
warning: Matrix ist singulaer
warning: called from
test1 at line 5 column 3
Weiter geht's
Schärfer ist der error-Befehl. Die Fehlermeldung wird am stderr-Stream ausgegeben. Vom Format her entspricht diese Funktion dem printf-Befehl. Nach Ausgabe der Fehlermeldung wird das Programm beendet.
m = [1 2
3 6];
if(det(m) == 0)
error("Matrix ist singulaer");
end
disp("Weiter geht's");
Ausgabe:
error: Matrix ist singulaer
error: called from
test1 at line 5 column 3
== Aufgaben ==
* Schreiben Sie ein Programm, das die Zahlen 1 bis 10 zeilenweise in eine Datei ausgibt.
* Lesen Sie diese Zeilen wieder von der Datei ein und geben Sie sie am Bildschirm aus.
* Gegeben sei eine Datei. Lesen Sie die Daten aus dieser Datei ein und rechnen Sie per Octave-Programm den Gesamtpreis für alle Tiere aus. Die Anzahl der Zeilen und der genaue Dateinhalt sei Ihnen vorab nicht bekannt. Bekannt ist nur das Datenformat wie folgt:
Nr. Name Einzelpreis Stueck
1 Affe 15000.50 2
2 Loewe 11000.90 1
3 Nashorn 45000.10 1
4 Elefant 51245.90 3
5 Tiger 9000.70 2
6 Maus 34.90 12
Eine einfache Lösung ohne Schnickschnack (Fehlerüberprüfungen etc.) für dieses Beispiel könnte wie folgt aussehen:
clear;
close all;
clc;
datei = fopen ("c:/tmp/daten1.txt", "r");
gesamtpreis = 0;
% Kopfzeile einlesen
[nr, name, preis, stk] = fscanf(datei, "%s %s %s %s", "C");
while(feof(datei) == 0)
% Datensätze einlesen
[nr, name, preis, stk] = fscanf(datei, "%d %s %f %d", "C");
gesamtpreis += preis*stk;
end
fclose(datei);
disp("Gesamtpreis = ");
format long;
disp(gesamtpreis);
Ausgabe:
Gesamtpreis =
258159.900000000
= Datencontainer =
== Datenstrukturen ==
Pseudocode:
STRUKTUR s
ZAHL a
VEKTOR b
STRING c
END
Octave-Code:
s.a = 45.9;
s.b = [1 2 3 4 5];
s.c = "Hallo!";
s
Ausgabe:
s =
scalar structure containing the fields:
a = 45.90000000000000
b =
1 2 3 4 5
c = Hallo!
Um ein paar weitere Möglichkeiten zum Handling mit Datenstrukturen aufzuzeigen, sei folgender Code aufgeführt.
Datei addsub.m
function res = addsub(a, b)
res.x = a + b;
res.y = a - b;
end
Datei test1.m
clear;
clc;
addsub(10, 50)
r = addsub(30, 70)
r.x
r.y
++r.x
Ausgabe:
ans =
scalar structure containing the fields:
x = 60
y = -40
r =
scalar structure containing the fields:
x = 100
y = -40
ans = 100
ans = -40
ans = 101
Die Funktion "addsub" liefert die Struktur res mit zwei Zahlenwerten. Die Elemente der Datenstruktur können auch außerhalb der Funktion angesprochen werden. Auch gerechnet werden kann mit diesen Elementen.
== Cell Arrays ==
Manchmal kann es sinnvoll sein mehrere Variablen verschiedenen Typs und Größe in einer Variablen zu speichern. Dies funktioniert ähnlich wie bei Vektoren. Es werden aber geschweifte Klammern verwendet.
Eingabe:
c = {"Hallo Welt!", [2 2], 44}
c{1}
c{1:2}
Ausgabe:
c =
{
[1,1] = Hallo Welt!
[1,2] =
2 2
[1,3] = 44
}
ans = Hallo Welt!
ans = Hallo Welt!
ans =
2 2
Elemente des Cell Arrays können auch wieder mit Variablen anderen Typs überschrieben werden.
c = {"Hallo Welt!", [2 2], 44};
c{1} = 5;
c
Ausgabe:
c =
{
[1,1] = 5
[1,2] =
2 2
[1,3] = 44
}
= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}
* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse "erbt" Attribute und Methoden von der Superklasse. Octave unterstützt (so wie C++ und Python, aber im Gegensatz zu Java) Mehrfachvererbung.
== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.
[[File:UmlCd Klasse-3.svg|300px]]
* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private (privat)
** # ... protected (geschützt)
* Vererbung:
<gallery>
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
</gallery>
Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0
== Klassen und Vererbung ==
Octave unterstützt auch objektorientierte Programmierung mit dem Schlüsselwort <code>classdef</code> (ab Version 4.0). Dieses Thema ist zwar etwas fortgeschritten, wird aber trotzdem kurz behandelt.
[[Bild:octave_oop1.svg|200px]]
Datei Auto.m:
classdef Auto
properties
marke1 = "Beemweh"
endproperties
methods
function zeige1(obj)
disp(["Marke: ", obj.marke1]);
endfunction
endmethods
endclassdef
Datei Cabrio.m:
classdef Cabrio < Auto
properties
marke2 = "Cabrio"
endproperties
methods
function zeige2(obj)
disp(["Marke: ", obj.marke2]);
endfunction
endmethods
endclassdef
Datei test1.m:
obj = Cabrio();
obj.zeige1();
obj.zeige2();
Ausgabe (Aufruf mittels "octave test1.m"):
Marke: Beemweh
Marke: Cabrio
GNU Octave kann auch Mehrfachvererbung:
[[Bild:octave_oop2.svg|200px]]
classdef Unterklasse < Oberklasse1 & Oberklasse2
Für die Reihenfolge der Vererbung gilt: Die zuerst genannte Klasse hat Vorrang.
Man kann mittels <code>private, protected, public</code> Daten auch kapseln:
properties(SetAccess = private, GetAccess = public)
methods (Access = public)
Standardmäßig sind alle Methoden und Attribute <code>public</code>.
Weiterführendes siehe z.B. in der [https://docs.octave.org/latest/Object-Oriented-Programming.html Octave-Dokumentation].
= Octave im Zusammenspiel mit anderen Programmiersprachen =
Man kann GNU Octave zur Kommunikation mit anderen Programmiersprachen bewegen, und das in beide Richtungen:
* GNU Octave -> andere Programmiersprache
* andere Programmiersprache -> GNU Octave
Hier die ganzen Möglichkeiten detailliert zu beschreiben würde zu weit führen. Wir beschränken uns im Wesentlichen auf die Erstellung von .oct-Files (C/C++; Fortran würde auch gehen, ist aber komplizierter) und zählen im Anschluss daran ein paar weitere Varianten auf.
== .oct-Dateien ==
Eine .oct-Datei in GNU Octave ist eine kompilierte C/C++-Datei, die als dynamisch ladbares Objekt direkt in Octave ausgeführt werden kann. oct-Dateien sind meist schneller als nativer Octave-Code.
1. Schritt: Erstelle z.B. eine C++-Datei ''quadrat.cc'' (es soll das Quadrat einer Zahl berechnet werden)
#include <octave/oct.h>
DEFUN_DLD(quadrat, args, nargout, "Quadrat einer Zahl berechnen")
{
double x = args(0).double_value();
double res = x*x;
return octave_value(res);
}
* <code>DEFUN_DLD</code> ist ein Makro. Damit wird angezeigt, dass es sich um eine dynamisch ladbare Funktion handelt ('''De'''fine '''Fun'''ction – '''D'''ynamically '''L'''inked '''D'''istribution).
* Der erste Parameter muss mit dem Namen der Funktion und der erstellten oct-Datei übereinstimmen, also hier <code>quadrat</code>.
* <code>args</code>: Argumente die beim Aufruf in Octave übergeben werden.
* <code>nargout</code>: Anzahl der Rückgabewerte.
* "Quadrat einer Zahl berechnen": Dokumentationsstring
2. Schritt: ''quadrat.cc'' kompilieren
# Terminal öffnen
# In das quadrat.cc-Verzeichnis wechseln
# Octave aufrufen
# cc-Datei zu einer oct-Datei kompilieren: <code>mkoctfile quadrat.cc</code>
# Wenn das ohne Fehlermeldung durchläuft, so sollte im Anschluss eine (relativ große) ''quadrat.oct''-Datei im entsprechenden Verzeichnis zu finden sein.
3. Schritt: Funktion <code>quadrat()</code> in Octave aufrufen, z.B.:
y = quadrat(5)
Es ergibt sich folgende Ausgabe:
y = 25
Damit das funktioniert, müssen natürlich die entsprechenden Werkzeuge (Compiler etc.) installiert sein. Darauf wird hier aber nicht näher eingegangen.
Die Dokumentation zu den .oct-Dateien findet sich auf [https://docs.octave.org/v11.1.0/Oct_002dFiles.html].
== Andere Möglichkeiten ==
* .mex-Dateien ('''M'''ATLAB '''Ex'''ecutables): Wenn man kompatibel zu MATLAB bleiben muss
* Java- oder Python-Schnittstelle (Nachteil: langsamer als .oct-Dateien)
Bevor man aber diese Möglichkeiten in Anspruch nimmt, sollte man vektorisieren. Damit lassen sich oft schon höhere Geschwindigkeiten erzielen. Dieses Thema wurde früher schon kurz behandelt ([[Ing_Mathematik:_Numerische_Mathematiksysteme_am_Beispiel_von_Octave#Die_FOR-Schleife|FOR-Schleife]]).
= Octave und die Tabellenkalkulation =
== Lesen ==
GNU Octave kann auch CSV-, LibreOffice Calc- oder MS Excel-Dateien einlesen.
Gegeben sei folgende schematisierte Datei im LibreOffice Calc-Format (test1.ods):
Februar März
Freitag 23 26
Samstag 17 41
Sonntag 34 37
=== Direkt als ODS-Datei einlesen ===
Die odsread-Funktion muss via io-Package geladen werden. Dieses Package ist nicht standardmäßig installiert, sondern kann z.B. bei openSUSE Tumbleweed mittels YaST als octave-forge-io installiert werden. Danach wird das Package geladen (pkg load io) und die Daten mittels odsread eingelesen.
pkg load io
[num, txt, raw] = odsread('test1.ods');
disp(num)
disp("------------")
disp(txt);
disp("------------")
disp(raw);
Ausgabe:
23 26
17 41
34 37
------------
{
[1,1] =
[2,1] = Freitag
[3,1] = Samstag
[4,1] = Sonntag
[1,2] = Februar
[2,2] =
[3,2] =
[4,2] =
[1,3] = März
[2,3] =
[3,3] =
[4,3] =
}
------------
{
[1,1] = [](0x0)
[2,1] = Freitag
[3,1] = Samstag
[4,1] = Sonntag
[1,2] = Februar
[2,2] = 23
[3,2] = 17
[4,2] = 34
[1,3] = März
[2,3] = 26
[3,3] = 41
[4,3] = 37
}
=== Als CSV-Datei einlesen ===
Die Datei test1.ods wird per LibreOffice Calc als CSV-Datei test1.csv (Trennzeichen ist der Strichpunkt) gespeichert (Achtung: gespeichert, nicht exportiert!):
;Februar;März
Freitag;23;26
Samstag;17;41
Sonntag;34;37
==== Mit csv2cell ====
Wir wollen hier den Strichpunkt als Trennzeichen verwenden. Per Default wird nämlich der Beistrich als Trennzeichen interpretiert.
pkg load io;
data = csv2cell("test1.csv", ";");
disp(data);
disp("---------------");
disp(data{2, 2});
Ausgabe:
{
[1,1] =
[2,1] = Freitag
[3,1] = Samstag
[4,1] = Sonntag
[1,2] = Februar
[2,2] = 23
[3,2] = 17
[4,2] = 34
[1,3] = März
[2,3] = 26
[3,3] = 41
[4,3] = 37
}
---------------
23
==== Mit dlmread ====
data = dlmread("test1.csv", ";");
disp(data);
disp("---------------");
disp(data(2, 2));
Ausgabe:
0 0 0
0 23 26
0 17 41
0 34 37
---------------
23
==== Mit importdata ====
data = importdata("test1.csv");
disp(data)
disp("------------")
disp(data.data);
disp("------------")
disp(data.data(2,2));
Ausgabe:
data =
23 26
17 41
34 37
textdata =
{
[1,1] = ;Februar;März
[2,1] = Freitag
[3,1] = Samstag
[4,1] = Sonntag
}
rowheaders =
{
[1,1] = Freitag
[2,1] = Samstag
[3,1] = Sonntag
}
------------
23 26
17 41
34 37
------------
41
Damit haben wir schon etliche Funktionen zu diesem Zweck kennengelernt. Weitere Funktionen zu
diesem Zweck sind z.B.
* csvread
* textscan
=== Als XLSX-Datei einlesen ===
Wir speichern unsere test1.ods-Datei als test1.xlsx-Datei. Dies ist das MS Excel-Standardformat. Und schon können wir den xlsread-Befehl zum Einlesen der Daten verwenden.
pkg load io
[num, txt, raw] = xlsread('test1.xlsx');
disp(num)
disp("------------")
disp(txt);
disp("------------")
disp(raw);
Die Ausgabe ist gleich wie oben bei der odsread-Funktion.
== Schreiben ==
=== Direkt als ODS-Datei schreiben ===
pkg load io
data = {
"", "Februar", "März";
"Freitag", 23, 26;
"Samstag", 17, 41;
"Sonntag", 34, 37
};
odswrite('test1.ods', data);
=== Als XLSX-Datei schreiben ===
pkg load io
data = {
"", "Februar", "März";
"Freitag", 23, 26;
"Samstag", 17, 41;
"Sonntag", 34, 37
};
xlswrite('test1.xlsx', data);
=== Als CSV-Datei schreiben ===
* dlmwrite
* csvwrite
* fprintf
= Octave GUI =
Das GUI-Programm ('''G'''raphical '''U'''ser '''I'''nterface) von Octave entspricht im Wesentlichen anderen Programmier-Benutzeroberflächen (IDEs ... '''I'''ntegrated '''D'''evelopment '''E'''nvironments), wie z.B. Eclipse (Java), Code::Blocks (C/C++) oder Spyder (Python). Nachfolgend ist ein Screenshot des Octave-GUI mit einigen Anmerkungen dargestellt.
[[Bild:octave_gui2.jpg|600px]]
Probieren Sie einfach die Möglichkeiten der zur Verfügung gestellten GUI/IDE aus.
= Komplexere Aufgaben =
* Berechnen Sie die Fläche, den Umfang, die Seitenlängen, den Inkreis und den Umkreis eines Dreiecks. Stellen Sie das Dreieck inklusive In- und Umkreis grafisch dar. Speichern Sie die Daten in einer Datei. Die drei Eckpunkte dieses Dreiecks sollen vom Benutzer beliebig vorgegeben werden.
* Die Werte einer beliebig großen quadratischen Matrix seien in einer Datei gespeichert. Lesen Sie diese Datei ein und berechnen Sie daraus die Determinante der Matrix, die inverse Matrix, die Eigenvektoren und -werte, die Spur. Führen Sie die LR-Zerlegung durch. Geben Sie diese Werte am Bildschirm aus.
= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Octave. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechende weiterführende Literatur, die Octave-Hilfefunktion und die Octave-Dokumentation verwiesen. Octave kennt noch viel mehr Befehle, als hier dargestellt wurden. Aber auch Octave selbst ist erweiterbar. Man siehe z.B. Octave Packages (https://gnu-octave.github.io/packages/) oder man schreibt selbst Erweiterungen.
{{Navigation_zurückhochvor_buch|
zurücktext=Maxima|
zurücklink=Ing Mathematik: Computeralgebrasysteme am Beispiel von Maxima|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Julia für Ingenieure|
vorlink=Ing Mathematik: Julia}}
ivinnpqfyyqdu07cqjbiny58jxvydln
Ing Mathematik: Julia
0
117895
1092407
1091125
2026-10-24T06:51:57Z
Intruder
1513
/* Linux */ Unter YaST gibt es neuerdings kein juliaup mehr -> entsprechenden Satz gelöscht
1092407
wikitext
text/x-wiki
{{Navigation_zurückhochvor_buch|
zurücktext=Octave|
zurücklink=Ing Mathematik: Numerische Mathematiksysteme am Beispiel von Octave|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Python für Ingenieure|
vorlink=Ing Mathematik: Python}}
= Hallo Welt und allgemeine Hinweise =
== Was ist Julia ==
* Julia ist eine höhere Programmiersprache, die vor allem für numerisches und wissenschaftliches Rechnen entwickelt wurde.
* Julia ist Open-Source (MIT-Lizenz).
* Julia ist schnell (JIT-Compiler).
* Julia ist für wichtige Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Julia als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
{{Wikipedia | Julia (Programmiersprache)}}
== Julia installieren ==
=== MS Windows ===
Laden Sie das aktuelle Julia-Paket von der Webseite [https://julialang.org/downloads/] herunter (Manual Downloads). Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen. Alternativ können Sie auch den "MSIX App Installer" verwenden, siehe die genannte Download-Seite.
=== Linux ===
Den Install-Button auf der Seite [https://julialang.org/] anklicken und den Anweisungen folgen (<code>curl ...</code>). Das Programm wird dann automatisch installiert.
== Julia starten ==
=== MS Windows ===
Das Icon für das Julia-Programm doppelklicken. Und schon startet das Programm.
[[Datei:juliastart1.jpg]]
Das Julia-System präsentiert sich dann folgendermaßen (interaktives Kommandozeilenprogramm REPL [Read–eval–print loop]):
[[Datei:Julia1.0.jpg|500px]]
=== Linux ===
Einfach <code>julia</code> in einer Konsole eintippen und mit der <code>Return</code>-Taste abschließen. Dies startet die Julia-REPL.
Es gibt auch noch andere Möglichkeiten Julia zwecks Programmausführung zu starten, z. B. den {{W|Shebang}} (<code>#!</code>) am Beginn eines Julia-Scripts. Das Script sei als Script.py gespeichert. Dann kann das Script mit ./Script.py ausgeführt werden. Für openSUSE Tumbleweed sei nachfolgend ein lauffähiges "Hallo Welt!"-Script angegeben.
#!/usr/bin/julia
println("Hallo Welt!")
Die Berechtigungen zum Ausführen der Datei müssen natürlich noch richtig gesetzt werden, z.B. mittels <code>chmod 777 Script.py</code>. <small>Die "Maske" <code>777</code> ist nur für Testzwecke sinnvoll, weil sie leicht zu merken ist und für alle Benutzer alle Zugriffsberechtigungen ('''r'''ead/'''w'''rite/e'''x'''ecute für owner/group/others) setzt. Im richtigen Einsatz wird man das aus Sicherheitsgründen nicht so handhaben, sondern nur die Berechtigungen setzen, die unbedingt erforderlich sind.</small>
== Ein paar Worte zur Erklärung ==
=== Tests ===
Getestet wurden die Beispiele unter den Betriebssystemen
* MS Windows 10 mit den Julia-Versionen 1.9.4 und 1.10.2 (bis Ende 2024).
* openSUSE Leap 15.6 mit der Julia-Version 1.11.6 (im Juli 2025, nur vereinzelt).
* openSUSE Tumbleweed ab der Julia-Version 1.12.5 (ab März 2026, nur vereinzelt).
=== Popularität ===
* An Beliebtheit rangiert Julia mit Stand September 2026 mit einem Rating von 0,74% an 21. Stelle der beliebtesten Programmiersprachen ([https://www.tiobe.com/tiobe-index/ lt. TPCI - TIOBE Programming Community Index]).
* Lt. [https://pypl.github.io/PYPL.html PYPL] (PopularitY of Programming Language) liegt Julia auf dem 21. Platz (0,45%; Stand: September 2026).
== Ein erstes Programm ==
Kommentare werden in Julia mit der Raute (#) eingeleitet. Sie werden vom Julia-Interpreter ignoriert. Text kann mit der print- oder println-Funktion ausgegeben werden. Starten Sie Julia und geben sie folgende Anweisungen zeilenweise ein (die Anweisungen sind jeweils mit der Return-Taste abzuschließen)
julia> # Das ist ein Kommentar
julia> print("Hallo Welt!")
Als Ergebnis erhalten Sie
Hallo Welt!
Der Prompt (julia>) ist selbstverständlich nicht einzutippen, sondern wird vom Julia-System geliefert.
Strings sind in Julia in Anführungszeichen (") zu setzen. Zwischen dem Befehl print und der öffnenden Klammer ( darf kein Leerzeichen gesetzt werden.
= Julia als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Julia. Geben Sie dann die Formel
julia> 3 * 5
ein, drücken die Taste ENTER/RETURN und erhalten als Ergebnis
15
Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck <math>\sin\sqrt{15}</math> berechnen :
julia> sin(sqrt(15))
-0.6679052983383519
Mit dieser Zahl kann unmittelbar weitergerechnet werden, z.B.
julia> ans * 2
-1.3358105966767038
"ans" steht übrigens für den Begriff "answer" (auf Deutsch "Antwort").
Das Mal-Zeichen (*) kann übrigens eingespart werden. <code>ans * 2</code> ist dasselbe wie <code>2ans</code>. Man beachte aber, dass in der Kurzform kein Leerzeichen zwischen 2 und ans stehen darf.
Beenden lässt sich das Julia-Programm durch Eingabe von exit() (und natürlich ist zur Bestätigung die RETURN-Taste zu drücken). Beachten Sie wieder, dass zwischen der Funktion exit und der öffnenden Klammer kein Leerzeichen stehen darf.
== Die Hilfefunktion von Julia ==
Bei Eingabe eines Fragezeichens (?) springt Julia in das Hilfesystem.
Eingabe:
?
Eingabe:
help?> sin
Ausgabe:
sin
search: sin sinh sind sinc sinpi sincos sincosd sincospi asin using isinf asinh asind isinteger isinteractive thisind
sin(x)
Compute sine of x, where x is in radians.
See also sind, sinpi, sincos, cis, asin.
Examples
≡≡≡≡≡≡≡≡≡≡
julia> round.(sin.(range(0, 2pi, length=9)'), digits=3)
...
...
...
0.454649 0.454649
Für die komplette Julia-Dokumentation siehe [https://docs.julialang.org/en/v1/].
== Aufgaben ==
* Erkunden Sie die Tangensfunktion "tan" mittels Julia-Hilfe.
* Berechnen Sie mit Julia den Ausdruck <math>\frac{1}{2}\cdot e^2 \cdot \tan(\pi/3)</math>. Siehe für die Exponentialfunktion im Julia-Hilfesystem auch den Befehl exp(). Potenzieren kann man bei Julia mit dem ^-Operator (z.B. 2^3 = 8)
* Berechnen Sie mit Julia den Ausdruck <math>2\text{cosd}(60) - 3\sin(\pi/5)</math>. Anmerkung: cosd erwartet den Parameter im Gradmaß (d für "degree"), sin erwartet den Parameter im Bogenmaß.
= Julia als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.jl
# Das ist ein Kommentar
print("Hallo Welt!")
Julia-Dateien werden mit der Dateiendung .jl versehen.
Danach bringen Sie die Skriptdatei test1.jl (sozusagen das Hauptprogramm) folgendermaßen zur Ausführung:
1) Starten Sie unter MS Windows die Eingabeaufforderung (oder alternativ die Windows PowerShell). Das sieht dann etwa so aus:
Microsoft Windows [Version 10.0.19045.3693]
(c) Microsoft Corporation. Alle Rechte vorbehalten.
C:\Users\xyz>
: <small>Falls jemand nicht weiß, wie man die Eingabeaufforderung startet: Eine Möglichkeit ist, einfach in der Taskleiste von Windows das "Start"-Symbol mit der rechten Maustaste anklicken. "Ausführen" auswählen (oder alternativ für die PowerShell den Eintrag "Windows PowerShell"). Im sich öffnenden Dialogfenster gibt man in die "Öffnen"-Zeile das Wort <code>cmd</code> ein und mit "OK" wird das Ganze bestätigt.</small>
2) Wechseln Sie mittels <code>cd c:\tmp</code> in das Verzeichnis c:\tmp
3) Angenommen, Sie haben Julia unter dem Pfad <code>c:\devel\Julia-1.9.4\</code> installiert. Starten Sie das Programm so (der Prompt <code>c:\tmp></code>ist natürlich nicht mit einzutippen):
c:\tmp>c:\devel\Julia-1.9.4\bin\julia.exe test1.jl
4) Wie erwartet ergibt sich folgende Ausgabe am Bildschirm
Hallo Welt!
Die Vorgehensweise unter Linux ist sehr ähnlich, wird hier deshalb nicht noch mal gezeigt.
== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9), Underscores (_) und etlichen Unicode-Zeichen bestehen, dürfen aber nicht mit einer Zahl beginnen.
Gültige Variablenbezeichner wären also:
xyz
x1
_wert
name_anzahl
a₂
γπΩ
Wie kann man eigentlich die griechischen Zeichen im vorhergehenden Beispiel eingeben? Auf einer deutschen oder englischen Tastatur sind sie jedenfalls nicht zu finden. Des Rätsels Lösung kann folgendermaßen aussehen (wird am Beispiel des Omega-Zeichens (Ω) vorgeführt):
1) Starten Sie das Julia-System (z.B. mittels Doppelklick auf das Julia-Icon oder in der Eingabeaufforderung durch direkte Eingabe von julia.exe (ggf. mit dem entsprechenden Programmpfad).
2) geben Sie <code>\Omega</code> ein (ohne den Befehl mit Return abzuschließen)
julia> \Omega
3 Tippen Sie auf die Tabulatortaste und schon erscheint das Ω.
4) Dieses Zeichen können Sie dann mittels Zwischenablage z.B. auch in eine jl.-Datei einfügen (ggf. unter Verwendung eines geeigneten Text-Editors, z.B. Geany oder unter Linux auch Kate)
Ähnliches gilt für tiefgestellte Indizes, z.B. <code>a\_2</code> gefolgt von einem Tabulator ergibt a₂.
Da Julia case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
xyz
XYZ
xYz
Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code unter MS Windows immer in der Datei <code>c:\tmp\test1.jl</code> oder unter Linux z.B. unter <code>~/tmp/test1.jl</code> gespeichert.
x = 5
y = 10
z = x*y
print(z)
Bringen Sie die Datei test1.jl zur Ausführung, so erhalten Sie folgende Bildschirmausgabe
50
Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben.
x = 5; y = 10; z = x*y
print(z)
Ausgabe:
50
Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
x = 5;
println(x)
# x = x - 2
x -= 2
println(x)
Bildschirmausgabe:
5
3
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist.
Die Verwendung von Prä-/Postfix-Operatoren (++, --) wie unter C/C++ oder Java ist in Julia nicht erlaubt, sondern liefert nur eine Fehlermeldung.
Soll eine Anweisung auf mehrere Zeilen verteilt werden, z.B. weil sie zu lang ist, so kann dies geschehen, wie nachfolgend dargestellt.
x = 5;
y = 1000 * x +
sin(x/2)
print(y)
Ausgabe:
5000.598472144104
Beachten Sie, dass die Zeilentrennung nach einem Operator erfolgt! Folgendes würde ein falsches Resultat liefern:
x = 5;
y = 1000 * x
+ sin(x/2)
print(y)
Ausgabe:
5000
Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist mit Julia problemlos möglich:
wert = 10
println(wert)
wert = 35.5
println(wert)
wert = "Hallo"
println(wert)
wert = pi
println(wert)
Ausgabe:
10
35.5
Hallo
π
==Hexadezimale, oktale und binäre Zahlen==
# Hexadezimale Zahl
println(0xABC)
# Oktale Zahl
println(0o56)
# Binäre Zahl
println( 0b1000011 )
Ausgabe (als Dezimalzahlen):
2748
46
67
Julia kann auch dezimale in binäre Zahlen etc. umwandeln:
Eingabe:
b = bitstring(30)
println(b)
Ausgabe:
0000000000000000000000000000000000000000000000000000000000011110
Ein anderes Beispiel (hexadezimal nach binär):
# hexadezimal -> binär
s = string(0xF, base=2)
print(s)
Ausgabe:
1111
== Verzweigungen ==
=== if ===
Die IF-Verzweigung ist aus anderen Programmiersprachen bereits bekannt. In Pseudocode lässt sie sich folgendermaßen darstellen:
WENN bedingung TRUE
führe block1 aus
SONST
führe block2 aus
ENDE
Die test1.jl-Datei laute also wie folgt:
x = 5;
if x < 4
println("x ist kleiner als 4");
else
println("Der else-Zweig wird ausgefuehrt");
println("x ist groesser oder gleich 4");
end
Ausgabe:
Der else-Zweig wird ausgefuehrt
x ist groesser oder gleich 4
Julia kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:
* <, <= ... kleiner (gleich)
* >, >= ... größer (gleich)
* == ... gleich
* != ... ungleich
* &, && ... AND
* |, || ... OR
Beispielsweise:
a = 5;
b = 9;
if a<=10 & b!=7
println("OK");
else
println("Nicht OK");
end
Ausgabe:
OK
Erweiterung der if-else-end-Verzweigung - ein Beispiel mit <code>elseif</code>:
a = 5
if a==10
println("OK")
elseif a==5
println("Nicht OK")
println("a = 5")
elseif a==6
println("Auch nicht OK")
else
println("Weiß nicht")
end
Ausgabe:
Nicht OK
a = 5
=== Ternärer Operator ===
Eingabedatei:
a = 5
a >= 6 ? println("größer gleich 6") : println("kleiner 6")
Ausgabe:
kleiner 6
== Schleifen ==
=== while ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert nicht ganz so wie aus anderen Programmiersprachen bekannt.
In Pseudocode:
SOLANGE bedingung TRUE
führe block aus
ENDE
In Julia:
x = 0
while x <= 10
println(x)
global x += 1
end
Ausgabe:
0
1
2
3
4
5
6
7
8
9
10
Außerhalb von Funktionen muss das Schlüsselwort <code>global</code> verwendet werden. Ansonsten gibt es eine Warnung und eine Fehlermeldung. Innerhalb einer Funktion benötigt man das <code>global</code> nicht.
=== for ===
for x = 0 : 2 : 10
println(x);
end
Ausgabe:
0
2
4
6
8
10
Der FOR-Schleifenkopf ist in Form einer Zahlenkolonne folgendermaßen aufgebaut:
for variable = startwert : schrittweite : endwert
Alternativ findet man in der Literatur auch folgende for-Schleifenaufbauten.
for x in 0 : 2 : 10
println(x);
end
for x ∈ 0 : 2 : 10
println(x);
end
Achtung: Das ∈ ist kein \epsilon, sondern ein \in.
Die unterschiedlichen for-Schleifen liefern jeweils das gleiche Ergebnis.
=== break und continue ===
Zum Abbrechen einer Schleife gibt es den Befehl "break".
for var = 0 : 1 : 100
println(var)
if var == 5
break;
end
end
Ausgabe:
0
1
2
3
4
5
"continue" setzt mit dem nächsten Schleifendurchlauf fort, z.B.
for var = 0 : 1 : 10
if var == 5
continue;
end
println(var);
end
Ausgabe:
0
1
2
3
4
6
7
8
9
10
== Eingabe via Tastatur ==
Datei c:\tmp\test1.jl:
print("Geben Sie eine Zahl ein: ")
# Einlesen als String
str = readline(stdin)
print("Die Zahl lautet ")
println(str)
# Umwandeln in einen Float
zahl = parse(Float64, str)
print("Die Zahl lautet ")
println(zahl)
Eingabe der Zahl via Tastatur:
67.8
Mit der RETURN-Taste bestätigen.
Ausgabe:
Die Zahl lautet 67.8
Die Zahl lautet 67.8
In diesem Fall wird, wie gezeigt, zweimal <code>Die Zahl lautet 67.8</code> ausgegeben. Gibt man aber z.B. <code>Eins</code> ein, so wird einmal <code>Die Zahl lautet Eins</code> ausgegeben. Das ist klar, da <code>Eins</code> ein gültiger String ist. Danach folgt aber eine Fehlermeldung, weil <code>Eins</code> nicht in eine Fließkommazahl umgewandelt werden kann.
= Grafiken zeichnen =
Es gibt in Julia mehrere Möglichkeiten Grafiken zu zeichnen. Hier wird eine Einführung in das Package Plots gegeben.
== Plots installieren ==
Im Julia-REPL die schließende eckige Klammer ] eintippen. Damit springt man in das Package-System, angezeigt wird das mit dem Prompt <code>(@v1.9) pkg></code>.
Das Plots-Package zum Julia-System hinzufügen:
(@v1.9) pkg> add Plots
Mit STRG-C kann das Package-System wieder verlassen werden.
== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall <math>x\in[-3,3]</math> gezeichnet werden. Der Programmcode lautet in der einfachsten Form:
using Plots
x = -3 : .1 : 3
y = cosh.(x)
p = plot(x, y)
gui()
while(true)
end
Ausgabe:
[[Datei:Julia_cosh.jpg]]
Der Code ist quasi selbsterklärend. Das Plots-Package wird importiert. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. "plot" ist der Zeichenbefehl. "gui" ist notwendig, um das Fenster mit der Grafik anzuzeigen. Es folgt eine Endlossschleife. Diese ist notwendig, weil das Fenster mit der Grafik sonst nur kurz aufblinkt und das Programm danach beendet wird. Das Gesagte gilt, wenn man die test1.jl-Datei direkt ausführt. Im REPL kann man sich den Befehl "gui" und die Endlosschleife sparen.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen.
Hinweise:
* Bis das Fenster mit dem cosh-Graphen erscheint, kann es einige Sekunden dauern.
* Beenden kann man die Endlosschleife, indem man STRG-C drückt (STRG ist die Steuerungs- oder Control-Taste)
* Beachten Sie den Punkt (.) bei der cosh-Funktion. Vergessen Sie diesen, so wird eine Fehlermeldung ausgegeben.
Ein etwas komplexeres Beispiel ist folgendes
using Plots
x = -3 : .1: 3
y = cosh.(x) + 2 .^x
plot(x,y)
gui()
while true
end
Man beachte die Punkte bei der Funktion y. Vergisst man die Punkte, dann erhält man eine Fehlermeldung. Weiters beachte man das Leerzeichen und die Position desselben bei 2 .^x. Setzt man das Leerzeichen an die falsche Stelle oder vergisst es ganz, so ist das auch ein Fehler.
Ausgabe:
[[Datei:Julia_cosh2.jpg]]
=== Graphen mehrerer Funktionen und weiteres ===
Mehrere Graphen lassen sich folgendermaßen in ein Fenster zeichnen (es werden auch Titel und Labels gesetzt):
using Plots
x = -3 : .1: 3
y1 = cosh.(x) + 2 .^x
y2 = sin.(x) .* cos.(x)
plot(x, [y1, y2], title="Screenshot", label=["cosh(x) + 2^x" "sin(x) + cos(x)"],
xlabel="x", ylabel="y")
gui()
while true
end
[[Bild:Julia_cosh14.jpg]]
Will man mehrere Graphen in ein Fenster zeichnen, aber nicht alles in einen plot-Befehl quetschen, so kann die "plot!"-Anweisung die Lösung des Problems sein. Auch die Linienstile sollen nun etwas individueller gestaltet werden:
using Plots
x = -3 : .1: 3
y1 = cosh.(x) + 2 .^x
y2 = sin.(x) .* cos.(x)
plot(x, y1, linestyle=:dot, label="cosh ...", linewidth=5)
plot!(x, y2, ls=:dot, label="sin ...", lw=3)
title!("Funktionsgraphen")
xlabel!("x")
ylabel!("y")
gui()
while true
end
[[Datei:Julia_cosh4.jpg]]
=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale <math>x = t \cos(t), y = t \sin(t)</math> im Intervall <math>[0, 6\pi]</math> gezeichnet werden.
using Plots
t = 0 : .1: 6*pi
x = t .* cos.(t)
y = t .* sin.(t)
plot(x, y, lw=5)
gui()
while true
end
[[Datei:Julia_spirale1.jpg]]
Der Graph erscheint in der obigen Darstellung verzerrt. Will man das nicht, so setze man das <code>aspect_ratio</code> auf <code>:equal</code>:
using Plots
t = 0 : .1: 6*pi
x = t .* cos.(t)
y = t .* sin.(t)
plot(x, y, lw=5, aspect_ratio = :equal)
gui()
while true
end
[[Datei:Julia_spirale2.jpg]]
=== Logarithmische Achsenskalierung ===
using Plots
f(x) = 10^x
p1 = plot(f, 1, 5, lw=2, title="kartesische Koordinaten")
p2 = plot(f, 1, 5, yscale=:log10, lw=2, title="Semilog")
p3 = plot(f, 1, 5, xscale=:log10, yscale=:log10, lw=2, title="LogLog")
plot(p1, p2, p3, layout=(3,1))
gui()
while true
end
Ausgabe:
[[Datei:Julia_log1.jpg]]
=== Aufgaben ===
* Zeichnen Sie die Strophoide <math>x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3</math>. Das Ganze sollte in etwa so aussehen wie folgende Grafik:
[[Datei:octave_strophoide.jpg]]
* Zeichnen Sie die verschlungene Hypozykloide <math>x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15</math>. Das Ganze sollte in etwa so aussehen wie folgende Grafik:
[[Datei:octave_hypozykloide.jpg]]
* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.
== 3D ==
=== Räumliche Kurven ===
Mittels "plot3d" lassen sich Raumkurven zeichnen.
using Plots
t = 0 : .1: 6*pi
x = t .* cos.(t)
y = t .* sin.(t)
z = t
plot3d(x, y, z)
gui()
while true
end
[[Datei:Julia_raumkurve1.jpg]]
=== Flächen ===
using Plots
x = 0 : .1 : 10;
y = 0 : .1 : 10;
z(x,y) = sin(x) + 3*cos(y);
surface(x,y,z)
gui()
while true
end
[[Datei:Julia_flaeche1.jpg]]
Das Ganze in Netzdarstellung läßt sich so programmieren:
using Plots
x = 0 : .5 : 10
y = 0 : .5 : 10
z(x,y) = sin(x) + 3*cos(y)
wireframe(x, y, z)
gui()
while true
end
[[Datei:Julia_flaeche2.jpg]]
Die Kameraposition lässt sich verändern:
using Plots
x = 0 : .1 : 10
y = 0 : .1 : 10
z(x,y) = sin(x) + 3*cos(y)
# Kamerawinkel in Grad (Azimut, Altitude)
surface(x,y,z, camera = (75, 60))
gui()
while true
end
[[Datei:Julia_flaeche_3.jpg]]
{{Wikipedia | Azimut}}
=== Höhenlinien ===
using Plots
x = 0 : .1 : 10
y = 0 : .1 : 10
z(x,y) = sin(x) + 3*cos(y)
contour(x,y,z)
gui()
while true
end
[[Datei:Julia_hoehenlinien.jpg]]
Etwas abgewandelt sind das so aus:
using Plots
x = 0 : .1 : 10
y = 0 : .1 : 10
z(x,y) = sin(x) + 3*cos(y)
contour(x, y, z, levels=10, clabels=true, cbar=false)
gui()
while true
end
[[Datei:Julia_hoehenlinien2.jpg]]
Und noch eine Variante sei gezeigt.
using Plots
x = 0 : .1 : 10
y = 0 : .1 : 10
z(x,y) = sin(x) + 3*cos(y)
contourf(x, y, z)
gui()
while true
end
[[Datei:Julia_hoehenlinien3.jpg]]
=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve <math>x = 2 \cdot \cosh(t)</math>, <math>y = 5 \cdot \sin(t)</math>, <math> z = t^{2} - t</math>, <math>0 \leq t \leq 3\pi</math>.
* Zeichnen Sie die Fläche <math>z = \log(x) + \cos(y)</math>.
== Animationen ==
using Plots
anim = Animation()
for i = 1:100
plt = plot(sin, 0, i*2pi/10, ylims = (-1., 1.), lab="")
frame(anim, plt)
end
gif(anim, "c:/tmp/Julia_anim1.gif",fps=10)
Dieses Programm schreibt ein animiertes {{W|GIF}} in die Datei <code>c:/tmp/Julia_anim1.gif</code>.
[[Datei:Julia_anim1.gif]]
= Vektoren und Matrizen =
== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein.
=== Spalten- und Zeilenvektoren ===
Starten Sie die Julia-REPL. Geben Sie folgenden Befehl ein, um einen Spaltenvektor zu erstellen:
julia> v1 = [1, 2, 3]
Ausgabe:
3-element Vector{Int64}:
1
2
3
Geben Sie folgenden Befehl ein, um einen Zeilenvektor (oder genauer eine 1x3-Matrix) zu erstellen:
julia> v1 = [1 2 3]
Ausgabe:
1×3 Matrix{Int64}:
1 2 3
=== Zugriff auf Vektorelemente ===
Nachfolgend seien Zugriffsmöglichkeiten auf die Vektorelemente erläutert.
Auf ein einzelnes Element kann via Index zugegriffen werden. Der Index startet bei 1:
v1 = [1, 2, 3]
println(v1[2])
Ausgabe:
2
Mehrere Elemente werden folgendermaßen angesprochen:
v1 = [1 2 4 8 16]
print(v1[3:4])
Ausgabe:
[4, 8]
Liefere den Teilvektor von einem gegebenen Index bis zum letzten Element:
v1 = [1 2 4 8 16]
print(v1[3:end])
Ausgabe:
[4, 8, 16]
=== Addition und Subtraktion von Vektoren ===
v1 = [1, 2, 3]
v2 = [5, 7, 9]
println(v1 + v2)
println(v1 - v2)
Ausgabe:
[6, 9, 12]
[-4, -5, -6]
=== Multiplikation mit Skalaren ===
faktor = 3;
v = [1, 2, 3];
println(v * faktor)
Ausgabe:
[3, 6, 9]
=== Skalarprodukt ===
Das Skalarprodukt ist bekanntermaßen als <math>v_1 \cdot v_2 = |v_1| |v_2| \cos(\angle(v_1, v_2))</math> definiert. In Julia sieht das so aus:
using LinearAlgebra
v1 = [1, 2, 3]
v2 = [2, 5, 10]
println(LinearAlgebra.dot(v1, v2))
Ausgabe:
42
Hinweis: Wenn das LinearAlgebra-Paket noch nicht installiert ist, so muss dies eventuell nachgeholt werden. Wie das prinzipiell funktioniert, wurde im Kapitel "Grafiken zeichnen" am Beispiel des Plots-Pakets vorgeführt.
=== Vektorprodukt ===
<math>a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
</math>
Julia-Code:
using LinearAlgebra
v1 = [1, 2, 3]
v2 = [2, 5, 10]
println(LinearAlgebra.cross(v1, v2))
Ausgabe:
[5, -4, 1]
=== Transponierter Vektor ===
using LinearAlgebra
v = [1, 2, 3]
println(LinearAlgebra.transpose(v))
Ausgabe:
[1 2 3]
=== Einige weitere Vektorfunktionen ===
Die euklidische Norm <math>\|x\|_2 = \sqrt{x_1^2 + x_2^2 + \ldots + x_n^2}</math> in Julia:
using LinearAlgebra
v = [1 2 3]
println(norm(v))
Ausgabe:
3.7416573867739413
Beispiel:
# 1 + 2 + 3
v = [1 2 3]
println(sum(v))
Ausgabe:
6
Beispiel:
# 1 * 2 * 3 * 4
v = [1 2 3 4]
println(prod(v))
Ausgabe:
24
== Matrizen ==
Starten Sie die Julia-REPL. Geben Sie folgenden Befehl ein, um eine 2x3-Matrix zu erstellen:
julia> [1 2 3; 4 5 6]
Ausgabe:
2×3 Matrix{Int64}:
1 2 3
4 5 6
Damit verlassen wir die Julia-REPL wieder und arbeiten im Folgenden mit der test1.jl-Datei weiter.
=== Zugriff auf Matrizenelemente ===
m = [1 2 3; 4 5 6]
# Element aus Zeile 2 und Spalte 3
println(m[2,3])
Ausgabe:
6
Eine andere Zugriffsmöglichkeit ist diese:
m = [1 2 3; 4 5 6]
# Auf das Element an Position 5 soll zugegriffen werden
println(m[5])
Ausgabe:
3
Die Matrix wird also spaltenweise durchlaufen (nicht zeilenweise). Dies ist vielleicht auf den ersten Blick etwas ungewöhnlich, wird aber z.B. auch in Fortran oder Octave so gehandhabt.
[[Datei:Julia_matrix1.svg]]
=== Addition und Subtraktion von Matrizen ===
m1 = [1 2 3; 4 5 6]
m2 = [-4 -2 0; 2 4 6]
println(m1 + m2)
println(m1 - m2)
Ausgabe:
[-3 0 3; 6 9 12]
[5 4 3; 2 1 0]
=== Transponierte Matrix ===
m = [1 2 3; 4 5 6]
println(m')
Ausgabe:
[1 4; 2 5; 3 6]
=== Rang einer Matrix ===
using LinearAlgebra
m1 = [1 2 3; 4 5 6]
m2 = [1 2 3; 2 4 6]
println(LinearAlgebra.rank(m1))
println(LinearAlgebra.rank(m2))
Ausgabe:
2
1
=== Inverse Matrix ===
using LinearAlgebra
m = [1 3; 0 -5 ]
println(LinearAlgebra.inv(m))
Ausgabe:
[1.0 0.6000000000000001; 0.0 -0.2]
=== Determinate einer Matrix ===
using LinearAlgebra
m1 = [1 3; 0 -5 ]
m2 = [1 2; 2 4]
println(LinearAlgebra.det(m1))
println(LinearAlgebra.det(m2))
Ausgabe:
-5.0
0.0
m1 ist regulär, m2 ist singulär. Determinanten können nur von quadratischen Matrizen gebildet werden.
=== Multiplikation von Matrizen (falksches Schema) ===
m1 = [1 3 4; 0 -5 1]
m2 = [1 2; 2 3; 0 2]
println(m1 * m2)
Ausgabe:
[7 19; -10 -13]
=== Teilmatrizen ===
m = [1 2 3; 0 5 1]
# Die Matrix in einen Spaltenvektor umwandeln
println(m[:])
# Das Element aus der 1. Zeile und der 2. Spalte extrahieren
println(m[1,2])
# Erste Zeile extrahieren
println(m[1, 1:3])
println(m[1, :])
# Zweite Spalte extrahieren
println(m[1:2, 2])
println(m[:, 2])
Ausgabe:
[1, 0, 2, 5, 3, 1]
2
[1, 2, 3]
[1, 2, 3]
[2, 5]
[2, 5]
=== Eigenwerte und Eigenvektoren ===
using LinearAlgebra
A = [5 8; 1 3]
# Eigenvektoren und Eigenwerte
println(eigvals(A))
println(eigvecs(A))
Ausgabe:
[1.0, 7.0]
[-0.8944271909999159 0.9701425001453319; 0.447213595499958 0.24253562503633297]
=== LR-Zerlegung einer Matrix ===
Führen Sie die LR-Faktorisierung (LR ... links/rechts bzw. LU ... left/upper) einer Matrix m aus. Dazu springen wir wieder in die REPL und geben folgende Befehle ein:
julia> using LinearAlgebra
julia> m=[1 0 5; -1 1 -2; 0 0 3]
3×3 Matrix{Int64}:
1 0 5
-1 1 -2
0 0 3
julia> f = factorize(m)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
3×3 Matrix{Float64}:
1.0 0.0 0.0
-1.0 1.0 0.0
0.0 0.0 1.0
U factor:
3×3 Matrix{Float64}:
1.0 0.0 5.0
0.0 1.0 3.0
0.0 0.0 3.0
=== Schwach besetzte Matrizen ===
In der Technik treten häufig große Matrizen auf, die aber nur relativ wenige von Null verschiedene Werte mit Bandstruktur besitzen. Für diese ist es ineffizient, alle Matrizenelemente zu speichern. Effizienter ist es, nur die von Null verschiedenen Elemente zu speichern. Zu diesem Zwecke gibt es das <code>SparseArrays</code>-Paket.
julia> using SparseArrays
julia> ms = sparse([1, 2, 3, 3, 4, 5, 5], [2, 4, 1, 4, 3, 4, 5], [1, 3, 4, 2, 1, 1, 7])
Ausgabe:
⋅ 1 ⋅ ⋅ ⋅
⋅ ⋅ ⋅ 3 ⋅
4 ⋅ ⋅ 2 ⋅
⋅ ⋅ 1 ⋅ ⋅
⋅ ⋅ ⋅ 1 7
=== Spezielle Matrizen ===
Nachfolgend sollen eine Nullmatrix und eine Matrix mit lauter Einsen generiert werden. Dazu starten wir wieder die Julia-REPL, geben die entsprechenden Befehle ein und erhalten:
julia> zeros(3,2)
3×2 Matrix{Float64}:
0.0 0.0
0.0 0.0
0.0 0.0
julia> ones(3,2)
3×2 Matrix{Float64}:
1.0 1.0
1.0 1.0
1.0 1.0
Insbesondere für Testzwecke kann es manchmal sinnvoll sein größere Matrizen mit Zufallswerten zu bilden. Dazu stellt Julia den rand-Befehl zur Verfügung.
julia> m = rand(5,6)
5×6 Matrix{Float64}:
0.554722 0.7314 0.571432 0.804651 0.192327 0.912537
0.684459 0.748819 0.642302 0.552636 0.671043 0.250012
0.624424 0.722093 0.125511 0.342248 0.398071 0.820795
0.0894763 0.0514967 0.310389 0.96167 0.382739 0.0181225
0.957162 0.365172 0.50859 0.0742012 0.555778 0.512406
Einheitsmatrizen: Man beachte das <code>I</code> nach der Zahl 1. Die Matrix muss quadratisch sein.
julia> using LinearAlgebra
julia> M = 1I + zeros(4,4)
4×4 Matrix{Float64}:
1.0 0.0 0.0 0.0
0.0 1.0 0.0 0.0
0.0 0.0 1.0 0.0
0.0 0.0 0.0 1.0
Alternativ:
julia> using LinearAlgebra
julia> M = 1I(4)
4×4 Diagonal{Int64, Vector{Int64}}:
1 ⋅ ⋅ ⋅
⋅ 1 ⋅ ⋅
⋅ ⋅ 1 ⋅
⋅ ⋅ ⋅ 1
Diagonalmatrizen, z.B.:
julia> using LinearAlgebra
julia> M = 3I + zeros(4,4)
4×4 Matrix{Float64}:
3.0 0.0 0.0 0.0
0.0 3.0 0.0 0.0
0.0 0.0 3.0 0.0
0.0 0.0 0.0 3.0
Und damit verlassen wir die REPL wieder.
= Komplexe Zahlen =
Die imaginäre Einheit wird in Julia durch die Buchstabenkombination <code>im</code> symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung <math>z = \Re(z) + i \cdot \Im(z)</math>
* Polardarstellungen <math>z = r \cdot (\cos(\phi) + i \cdot \sin(\phi)) = r \cdot e^{i\cdot \phi}</math>
Die konjugiert komplexe Zahl ist <math>z^* = \Re(z) - i \cdot \Im(z)</math>
== Mit komplexen Zahlen rechnen ==
z1 = 2 + 5im # kartesische Darstellung
z2 = 3 * exp(3im) # Polardarstellung
# Addition
res = z1 + z2
println("z1 + z2 = ", res)
# Multiplikation
res = z1 * z2
println("z1 * z2 = ", res)
# Realteil
res = real(z2)
println("Realteil von z2 = ", res)
# Imaginärteil
res = imag(z2)
println("Imaginaerteil von z2 = ", res)
# Betrag
res = abs(z1)
println("Betrag von z1 = ", res)
# Argument
res = angle(z1)
println("Argument von z1 = ", res)
# Konjugiert komplexe Zahl
res = conj(z1)
println("Konjugiert komplexe Zahl von z1 = ", res)
Ausgabe:
z1 + z2 = -0.9699774898013365 + 5.423360024179601im
z1 * z2 = -8.05675510050068 - 14.003167400647481im
Realteil von z2 = -2.9699774898013365
Imaginaerteil von z2 = 0.4233600241796016
Betrag von z1 = 5.385164807134504
Argument von z1 = 1.1902899496825317
Konjugiert komplexe Zahl von z1 = 2 - 5im
= Funktionen =
Um Programme zu strukturieren und einfacher zu gestalten können Programmteile in Funktionen ausgelagert werden. Eingebaute Funktionen haben wir schon kennengelernt (z.B. die Sinus-Funktion sin). Nun wollen wir sehen, wie man selbst solche Funktionen schreiben kann.
== Eine einfache Funktion schreiben ==
f(a, b) = a + b
println(f(2, 3))
Ausgabe:
5
== function ==
Datei <code>c:\tmp\func.jl</code>:
function add(a,b)
println(a + b)
end
Datei <code>c:\tmp\test1.jl</code>:
include("func.jl")
add(5, 11)
Folgendes wird ausgegeben, wenn wir die test1.jl-Datei ausführen
16
== Anonyme Funktionen ==
println(map(a -> 5a + 10, [2, 3]))
Ausgabe:
[20, 25]
== return ==
Datei <code>c:\tmp\func.jl</code>:
function add(a,b)
return a + b
end
Datei <code>c:\tmp\test1.jl</code>:
include("func.jl")
println(add(5, 11))
Folgendes wird ausgegeben, wenn wir die test1.jl-Datei ausführen
16
Auch die Rückgabe mehrerer Werte ist möglich.
Datei <code>c:\tmp\func.jl</code>:
function add(a, b)
return a + b, "Addition"
end
Datei <code>c:\tmp\test1.jl</code>:
include("func.jl")
x, y = add(10, 20)
println(x)
println(y)
Ausgabe:
30
Addition
== Optionale Argumente ==
Datei <code>c:\tmp\func.jl</code>:
function add(a, b = 100)
return a + b
end
Datei <code>c:\tmp\test1.jl</code>:
include("func.jl")
println(add(5, 11))
println(add(5))
Folgendes wird ausgegeben, wenn wir die test1.jl-Datei ausführen
16
105
== Schlüsselwort-Argumente ==
Datei <code>c:\tmp\func.jl</code>:
function add(a; b = 100)
return a + b
end
Man beachte, dass hier zwischen den Argumenten a und b kein Beistrich, sondern ein Semikolon steht.
Datei <code>c:\tmp\test1.jl</code>:
include("func.jl")
println(add(b=16, 5))
println(add(5, b=16))
println(add(5))
Ausgabe:
21
21
105
= Polynome =
Sofern noch nicht geschehen, fügen Sie das Paket <code>Polynomials</code> zum Julia-System hinzu.
== Ein erstes einfaches Beispiel ==
using Polynomials
println(Polynomial([1, 0, 5, 7]))
Ausgabe:
1 + 5*x^2 + 7*x^3
== Einzelne Polynomwerte berechnen ==
using Polynomials
p = Polynomial([1, 0, 5, 7]);
println(p(1.5))
Ausgabe:
35.875
== Polynome integrieren und differenzieren ==
using Polynomials
p = Polynomial([1, 0, 5, 7]);
i = integrate(p)
d = derivative(p)
println(i)
println(d)
Ausgabe:
1.0*x + 1.66667*x^3 + 1.75*x^4
10*x + 21*x^2
== Nullstellen bestimmen ==
using Polynomials
p = Polynomial([4, 0, 5, 2]);
r = roots(p)
println(r)
Ausgabe:
ComplexF64[-2.7621427020576714 + 0.0im, 0.13107135102883646 - 0.8407709868482356im, 0.13107135102883646 + 0.8407709868482356im]
== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms <math>y = 2x^4 - 3x^3 - x + 7</math>.
* Differenzieren und integrieren Sie das Polynom <math>y = 2x^4 - 3x^3 - x + 7</math>.
* Berechnen Sie die Nullstellen von <math>y = 7x^5 - 3x^2 + 12</math>.
= Lineare Gleichungssysteme =
Sei <math>Ax = b</math> ein lineares Gleichungssystem. <math>A</math> sei die Koeffizientenmatrix, <math>x</math> der Lösungsvektor und <math>b</math> ein bekannter Vektor.
Beispiel:
A = [5 1; 0 2]
b = [1, 2]
x = A \ b
println(x)
Ausgabe:
[0.0, 1.0]
= Interpolation =
Als erstes muss das Interpolations-Paket installiert werden. Wenn Sie nicht wissen, wie man das macht, so sehen Sie unter dem Abschnitt "Grafiken zeichnen" den Absatz "Plots installieren". Dort wird die Vorgehensweise detailliert beschrieben.
Datei "c:\tmp\test1.jl":
using Interpolations
using Plots
# Stützpunkte
xp = 1 : 1 : 5
yp = [0; -5; 2; 7; 6]
# Interpolationsfunktionen
lspl = LinearInterpolation(xp, yp, extrapolation_bc = Line())
cspl = CubicSplineInterpolation(xp, yp, extrapolation_bc = Line())
# Stützpunkte zeichnen
plot(xp,yp,marker=4,linetype=:scatter, label = "Data", title = "Interpolation")
# Interpolierende zeichnen
x = 1 : .1 : 5
plot!(x, lspl(x), label="Linearer Spline")
plot!(x, cspl(x), label="Kubischer Spline")
gui()
while true
end
Ausgabe:
[[Datei:Julia_interpol1.jpg]]
= Differenzialrechnung =
== Symbolische Differenziation ==
julia> using Calculus
julia> differentiate("sin(x)", :x)
Ausgabe:
:(1 * cos(x))
Auswertung:
julia> x = pi/2;
julia> round(eval(differentiate("sin(x)", :x)))
Ausgabe:
0.0
== Numerische Differenziation ==
julia> using Calculus
julia> derivative("sin", pi/2)
Ausgabe:
0.0
= Integralrechnung =
julia> using QuadGK
julia> integral, err = quadgk(x -> sin(x), 0, pi/2, rtol=1e-8)
Ausgabe:
(0.9999999999999999, 1.1102230246251565e-16)
Im Rahmen der Näherung ist das Resultat richtig (exakt sollte (1.0, 0.0) rauskommen).
= Gewöhnliche Differenzialgleichungen =
Das Paket <code>DifferentialEquations</code> ist, wie so viele andere, umfangreich. Hier sei nur ein einfaches Beispiel dargestellt. Für weiterführende Studien sei auf die entsprechenden Weblinks verwiesen.
Folgende Differentialgleichung sei gegeben: <math>y' = x^2 + y^3</math>.
using DifferentialEquations
using Plots
f(y, p, x) = x^2 + y^3
problem = ODEProblem(f, 0.0, (0.0, 1.0))
s = solve(problem, Tsit5(), reltol = 1e-8, abstol = 1e-8)
plot(s, title = "ODE")
gui()
while true
end
Ausgabe:
[[Datei:Julia_dgl1.jpg]]
= Ein- und Ausgabe =
== Dateien lesen ==
# Textdatei im aktuellen Verzeichnis öffnen
f = open("test1.jl")
# Lesen aus Datei
lines = readlines(f)
# Zeilenweise Ausgabe am Bildschirm
for l in lines
println("$l")
end
# Datei schließen
close(f)
Als Ausgabe erscheint exakt obiger Source-Code im Terminal.
== Dateien schreiben ==
open("test.txt", "w") do f
write(f, "Schreibe eine Zeile in Textdatei\n")
end
Der Inhalt der Datei "test.txt" ist dann:
Schreibe eine Zeile in Textdatei
= Benutzeroberflächen erstellen =
Hier wird nur eine (sehr) kurze Einführung in das Thema GUI mit Gtk (Gimp toolkit, [https://www.gtk.org/]) gegeben. Nähere Details siehe die Gtk.jl-Dokumentation ([https://juliagraphics.github.io/Gtk.jl/latest/]). Nachfolgend wird ein gegenüber der offiziellen Dokumentation abgewandeltes Beispiel gezeigt. Das ist nötig, um Gtk.jl unter Windows 10 zum Laufen (bzw. um ein Fenster angezeigt) zu bekommen. Das Problem scheint schon seit Langem bekannt zu sein, siehe [https://stackoverflow.com/questions/52589873/gtk-jl-julia-bindings-for-gtk-gtk-window-is-not-displayed-outside-the-repl Gtk.jl, Julia Bindings for Gtk: Gtk Window is not displayed outside the REPL].
using Gtk
win = GtkWindow("Hallo Welt", 400, 200)
b = GtkButton("Push the button")
push!(win,b)
c = Condition()
endit(w) = notify(c)
signal_connect(endit, win, :destroy)
showall(win)
wait(c)
Ausgabe:
[[Datei:Julia_gtk1.jpg]]
Ein etwas komplizierteres (aber zugegebenerweise noch nicht sehr schönes) Beispiel sei nachfolgend gezeigt. Es sollen zwei Strings miteinander verknüpft und ausgegeben werden.
using Gtk
win = GtkWindow("Stringverknüpfung")
hbox = GtkBox(:h)
push!(win, hbox)
e1 = GtkEntry()
l1 = GtkLabel("verknüpfe mit")
e2 = GtkEntry()
b = GtkButton("=")
l2 = GtkLabel(" ")
push!(hbox, e1)
push!(hbox, l1)
push!(hbox, e2)
push!(hbox, b)
push!(hbox, l2)
function on_button_clicked(b)
GAccessor.text(l2, get_gtk_property(e1, :text, String) * get_gtk_property(e2, :text, String))
end
signal_connect(on_button_clicked, b, "clicked")
c = Condition()
endit(w) = notify(c)
signal_connect(endit, win, :destroy)
showall(win)
wait(c)
Ausgabe (vor der Eingabe der Teilstrings):
[[Datei:Julia_gtk2.jpg]]
Ausgabe (nach der Eingabe der Teilstrings und dem Drücken des =-Buttons):
[[Datei:Julia_gtk3.jpg]]
= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Julia. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechenden weiterführenden Weblinks und die Julia-Hilfefunktion
verwiesen. Julia kennt noch viel mehr Befehle, als hier dargestellt wurden. Das Themenspektrum ist auch durch die Einbindung externer Pakete fast beliebig erweiterbar.
= Weblinks =
* [https://julialang.org/ Julia Homepage]
* [https://docs.julialang.org/en/v1/ Julia Dokumentation]
* [https://en.wikibooks.org/wiki/Introducing_Julia Englisches Wikibook zu Julia]
* [https://docs.makie.org/stable/ Makie - a data visualization ecosystem for Julia]
* [https://docs.juliaplots.org/latest/ Plots - powerful convenience for visualization in Julia]
* [https://www.matecdev.com/posts/julia-numerical-computing.html Numerical Computing in Julia]
* [https://www.matecdev.com/posts/julia-tutorial-science-engineering.html Julia Programming Tutorial]
* [https://juliapackages.com/p/polynomials Polynomials.jl]
* [https://github.com/JuliaMath/Calculus.jl Calculus.jl]
* [https://github.com/JuliaMath/QuadGK.jl QuadGK.jl]
* [https://docs.sciml.ai/DiffEqDocs/stable/ DifferentialEquations.jl: Efficient Differential Equation Solving in Julia]
* [https://nextjournal.com/sosiris-de/ode-diffeq# Solving ODEs in Julia]
* [https://juliagraphics.github.io/Gtk.jl/latest/ Gtk.jl]
{{Navigation_zurückhochvor_buch|
zurücktext=Octave|
zurücklink=Ing Mathematik: Numerische Mathematiksysteme am Beispiel von Octave|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Python für Ingenieure|
vorlink=Ing Mathematik: Python}}
0hiu34pl8upbfqr9rmtzp1nwd2x9exj
1092408
1092407
2026-10-24T07:01:42Z
Intruder
1513
/* if */
1092408
wikitext
text/x-wiki
{{Navigation_zurückhochvor_buch|
zurücktext=Octave|
zurücklink=Ing Mathematik: Numerische Mathematiksysteme am Beispiel von Octave|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Python für Ingenieure|
vorlink=Ing Mathematik: Python}}
= Hallo Welt und allgemeine Hinweise =
== Was ist Julia ==
* Julia ist eine höhere Programmiersprache, die vor allem für numerisches und wissenschaftliches Rechnen entwickelt wurde.
* Julia ist Open-Source (MIT-Lizenz).
* Julia ist schnell (JIT-Compiler).
* Julia ist für wichtige Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Julia als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
{{Wikipedia | Julia (Programmiersprache)}}
== Julia installieren ==
=== MS Windows ===
Laden Sie das aktuelle Julia-Paket von der Webseite [https://julialang.org/downloads/] herunter (Manual Downloads). Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen. Alternativ können Sie auch den "MSIX App Installer" verwenden, siehe die genannte Download-Seite.
=== Linux ===
Den Install-Button auf der Seite [https://julialang.org/] anklicken und den Anweisungen folgen (<code>curl ...</code>). Das Programm wird dann automatisch installiert.
== Julia starten ==
=== MS Windows ===
Das Icon für das Julia-Programm doppelklicken. Und schon startet das Programm.
[[Datei:juliastart1.jpg]]
Das Julia-System präsentiert sich dann folgendermaßen (interaktives Kommandozeilenprogramm REPL [Read–eval–print loop]):
[[Datei:Julia1.0.jpg|500px]]
=== Linux ===
Einfach <code>julia</code> in einer Konsole eintippen und mit der <code>Return</code>-Taste abschließen. Dies startet die Julia-REPL.
Es gibt auch noch andere Möglichkeiten Julia zwecks Programmausführung zu starten, z. B. den {{W|Shebang}} (<code>#!</code>) am Beginn eines Julia-Scripts. Das Script sei als Script.py gespeichert. Dann kann das Script mit ./Script.py ausgeführt werden. Für openSUSE Tumbleweed sei nachfolgend ein lauffähiges "Hallo Welt!"-Script angegeben.
#!/usr/bin/julia
println("Hallo Welt!")
Die Berechtigungen zum Ausführen der Datei müssen natürlich noch richtig gesetzt werden, z.B. mittels <code>chmod 777 Script.py</code>. <small>Die "Maske" <code>777</code> ist nur für Testzwecke sinnvoll, weil sie leicht zu merken ist und für alle Benutzer alle Zugriffsberechtigungen ('''r'''ead/'''w'''rite/e'''x'''ecute für owner/group/others) setzt. Im richtigen Einsatz wird man das aus Sicherheitsgründen nicht so handhaben, sondern nur die Berechtigungen setzen, die unbedingt erforderlich sind.</small>
== Ein paar Worte zur Erklärung ==
=== Tests ===
Getestet wurden die Beispiele unter den Betriebssystemen
* MS Windows 10 mit den Julia-Versionen 1.9.4 und 1.10.2 (bis Ende 2024).
* openSUSE Leap 15.6 mit der Julia-Version 1.11.6 (im Juli 2025, nur vereinzelt).
* openSUSE Tumbleweed ab der Julia-Version 1.12.5 (ab März 2026, nur vereinzelt).
=== Popularität ===
* An Beliebtheit rangiert Julia mit Stand September 2026 mit einem Rating von 0,74% an 21. Stelle der beliebtesten Programmiersprachen ([https://www.tiobe.com/tiobe-index/ lt. TPCI - TIOBE Programming Community Index]).
* Lt. [https://pypl.github.io/PYPL.html PYPL] (PopularitY of Programming Language) liegt Julia auf dem 21. Platz (0,45%; Stand: September 2026).
== Ein erstes Programm ==
Kommentare werden in Julia mit der Raute (#) eingeleitet. Sie werden vom Julia-Interpreter ignoriert. Text kann mit der print- oder println-Funktion ausgegeben werden. Starten Sie Julia und geben sie folgende Anweisungen zeilenweise ein (die Anweisungen sind jeweils mit der Return-Taste abzuschließen)
julia> # Das ist ein Kommentar
julia> print("Hallo Welt!")
Als Ergebnis erhalten Sie
Hallo Welt!
Der Prompt (julia>) ist selbstverständlich nicht einzutippen, sondern wird vom Julia-System geliefert.
Strings sind in Julia in Anführungszeichen (") zu setzen. Zwischen dem Befehl print und der öffnenden Klammer ( darf kein Leerzeichen gesetzt werden.
= Julia als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Julia. Geben Sie dann die Formel
julia> 3 * 5
ein, drücken die Taste ENTER/RETURN und erhalten als Ergebnis
15
Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck <math>\sin\sqrt{15}</math> berechnen :
julia> sin(sqrt(15))
-0.6679052983383519
Mit dieser Zahl kann unmittelbar weitergerechnet werden, z.B.
julia> ans * 2
-1.3358105966767038
"ans" steht übrigens für den Begriff "answer" (auf Deutsch "Antwort").
Das Mal-Zeichen (*) kann übrigens eingespart werden. <code>ans * 2</code> ist dasselbe wie <code>2ans</code>. Man beachte aber, dass in der Kurzform kein Leerzeichen zwischen 2 und ans stehen darf.
Beenden lässt sich das Julia-Programm durch Eingabe von exit() (und natürlich ist zur Bestätigung die RETURN-Taste zu drücken). Beachten Sie wieder, dass zwischen der Funktion exit und der öffnenden Klammer kein Leerzeichen stehen darf.
== Die Hilfefunktion von Julia ==
Bei Eingabe eines Fragezeichens (?) springt Julia in das Hilfesystem.
Eingabe:
?
Eingabe:
help?> sin
Ausgabe:
sin
search: sin sinh sind sinc sinpi sincos sincosd sincospi asin using isinf asinh asind isinteger isinteractive thisind
sin(x)
Compute sine of x, where x is in radians.
See also sind, sinpi, sincos, cis, asin.
Examples
≡≡≡≡≡≡≡≡≡≡
julia> round.(sin.(range(0, 2pi, length=9)'), digits=3)
...
...
...
0.454649 0.454649
Für die komplette Julia-Dokumentation siehe [https://docs.julialang.org/en/v1/].
== Aufgaben ==
* Erkunden Sie die Tangensfunktion "tan" mittels Julia-Hilfe.
* Berechnen Sie mit Julia den Ausdruck <math>\frac{1}{2}\cdot e^2 \cdot \tan(\pi/3)</math>. Siehe für die Exponentialfunktion im Julia-Hilfesystem auch den Befehl exp(). Potenzieren kann man bei Julia mit dem ^-Operator (z.B. 2^3 = 8)
* Berechnen Sie mit Julia den Ausdruck <math>2\text{cosd}(60) - 3\sin(\pi/5)</math>. Anmerkung: cosd erwartet den Parameter im Gradmaß (d für "degree"), sin erwartet den Parameter im Bogenmaß.
= Julia als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.jl
# Das ist ein Kommentar
print("Hallo Welt!")
Julia-Dateien werden mit der Dateiendung .jl versehen.
Danach bringen Sie die Skriptdatei test1.jl (sozusagen das Hauptprogramm) folgendermaßen zur Ausführung:
1) Starten Sie unter MS Windows die Eingabeaufforderung (oder alternativ die Windows PowerShell). Das sieht dann etwa so aus:
Microsoft Windows [Version 10.0.19045.3693]
(c) Microsoft Corporation. Alle Rechte vorbehalten.
C:\Users\xyz>
: <small>Falls jemand nicht weiß, wie man die Eingabeaufforderung startet: Eine Möglichkeit ist, einfach in der Taskleiste von Windows das "Start"-Symbol mit der rechten Maustaste anklicken. "Ausführen" auswählen (oder alternativ für die PowerShell den Eintrag "Windows PowerShell"). Im sich öffnenden Dialogfenster gibt man in die "Öffnen"-Zeile das Wort <code>cmd</code> ein und mit "OK" wird das Ganze bestätigt.</small>
2) Wechseln Sie mittels <code>cd c:\tmp</code> in das Verzeichnis c:\tmp
3) Angenommen, Sie haben Julia unter dem Pfad <code>c:\devel\Julia-1.9.4\</code> installiert. Starten Sie das Programm so (der Prompt <code>c:\tmp></code>ist natürlich nicht mit einzutippen):
c:\tmp>c:\devel\Julia-1.9.4\bin\julia.exe test1.jl
4) Wie erwartet ergibt sich folgende Ausgabe am Bildschirm
Hallo Welt!
Die Vorgehensweise unter Linux ist sehr ähnlich, wird hier deshalb nicht noch mal gezeigt.
== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9), Underscores (_) und etlichen Unicode-Zeichen bestehen, dürfen aber nicht mit einer Zahl beginnen.
Gültige Variablenbezeichner wären also:
xyz
x1
_wert
name_anzahl
a₂
γπΩ
Wie kann man eigentlich die griechischen Zeichen im vorhergehenden Beispiel eingeben? Auf einer deutschen oder englischen Tastatur sind sie jedenfalls nicht zu finden. Des Rätsels Lösung kann folgendermaßen aussehen (wird am Beispiel des Omega-Zeichens (Ω) vorgeführt):
1) Starten Sie das Julia-System (z.B. mittels Doppelklick auf das Julia-Icon oder in der Eingabeaufforderung durch direkte Eingabe von julia.exe (ggf. mit dem entsprechenden Programmpfad).
2) geben Sie <code>\Omega</code> ein (ohne den Befehl mit Return abzuschließen)
julia> \Omega
3 Tippen Sie auf die Tabulatortaste und schon erscheint das Ω.
4) Dieses Zeichen können Sie dann mittels Zwischenablage z.B. auch in eine jl.-Datei einfügen (ggf. unter Verwendung eines geeigneten Text-Editors, z.B. Geany oder unter Linux auch Kate)
Ähnliches gilt für tiefgestellte Indizes, z.B. <code>a\_2</code> gefolgt von einem Tabulator ergibt a₂.
Da Julia case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
xyz
XYZ
xYz
Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code unter MS Windows immer in der Datei <code>c:\tmp\test1.jl</code> oder unter Linux z.B. unter <code>~/tmp/test1.jl</code> gespeichert.
x = 5
y = 10
z = x*y
print(z)
Bringen Sie die Datei test1.jl zur Ausführung, so erhalten Sie folgende Bildschirmausgabe
50
Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben.
x = 5; y = 10; z = x*y
print(z)
Ausgabe:
50
Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
x = 5;
println(x)
# x = x - 2
x -= 2
println(x)
Bildschirmausgabe:
5
3
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist.
Die Verwendung von Prä-/Postfix-Operatoren (++, --) wie unter C/C++ oder Java ist in Julia nicht erlaubt, sondern liefert nur eine Fehlermeldung.
Soll eine Anweisung auf mehrere Zeilen verteilt werden, z.B. weil sie zu lang ist, so kann dies geschehen, wie nachfolgend dargestellt.
x = 5;
y = 1000 * x +
sin(x/2)
print(y)
Ausgabe:
5000.598472144104
Beachten Sie, dass die Zeilentrennung nach einem Operator erfolgt! Folgendes würde ein falsches Resultat liefern:
x = 5;
y = 1000 * x
+ sin(x/2)
print(y)
Ausgabe:
5000
Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist mit Julia problemlos möglich:
wert = 10
println(wert)
wert = 35.5
println(wert)
wert = "Hallo"
println(wert)
wert = pi
println(wert)
Ausgabe:
10
35.5
Hallo
π
==Hexadezimale, oktale und binäre Zahlen==
# Hexadezimale Zahl
println(0xABC)
# Oktale Zahl
println(0o56)
# Binäre Zahl
println( 0b1000011 )
Ausgabe (als Dezimalzahlen):
2748
46
67
Julia kann auch dezimale in binäre Zahlen etc. umwandeln:
Eingabe:
b = bitstring(30)
println(b)
Ausgabe:
0000000000000000000000000000000000000000000000000000000000011110
Ein anderes Beispiel (hexadezimal nach binär):
# hexadezimal -> binär
s = string(0xF, base=2)
print(s)
Ausgabe:
1111
== Verzweigungen ==
=== if ===
Die IF-Verzweigung ist aus anderen Programmiersprachen bereits bekannt. In Pseudocode lässt sie sich folgendermaßen darstellen:
WENN bedingung TRUE
führe block1 aus
SONST
führe block2 aus
ENDE
Die test1.jl-Datei laute also wie folgt:
x = 5;
if x < 4
println("x ist kleiner als 4");
else
println("Der else-Zweig wird ausgefuehrt");
println("x ist groesser oder gleich 4");
end
Ausgabe:
Der else-Zweig wird ausgefuehrt
x ist groesser oder gleich 4
Julia kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:
* <, <= ... kleiner (gleich)
* >, >= ... größer (gleich)
* == ... gleich
* != ... ungleich
* &, && ... AND
* |, || ... OR
Beispielsweise:
a = 5;
b = 9;
if a<=10 & b!=7
println("OK");
else
println("Nicht OK");
end
Ausgabe:
OK
Erweiterung der if-else-end-Verzweigung - ein Beispiel mit <code>elseif</code>:
a = 5
if a==10
println("OK")
elseif a==5
println("Nicht OK")
println("a = 5")
elseif a==6
println("Auch nicht OK")
else
println("Weiß nicht")
end
Ausgabe:
Nicht OK
a = 5
Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen <math>\varepsilon</math>-Wert) vorgeben.
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:
i = 0.1 + 0.2
println(i);
if i == 0.3
println("OK");
else
println("NOK");
end
Ausgabe:
0.30000000000000004
NOK
Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist.
Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:
ist = 0.1 + 0.2;
soll = 0.3;
epsilon = 0.000001;
println(ist);
if abs(ist-soll) < epsilon
println("OK");
else
println("NOK");
end
Ausgabe:
0.30000000000000004
OK
=== Ternärer Operator ===
Eingabedatei:
a = 5
a >= 6 ? println("größer gleich 6") : println("kleiner 6")
Ausgabe:
kleiner 6
== Schleifen ==
=== while ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert nicht ganz so wie aus anderen Programmiersprachen bekannt.
In Pseudocode:
SOLANGE bedingung TRUE
führe block aus
ENDE
In Julia:
x = 0
while x <= 10
println(x)
global x += 1
end
Ausgabe:
0
1
2
3
4
5
6
7
8
9
10
Außerhalb von Funktionen muss das Schlüsselwort <code>global</code> verwendet werden. Ansonsten gibt es eine Warnung und eine Fehlermeldung. Innerhalb einer Funktion benötigt man das <code>global</code> nicht.
=== for ===
for x = 0 : 2 : 10
println(x);
end
Ausgabe:
0
2
4
6
8
10
Der FOR-Schleifenkopf ist in Form einer Zahlenkolonne folgendermaßen aufgebaut:
for variable = startwert : schrittweite : endwert
Alternativ findet man in der Literatur auch folgende for-Schleifenaufbauten.
for x in 0 : 2 : 10
println(x);
end
for x ∈ 0 : 2 : 10
println(x);
end
Achtung: Das ∈ ist kein \epsilon, sondern ein \in.
Die unterschiedlichen for-Schleifen liefern jeweils das gleiche Ergebnis.
=== break und continue ===
Zum Abbrechen einer Schleife gibt es den Befehl "break".
for var = 0 : 1 : 100
println(var)
if var == 5
break;
end
end
Ausgabe:
0
1
2
3
4
5
"continue" setzt mit dem nächsten Schleifendurchlauf fort, z.B.
for var = 0 : 1 : 10
if var == 5
continue;
end
println(var);
end
Ausgabe:
0
1
2
3
4
6
7
8
9
10
== Eingabe via Tastatur ==
Datei c:\tmp\test1.jl:
print("Geben Sie eine Zahl ein: ")
# Einlesen als String
str = readline(stdin)
print("Die Zahl lautet ")
println(str)
# Umwandeln in einen Float
zahl = parse(Float64, str)
print("Die Zahl lautet ")
println(zahl)
Eingabe der Zahl via Tastatur:
67.8
Mit der RETURN-Taste bestätigen.
Ausgabe:
Die Zahl lautet 67.8
Die Zahl lautet 67.8
In diesem Fall wird, wie gezeigt, zweimal <code>Die Zahl lautet 67.8</code> ausgegeben. Gibt man aber z.B. <code>Eins</code> ein, so wird einmal <code>Die Zahl lautet Eins</code> ausgegeben. Das ist klar, da <code>Eins</code> ein gültiger String ist. Danach folgt aber eine Fehlermeldung, weil <code>Eins</code> nicht in eine Fließkommazahl umgewandelt werden kann.
= Grafiken zeichnen =
Es gibt in Julia mehrere Möglichkeiten Grafiken zu zeichnen. Hier wird eine Einführung in das Package Plots gegeben.
== Plots installieren ==
Im Julia-REPL die schließende eckige Klammer ] eintippen. Damit springt man in das Package-System, angezeigt wird das mit dem Prompt <code>(@v1.9) pkg></code>.
Das Plots-Package zum Julia-System hinzufügen:
(@v1.9) pkg> add Plots
Mit STRG-C kann das Package-System wieder verlassen werden.
== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall <math>x\in[-3,3]</math> gezeichnet werden. Der Programmcode lautet in der einfachsten Form:
using Plots
x = -3 : .1 : 3
y = cosh.(x)
p = plot(x, y)
gui()
while(true)
end
Ausgabe:
[[Datei:Julia_cosh.jpg]]
Der Code ist quasi selbsterklärend. Das Plots-Package wird importiert. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. "plot" ist der Zeichenbefehl. "gui" ist notwendig, um das Fenster mit der Grafik anzuzeigen. Es folgt eine Endlossschleife. Diese ist notwendig, weil das Fenster mit der Grafik sonst nur kurz aufblinkt und das Programm danach beendet wird. Das Gesagte gilt, wenn man die test1.jl-Datei direkt ausführt. Im REPL kann man sich den Befehl "gui" und die Endlosschleife sparen.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen.
Hinweise:
* Bis das Fenster mit dem cosh-Graphen erscheint, kann es einige Sekunden dauern.
* Beenden kann man die Endlosschleife, indem man STRG-C drückt (STRG ist die Steuerungs- oder Control-Taste)
* Beachten Sie den Punkt (.) bei der cosh-Funktion. Vergessen Sie diesen, so wird eine Fehlermeldung ausgegeben.
Ein etwas komplexeres Beispiel ist folgendes
using Plots
x = -3 : .1: 3
y = cosh.(x) + 2 .^x
plot(x,y)
gui()
while true
end
Man beachte die Punkte bei der Funktion y. Vergisst man die Punkte, dann erhält man eine Fehlermeldung. Weiters beachte man das Leerzeichen und die Position desselben bei 2 .^x. Setzt man das Leerzeichen an die falsche Stelle oder vergisst es ganz, so ist das auch ein Fehler.
Ausgabe:
[[Datei:Julia_cosh2.jpg]]
=== Graphen mehrerer Funktionen und weiteres ===
Mehrere Graphen lassen sich folgendermaßen in ein Fenster zeichnen (es werden auch Titel und Labels gesetzt):
using Plots
x = -3 : .1: 3
y1 = cosh.(x) + 2 .^x
y2 = sin.(x) .* cos.(x)
plot(x, [y1, y2], title="Screenshot", label=["cosh(x) + 2^x" "sin(x) + cos(x)"],
xlabel="x", ylabel="y")
gui()
while true
end
[[Bild:Julia_cosh14.jpg]]
Will man mehrere Graphen in ein Fenster zeichnen, aber nicht alles in einen plot-Befehl quetschen, so kann die "plot!"-Anweisung die Lösung des Problems sein. Auch die Linienstile sollen nun etwas individueller gestaltet werden:
using Plots
x = -3 : .1: 3
y1 = cosh.(x) + 2 .^x
y2 = sin.(x) .* cos.(x)
plot(x, y1, linestyle=:dot, label="cosh ...", linewidth=5)
plot!(x, y2, ls=:dot, label="sin ...", lw=3)
title!("Funktionsgraphen")
xlabel!("x")
ylabel!("y")
gui()
while true
end
[[Datei:Julia_cosh4.jpg]]
=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale <math>x = t \cos(t), y = t \sin(t)</math> im Intervall <math>[0, 6\pi]</math> gezeichnet werden.
using Plots
t = 0 : .1: 6*pi
x = t .* cos.(t)
y = t .* sin.(t)
plot(x, y, lw=5)
gui()
while true
end
[[Datei:Julia_spirale1.jpg]]
Der Graph erscheint in der obigen Darstellung verzerrt. Will man das nicht, so setze man das <code>aspect_ratio</code> auf <code>:equal</code>:
using Plots
t = 0 : .1: 6*pi
x = t .* cos.(t)
y = t .* sin.(t)
plot(x, y, lw=5, aspect_ratio = :equal)
gui()
while true
end
[[Datei:Julia_spirale2.jpg]]
=== Logarithmische Achsenskalierung ===
using Plots
f(x) = 10^x
p1 = plot(f, 1, 5, lw=2, title="kartesische Koordinaten")
p2 = plot(f, 1, 5, yscale=:log10, lw=2, title="Semilog")
p3 = plot(f, 1, 5, xscale=:log10, yscale=:log10, lw=2, title="LogLog")
plot(p1, p2, p3, layout=(3,1))
gui()
while true
end
Ausgabe:
[[Datei:Julia_log1.jpg]]
=== Aufgaben ===
* Zeichnen Sie die Strophoide <math>x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3</math>. Das Ganze sollte in etwa so aussehen wie folgende Grafik:
[[Datei:octave_strophoide.jpg]]
* Zeichnen Sie die verschlungene Hypozykloide <math>x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15</math>. Das Ganze sollte in etwa so aussehen wie folgende Grafik:
[[Datei:octave_hypozykloide.jpg]]
* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.
== 3D ==
=== Räumliche Kurven ===
Mittels "plot3d" lassen sich Raumkurven zeichnen.
using Plots
t = 0 : .1: 6*pi
x = t .* cos.(t)
y = t .* sin.(t)
z = t
plot3d(x, y, z)
gui()
while true
end
[[Datei:Julia_raumkurve1.jpg]]
=== Flächen ===
using Plots
x = 0 : .1 : 10;
y = 0 : .1 : 10;
z(x,y) = sin(x) + 3*cos(y);
surface(x,y,z)
gui()
while true
end
[[Datei:Julia_flaeche1.jpg]]
Das Ganze in Netzdarstellung läßt sich so programmieren:
using Plots
x = 0 : .5 : 10
y = 0 : .5 : 10
z(x,y) = sin(x) + 3*cos(y)
wireframe(x, y, z)
gui()
while true
end
[[Datei:Julia_flaeche2.jpg]]
Die Kameraposition lässt sich verändern:
using Plots
x = 0 : .1 : 10
y = 0 : .1 : 10
z(x,y) = sin(x) + 3*cos(y)
# Kamerawinkel in Grad (Azimut, Altitude)
surface(x,y,z, camera = (75, 60))
gui()
while true
end
[[Datei:Julia_flaeche_3.jpg]]
{{Wikipedia | Azimut}}
=== Höhenlinien ===
using Plots
x = 0 : .1 : 10
y = 0 : .1 : 10
z(x,y) = sin(x) + 3*cos(y)
contour(x,y,z)
gui()
while true
end
[[Datei:Julia_hoehenlinien.jpg]]
Etwas abgewandelt sind das so aus:
using Plots
x = 0 : .1 : 10
y = 0 : .1 : 10
z(x,y) = sin(x) + 3*cos(y)
contour(x, y, z, levels=10, clabels=true, cbar=false)
gui()
while true
end
[[Datei:Julia_hoehenlinien2.jpg]]
Und noch eine Variante sei gezeigt.
using Plots
x = 0 : .1 : 10
y = 0 : .1 : 10
z(x,y) = sin(x) + 3*cos(y)
contourf(x, y, z)
gui()
while true
end
[[Datei:Julia_hoehenlinien3.jpg]]
=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve <math>x = 2 \cdot \cosh(t)</math>, <math>y = 5 \cdot \sin(t)</math>, <math> z = t^{2} - t</math>, <math>0 \leq t \leq 3\pi</math>.
* Zeichnen Sie die Fläche <math>z = \log(x) + \cos(y)</math>.
== Animationen ==
using Plots
anim = Animation()
for i = 1:100
plt = plot(sin, 0, i*2pi/10, ylims = (-1., 1.), lab="")
frame(anim, plt)
end
gif(anim, "c:/tmp/Julia_anim1.gif",fps=10)
Dieses Programm schreibt ein animiertes {{W|GIF}} in die Datei <code>c:/tmp/Julia_anim1.gif</code>.
[[Datei:Julia_anim1.gif]]
= Vektoren und Matrizen =
== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein.
=== Spalten- und Zeilenvektoren ===
Starten Sie die Julia-REPL. Geben Sie folgenden Befehl ein, um einen Spaltenvektor zu erstellen:
julia> v1 = [1, 2, 3]
Ausgabe:
3-element Vector{Int64}:
1
2
3
Geben Sie folgenden Befehl ein, um einen Zeilenvektor (oder genauer eine 1x3-Matrix) zu erstellen:
julia> v1 = [1 2 3]
Ausgabe:
1×3 Matrix{Int64}:
1 2 3
=== Zugriff auf Vektorelemente ===
Nachfolgend seien Zugriffsmöglichkeiten auf die Vektorelemente erläutert.
Auf ein einzelnes Element kann via Index zugegriffen werden. Der Index startet bei 1:
v1 = [1, 2, 3]
println(v1[2])
Ausgabe:
2
Mehrere Elemente werden folgendermaßen angesprochen:
v1 = [1 2 4 8 16]
print(v1[3:4])
Ausgabe:
[4, 8]
Liefere den Teilvektor von einem gegebenen Index bis zum letzten Element:
v1 = [1 2 4 8 16]
print(v1[3:end])
Ausgabe:
[4, 8, 16]
=== Addition und Subtraktion von Vektoren ===
v1 = [1, 2, 3]
v2 = [5, 7, 9]
println(v1 + v2)
println(v1 - v2)
Ausgabe:
[6, 9, 12]
[-4, -5, -6]
=== Multiplikation mit Skalaren ===
faktor = 3;
v = [1, 2, 3];
println(v * faktor)
Ausgabe:
[3, 6, 9]
=== Skalarprodukt ===
Das Skalarprodukt ist bekanntermaßen als <math>v_1 \cdot v_2 = |v_1| |v_2| \cos(\angle(v_1, v_2))</math> definiert. In Julia sieht das so aus:
using LinearAlgebra
v1 = [1, 2, 3]
v2 = [2, 5, 10]
println(LinearAlgebra.dot(v1, v2))
Ausgabe:
42
Hinweis: Wenn das LinearAlgebra-Paket noch nicht installiert ist, so muss dies eventuell nachgeholt werden. Wie das prinzipiell funktioniert, wurde im Kapitel "Grafiken zeichnen" am Beispiel des Plots-Pakets vorgeführt.
=== Vektorprodukt ===
<math>a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
</math>
Julia-Code:
using LinearAlgebra
v1 = [1, 2, 3]
v2 = [2, 5, 10]
println(LinearAlgebra.cross(v1, v2))
Ausgabe:
[5, -4, 1]
=== Transponierter Vektor ===
using LinearAlgebra
v = [1, 2, 3]
println(LinearAlgebra.transpose(v))
Ausgabe:
[1 2 3]
=== Einige weitere Vektorfunktionen ===
Die euklidische Norm <math>\|x\|_2 = \sqrt{x_1^2 + x_2^2 + \ldots + x_n^2}</math> in Julia:
using LinearAlgebra
v = [1 2 3]
println(norm(v))
Ausgabe:
3.7416573867739413
Beispiel:
# 1 + 2 + 3
v = [1 2 3]
println(sum(v))
Ausgabe:
6
Beispiel:
# 1 * 2 * 3 * 4
v = [1 2 3 4]
println(prod(v))
Ausgabe:
24
== Matrizen ==
Starten Sie die Julia-REPL. Geben Sie folgenden Befehl ein, um eine 2x3-Matrix zu erstellen:
julia> [1 2 3; 4 5 6]
Ausgabe:
2×3 Matrix{Int64}:
1 2 3
4 5 6
Damit verlassen wir die Julia-REPL wieder und arbeiten im Folgenden mit der test1.jl-Datei weiter.
=== Zugriff auf Matrizenelemente ===
m = [1 2 3; 4 5 6]
# Element aus Zeile 2 und Spalte 3
println(m[2,3])
Ausgabe:
6
Eine andere Zugriffsmöglichkeit ist diese:
m = [1 2 3; 4 5 6]
# Auf das Element an Position 5 soll zugegriffen werden
println(m[5])
Ausgabe:
3
Die Matrix wird also spaltenweise durchlaufen (nicht zeilenweise). Dies ist vielleicht auf den ersten Blick etwas ungewöhnlich, wird aber z.B. auch in Fortran oder Octave so gehandhabt.
[[Datei:Julia_matrix1.svg]]
=== Addition und Subtraktion von Matrizen ===
m1 = [1 2 3; 4 5 6]
m2 = [-4 -2 0; 2 4 6]
println(m1 + m2)
println(m1 - m2)
Ausgabe:
[-3 0 3; 6 9 12]
[5 4 3; 2 1 0]
=== Transponierte Matrix ===
m = [1 2 3; 4 5 6]
println(m')
Ausgabe:
[1 4; 2 5; 3 6]
=== Rang einer Matrix ===
using LinearAlgebra
m1 = [1 2 3; 4 5 6]
m2 = [1 2 3; 2 4 6]
println(LinearAlgebra.rank(m1))
println(LinearAlgebra.rank(m2))
Ausgabe:
2
1
=== Inverse Matrix ===
using LinearAlgebra
m = [1 3; 0 -5 ]
println(LinearAlgebra.inv(m))
Ausgabe:
[1.0 0.6000000000000001; 0.0 -0.2]
=== Determinate einer Matrix ===
using LinearAlgebra
m1 = [1 3; 0 -5 ]
m2 = [1 2; 2 4]
println(LinearAlgebra.det(m1))
println(LinearAlgebra.det(m2))
Ausgabe:
-5.0
0.0
m1 ist regulär, m2 ist singulär. Determinanten können nur von quadratischen Matrizen gebildet werden.
=== Multiplikation von Matrizen (falksches Schema) ===
m1 = [1 3 4; 0 -5 1]
m2 = [1 2; 2 3; 0 2]
println(m1 * m2)
Ausgabe:
[7 19; -10 -13]
=== Teilmatrizen ===
m = [1 2 3; 0 5 1]
# Die Matrix in einen Spaltenvektor umwandeln
println(m[:])
# Das Element aus der 1. Zeile und der 2. Spalte extrahieren
println(m[1,2])
# Erste Zeile extrahieren
println(m[1, 1:3])
println(m[1, :])
# Zweite Spalte extrahieren
println(m[1:2, 2])
println(m[:, 2])
Ausgabe:
[1, 0, 2, 5, 3, 1]
2
[1, 2, 3]
[1, 2, 3]
[2, 5]
[2, 5]
=== Eigenwerte und Eigenvektoren ===
using LinearAlgebra
A = [5 8; 1 3]
# Eigenvektoren und Eigenwerte
println(eigvals(A))
println(eigvecs(A))
Ausgabe:
[1.0, 7.0]
[-0.8944271909999159 0.9701425001453319; 0.447213595499958 0.24253562503633297]
=== LR-Zerlegung einer Matrix ===
Führen Sie die LR-Faktorisierung (LR ... links/rechts bzw. LU ... left/upper) einer Matrix m aus. Dazu springen wir wieder in die REPL und geben folgende Befehle ein:
julia> using LinearAlgebra
julia> m=[1 0 5; -1 1 -2; 0 0 3]
3×3 Matrix{Int64}:
1 0 5
-1 1 -2
0 0 3
julia> f = factorize(m)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
3×3 Matrix{Float64}:
1.0 0.0 0.0
-1.0 1.0 0.0
0.0 0.0 1.0
U factor:
3×3 Matrix{Float64}:
1.0 0.0 5.0
0.0 1.0 3.0
0.0 0.0 3.0
=== Schwach besetzte Matrizen ===
In der Technik treten häufig große Matrizen auf, die aber nur relativ wenige von Null verschiedene Werte mit Bandstruktur besitzen. Für diese ist es ineffizient, alle Matrizenelemente zu speichern. Effizienter ist es, nur die von Null verschiedenen Elemente zu speichern. Zu diesem Zwecke gibt es das <code>SparseArrays</code>-Paket.
julia> using SparseArrays
julia> ms = sparse([1, 2, 3, 3, 4, 5, 5], [2, 4, 1, 4, 3, 4, 5], [1, 3, 4, 2, 1, 1, 7])
Ausgabe:
⋅ 1 ⋅ ⋅ ⋅
⋅ ⋅ ⋅ 3 ⋅
4 ⋅ ⋅ 2 ⋅
⋅ ⋅ 1 ⋅ ⋅
⋅ ⋅ ⋅ 1 7
=== Spezielle Matrizen ===
Nachfolgend sollen eine Nullmatrix und eine Matrix mit lauter Einsen generiert werden. Dazu starten wir wieder die Julia-REPL, geben die entsprechenden Befehle ein und erhalten:
julia> zeros(3,2)
3×2 Matrix{Float64}:
0.0 0.0
0.0 0.0
0.0 0.0
julia> ones(3,2)
3×2 Matrix{Float64}:
1.0 1.0
1.0 1.0
1.0 1.0
Insbesondere für Testzwecke kann es manchmal sinnvoll sein größere Matrizen mit Zufallswerten zu bilden. Dazu stellt Julia den rand-Befehl zur Verfügung.
julia> m = rand(5,6)
5×6 Matrix{Float64}:
0.554722 0.7314 0.571432 0.804651 0.192327 0.912537
0.684459 0.748819 0.642302 0.552636 0.671043 0.250012
0.624424 0.722093 0.125511 0.342248 0.398071 0.820795
0.0894763 0.0514967 0.310389 0.96167 0.382739 0.0181225
0.957162 0.365172 0.50859 0.0742012 0.555778 0.512406
Einheitsmatrizen: Man beachte das <code>I</code> nach der Zahl 1. Die Matrix muss quadratisch sein.
julia> using LinearAlgebra
julia> M = 1I + zeros(4,4)
4×4 Matrix{Float64}:
1.0 0.0 0.0 0.0
0.0 1.0 0.0 0.0
0.0 0.0 1.0 0.0
0.0 0.0 0.0 1.0
Alternativ:
julia> using LinearAlgebra
julia> M = 1I(4)
4×4 Diagonal{Int64, Vector{Int64}}:
1 ⋅ ⋅ ⋅
⋅ 1 ⋅ ⋅
⋅ ⋅ 1 ⋅
⋅ ⋅ ⋅ 1
Diagonalmatrizen, z.B.:
julia> using LinearAlgebra
julia> M = 3I + zeros(4,4)
4×4 Matrix{Float64}:
3.0 0.0 0.0 0.0
0.0 3.0 0.0 0.0
0.0 0.0 3.0 0.0
0.0 0.0 0.0 3.0
Und damit verlassen wir die REPL wieder.
= Komplexe Zahlen =
Die imaginäre Einheit wird in Julia durch die Buchstabenkombination <code>im</code> symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung <math>z = \Re(z) + i \cdot \Im(z)</math>
* Polardarstellungen <math>z = r \cdot (\cos(\phi) + i \cdot \sin(\phi)) = r \cdot e^{i\cdot \phi}</math>
Die konjugiert komplexe Zahl ist <math>z^* = \Re(z) - i \cdot \Im(z)</math>
== Mit komplexen Zahlen rechnen ==
z1 = 2 + 5im # kartesische Darstellung
z2 = 3 * exp(3im) # Polardarstellung
# Addition
res = z1 + z2
println("z1 + z2 = ", res)
# Multiplikation
res = z1 * z2
println("z1 * z2 = ", res)
# Realteil
res = real(z2)
println("Realteil von z2 = ", res)
# Imaginärteil
res = imag(z2)
println("Imaginaerteil von z2 = ", res)
# Betrag
res = abs(z1)
println("Betrag von z1 = ", res)
# Argument
res = angle(z1)
println("Argument von z1 = ", res)
# Konjugiert komplexe Zahl
res = conj(z1)
println("Konjugiert komplexe Zahl von z1 = ", res)
Ausgabe:
z1 + z2 = -0.9699774898013365 + 5.423360024179601im
z1 * z2 = -8.05675510050068 - 14.003167400647481im
Realteil von z2 = -2.9699774898013365
Imaginaerteil von z2 = 0.4233600241796016
Betrag von z1 = 5.385164807134504
Argument von z1 = 1.1902899496825317
Konjugiert komplexe Zahl von z1 = 2 - 5im
= Funktionen =
Um Programme zu strukturieren und einfacher zu gestalten können Programmteile in Funktionen ausgelagert werden. Eingebaute Funktionen haben wir schon kennengelernt (z.B. die Sinus-Funktion sin). Nun wollen wir sehen, wie man selbst solche Funktionen schreiben kann.
== Eine einfache Funktion schreiben ==
f(a, b) = a + b
println(f(2, 3))
Ausgabe:
5
== function ==
Datei <code>c:\tmp\func.jl</code>:
function add(a,b)
println(a + b)
end
Datei <code>c:\tmp\test1.jl</code>:
include("func.jl")
add(5, 11)
Folgendes wird ausgegeben, wenn wir die test1.jl-Datei ausführen
16
== Anonyme Funktionen ==
println(map(a -> 5a + 10, [2, 3]))
Ausgabe:
[20, 25]
== return ==
Datei <code>c:\tmp\func.jl</code>:
function add(a,b)
return a + b
end
Datei <code>c:\tmp\test1.jl</code>:
include("func.jl")
println(add(5, 11))
Folgendes wird ausgegeben, wenn wir die test1.jl-Datei ausführen
16
Auch die Rückgabe mehrerer Werte ist möglich.
Datei <code>c:\tmp\func.jl</code>:
function add(a, b)
return a + b, "Addition"
end
Datei <code>c:\tmp\test1.jl</code>:
include("func.jl")
x, y = add(10, 20)
println(x)
println(y)
Ausgabe:
30
Addition
== Optionale Argumente ==
Datei <code>c:\tmp\func.jl</code>:
function add(a, b = 100)
return a + b
end
Datei <code>c:\tmp\test1.jl</code>:
include("func.jl")
println(add(5, 11))
println(add(5))
Folgendes wird ausgegeben, wenn wir die test1.jl-Datei ausführen
16
105
== Schlüsselwort-Argumente ==
Datei <code>c:\tmp\func.jl</code>:
function add(a; b = 100)
return a + b
end
Man beachte, dass hier zwischen den Argumenten a und b kein Beistrich, sondern ein Semikolon steht.
Datei <code>c:\tmp\test1.jl</code>:
include("func.jl")
println(add(b=16, 5))
println(add(5, b=16))
println(add(5))
Ausgabe:
21
21
105
= Polynome =
Sofern noch nicht geschehen, fügen Sie das Paket <code>Polynomials</code> zum Julia-System hinzu.
== Ein erstes einfaches Beispiel ==
using Polynomials
println(Polynomial([1, 0, 5, 7]))
Ausgabe:
1 + 5*x^2 + 7*x^3
== Einzelne Polynomwerte berechnen ==
using Polynomials
p = Polynomial([1, 0, 5, 7]);
println(p(1.5))
Ausgabe:
35.875
== Polynome integrieren und differenzieren ==
using Polynomials
p = Polynomial([1, 0, 5, 7]);
i = integrate(p)
d = derivative(p)
println(i)
println(d)
Ausgabe:
1.0*x + 1.66667*x^3 + 1.75*x^4
10*x + 21*x^2
== Nullstellen bestimmen ==
using Polynomials
p = Polynomial([4, 0, 5, 2]);
r = roots(p)
println(r)
Ausgabe:
ComplexF64[-2.7621427020576714 + 0.0im, 0.13107135102883646 - 0.8407709868482356im, 0.13107135102883646 + 0.8407709868482356im]
== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms <math>y = 2x^4 - 3x^3 - x + 7</math>.
* Differenzieren und integrieren Sie das Polynom <math>y = 2x^4 - 3x^3 - x + 7</math>.
* Berechnen Sie die Nullstellen von <math>y = 7x^5 - 3x^2 + 12</math>.
= Lineare Gleichungssysteme =
Sei <math>Ax = b</math> ein lineares Gleichungssystem. <math>A</math> sei die Koeffizientenmatrix, <math>x</math> der Lösungsvektor und <math>b</math> ein bekannter Vektor.
Beispiel:
A = [5 1; 0 2]
b = [1, 2]
x = A \ b
println(x)
Ausgabe:
[0.0, 1.0]
= Interpolation =
Als erstes muss das Interpolations-Paket installiert werden. Wenn Sie nicht wissen, wie man das macht, so sehen Sie unter dem Abschnitt "Grafiken zeichnen" den Absatz "Plots installieren". Dort wird die Vorgehensweise detailliert beschrieben.
Datei "c:\tmp\test1.jl":
using Interpolations
using Plots
# Stützpunkte
xp = 1 : 1 : 5
yp = [0; -5; 2; 7; 6]
# Interpolationsfunktionen
lspl = LinearInterpolation(xp, yp, extrapolation_bc = Line())
cspl = CubicSplineInterpolation(xp, yp, extrapolation_bc = Line())
# Stützpunkte zeichnen
plot(xp,yp,marker=4,linetype=:scatter, label = "Data", title = "Interpolation")
# Interpolierende zeichnen
x = 1 : .1 : 5
plot!(x, lspl(x), label="Linearer Spline")
plot!(x, cspl(x), label="Kubischer Spline")
gui()
while true
end
Ausgabe:
[[Datei:Julia_interpol1.jpg]]
= Differenzialrechnung =
== Symbolische Differenziation ==
julia> using Calculus
julia> differentiate("sin(x)", :x)
Ausgabe:
:(1 * cos(x))
Auswertung:
julia> x = pi/2;
julia> round(eval(differentiate("sin(x)", :x)))
Ausgabe:
0.0
== Numerische Differenziation ==
julia> using Calculus
julia> derivative("sin", pi/2)
Ausgabe:
0.0
= Integralrechnung =
julia> using QuadGK
julia> integral, err = quadgk(x -> sin(x), 0, pi/2, rtol=1e-8)
Ausgabe:
(0.9999999999999999, 1.1102230246251565e-16)
Im Rahmen der Näherung ist das Resultat richtig (exakt sollte (1.0, 0.0) rauskommen).
= Gewöhnliche Differenzialgleichungen =
Das Paket <code>DifferentialEquations</code> ist, wie so viele andere, umfangreich. Hier sei nur ein einfaches Beispiel dargestellt. Für weiterführende Studien sei auf die entsprechenden Weblinks verwiesen.
Folgende Differentialgleichung sei gegeben: <math>y' = x^2 + y^3</math>.
using DifferentialEquations
using Plots
f(y, p, x) = x^2 + y^3
problem = ODEProblem(f, 0.0, (0.0, 1.0))
s = solve(problem, Tsit5(), reltol = 1e-8, abstol = 1e-8)
plot(s, title = "ODE")
gui()
while true
end
Ausgabe:
[[Datei:Julia_dgl1.jpg]]
= Ein- und Ausgabe =
== Dateien lesen ==
# Textdatei im aktuellen Verzeichnis öffnen
f = open("test1.jl")
# Lesen aus Datei
lines = readlines(f)
# Zeilenweise Ausgabe am Bildschirm
for l in lines
println("$l")
end
# Datei schließen
close(f)
Als Ausgabe erscheint exakt obiger Source-Code im Terminal.
== Dateien schreiben ==
open("test.txt", "w") do f
write(f, "Schreibe eine Zeile in Textdatei\n")
end
Der Inhalt der Datei "test.txt" ist dann:
Schreibe eine Zeile in Textdatei
= Benutzeroberflächen erstellen =
Hier wird nur eine (sehr) kurze Einführung in das Thema GUI mit Gtk (Gimp toolkit, [https://www.gtk.org/]) gegeben. Nähere Details siehe die Gtk.jl-Dokumentation ([https://juliagraphics.github.io/Gtk.jl/latest/]). Nachfolgend wird ein gegenüber der offiziellen Dokumentation abgewandeltes Beispiel gezeigt. Das ist nötig, um Gtk.jl unter Windows 10 zum Laufen (bzw. um ein Fenster angezeigt) zu bekommen. Das Problem scheint schon seit Langem bekannt zu sein, siehe [https://stackoverflow.com/questions/52589873/gtk-jl-julia-bindings-for-gtk-gtk-window-is-not-displayed-outside-the-repl Gtk.jl, Julia Bindings for Gtk: Gtk Window is not displayed outside the REPL].
using Gtk
win = GtkWindow("Hallo Welt", 400, 200)
b = GtkButton("Push the button")
push!(win,b)
c = Condition()
endit(w) = notify(c)
signal_connect(endit, win, :destroy)
showall(win)
wait(c)
Ausgabe:
[[Datei:Julia_gtk1.jpg]]
Ein etwas komplizierteres (aber zugegebenerweise noch nicht sehr schönes) Beispiel sei nachfolgend gezeigt. Es sollen zwei Strings miteinander verknüpft und ausgegeben werden.
using Gtk
win = GtkWindow("Stringverknüpfung")
hbox = GtkBox(:h)
push!(win, hbox)
e1 = GtkEntry()
l1 = GtkLabel("verknüpfe mit")
e2 = GtkEntry()
b = GtkButton("=")
l2 = GtkLabel(" ")
push!(hbox, e1)
push!(hbox, l1)
push!(hbox, e2)
push!(hbox, b)
push!(hbox, l2)
function on_button_clicked(b)
GAccessor.text(l2, get_gtk_property(e1, :text, String) * get_gtk_property(e2, :text, String))
end
signal_connect(on_button_clicked, b, "clicked")
c = Condition()
endit(w) = notify(c)
signal_connect(endit, win, :destroy)
showall(win)
wait(c)
Ausgabe (vor der Eingabe der Teilstrings):
[[Datei:Julia_gtk2.jpg]]
Ausgabe (nach der Eingabe der Teilstrings und dem Drücken des =-Buttons):
[[Datei:Julia_gtk3.jpg]]
= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Julia. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechenden weiterführenden Weblinks und die Julia-Hilfefunktion
verwiesen. Julia kennt noch viel mehr Befehle, als hier dargestellt wurden. Das Themenspektrum ist auch durch die Einbindung externer Pakete fast beliebig erweiterbar.
= Weblinks =
* [https://julialang.org/ Julia Homepage]
* [https://docs.julialang.org/en/v1/ Julia Dokumentation]
* [https://en.wikibooks.org/wiki/Introducing_Julia Englisches Wikibook zu Julia]
* [https://docs.makie.org/stable/ Makie - a data visualization ecosystem for Julia]
* [https://docs.juliaplots.org/latest/ Plots - powerful convenience for visualization in Julia]
* [https://www.matecdev.com/posts/julia-numerical-computing.html Numerical Computing in Julia]
* [https://www.matecdev.com/posts/julia-tutorial-science-engineering.html Julia Programming Tutorial]
* [https://juliapackages.com/p/polynomials Polynomials.jl]
* [https://github.com/JuliaMath/Calculus.jl Calculus.jl]
* [https://github.com/JuliaMath/QuadGK.jl QuadGK.jl]
* [https://docs.sciml.ai/DiffEqDocs/stable/ DifferentialEquations.jl: Efficient Differential Equation Solving in Julia]
* [https://nextjournal.com/sosiris-de/ode-diffeq# Solving ODEs in Julia]
* [https://juliagraphics.github.io/Gtk.jl/latest/ Gtk.jl]
{{Navigation_zurückhochvor_buch|
zurücktext=Octave|
zurücklink=Ing Mathematik: Numerische Mathematiksysteme am Beispiel von Octave|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Python für Ingenieure|
vorlink=Ing Mathematik: Python}}
d16qko2wr2fvxhr0hfeip4hguj7wwth
Ing Mathematik: Python
0
117969
1092406
1092397
2026-10-23T14:21:59Z
Intruder
1513
/* 2D */
1092406
wikitext
text/x-wiki
{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}
= Hallo Welt und allgemeine Hinweise =
== Was ist Python ==
* Python ist eine universelle höhere Programmiersprache.
* Python ist objektorientiert.
* Python ist Open-Source (Python Software Foundation License).
* Python ist für viele Betriebssysteme erhältlich (z.B. für Linux, MS Windows, macOS).
* Python ist ein Interpreter.
* Python ist durch Module fast beliebig erweiterbar.
* Python als Programmiersprache ist case-sensitive - d.h. Groß- und Kleinschreibung ist relevant bei der Eingabe von Befehlen.
* Python ist in etlichen Anwendungsprogrammen (z.B. {{W|FreeCAD}}, {{W|LibreOffice}}, {{W|GIMP}}, {{W|Blender (Software) | Blender}}) als Makrosprache verwendbar.
{{Wikipedia | Python (Programmiersprache)}}
== Python installieren ==
=== MS Windows ===
Laden Sie das aktuelle Python-Paket von der Webseite [https://www.python.org/] herunter. Weiter geht es wie bei jedem anderen größeren zu installierenden Programm. Einfach das Installationsprogramm im Explorer doppelklicken und den Anweisungen des Setup-Programmes folgen.
=== Linux ===
Entweder ist Python bereits standardmäßig installiert, ansonsten ist die Installation mittels Paketmanagementsystem einfach möglich. Aber auch die Spyder-Entwicklungsumgebung ([https://www.spyder-ide.org]) bietet einen guten Einstieg mit Python (das gilt auch für MS Windows). Spyder bringt auch schon etliche wichtige Module standardmäßig mit.
== Python starten ==
=== MS Windows ===
Das Icon für das Python-Programm doppelklicken. Und schon startet das Programm.
[[Datei:PythonIng_start1.jpg]]
Python im interaktiven Modus (REPL ... '''R'''ead-'''E'''valuate-'''P'''rint-'''L'''oop) präsentiert sich dann so:
Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun 6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
Alternativ kann das Programm auch über die Eingabeaufforderung oder die PowerShell gestartet werden:
c:\devel\Python>python.exe
Python 3.12.4 (tags/v3.12.4:8e8a4ba, Jun 6 2024, 19:30:16) [MSC v.1940 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
=== Linux ===
Tippen Sie einfach das Wort „python“ (oder unter openSUSE Tumbleweed z.B. auch „python3.11“ oder „python3.13“) in einem Linux-Terminal ein, schließen den Befehl mit der RETURN-Taste ab, und schon startet Python im interaktiven Modus:
Python 3.13.12 (main, Feb 09 2026, 22:37:44) [GCC] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
Es gibt auch noch andere Möglichkeiten Python zwecks Programmausführung zu starten, z. B. den {{W|Shebang}} (<code>#!</code>) am Beginn eines Python-Scripts. Das Script sei als Script.py gespeichert. Dann kann das Script mit ./Script.py ausgeführt werden. Für openSUSE Tumbleweed sei nachfolgend ein lauffähiges "Hallo Welt!"-Script angegeben. Es wird in diesem Script der Python-Interpreter in der Version 3.13 verwendet :
#!/usr/bin/python3.13
print("Hallo Welt!")
Die Berechtigungen zum Ausführen der Datei müssen natürlich noch richtig gesetzt werden, z.B. mittels <code>chmod 777 Script.py</code>. <small><code>chmod</code> ist die Abkürzung für"'''ch'''ange file '''mod'''e bits".</small>
<small>Die "Maske" <code>777</code> ist nur für Testzwecke sinnvoll, weil sie leicht zu merken ist und für alle Benutzer alle Zugriffsberechtigungen ('''r'''ead/'''w'''rite/e'''x'''ecute für owner/group/others) setzt. Im richtigen Einsatz wird man das aus Sicherheitsgründen nicht so handhaben, sondern nur die Berechtigungen setzen, die unbedingt erforderlich sind. Welche Zugriffsberechtigungen gesetzt sind, kann man z.B. mit dem Befehl <code>ls -l</code> oder <code>ll</code> ('''l'''i'''s'''t directory contents) erfragen. Aber dazu im Moment genug. Erfahrene Linux-Nutzer kennen das ohnehin und Anfänger sollen jetzt nicht mit Linux-Interna überfordert werden. Bei Bedarf siehe die Linux-Man-Pages oder dezidierte Bücher zu Linux.</code></small>
<small>Oder das Script wird in einen Pfad verschoben, in dem sich ausführbare Programme generell befinden (welche Verzeichnisse im PATH liegen, kann bspw. mit <code>echo $PATH</code> abgefragt werden). Das Script kann dann wie ein normales Programm ohne weitere Angaben mit Script.py gestartet werden. Alternativ wird nicht das Script an sich verschoben, sondern nur ein symbolischer Link angelegt, z.B. mit <code>ln -s ~/tmp/Script.py ~/.local/bin/Script.py</code>. <code>~/.local/bin</code> sei ein im PATH gelegenes Verzeichnis. Dies sind aber schon Features für fortgeschrittene Linux-Benutzer und werden am Anfang eher selten benötigt.</small>
== Ein paar Worte zur Erklärung ==
=== Tests ===
Getestet wurden die Beispiele unter den Betriebssystemen
* MS Windows 10 mit der Python-Version 3.12.0 (teilweise auch mit 3.12.2 und 3.13.1; nur die Inhalte die bis spätestens Juli 2025 erstellt wurden)
* MS Windows 11 ab der Python-Version 3.13.4 (nur zum Teil; ab Juli 2025)
* openSUSE Leap 15.6 mit der Python-Version 3.11.12 (Spyder, nur vereinzelt) und zum Teil mit 3.12.11 (ab Juli 2025 bis November 2025).
* openSUSE Tumbleweed ab der Python-Version 3.13.9 (nur vereinzelt, ab November 2025)
=== Popularität ===
* An Beliebtheit rangiert Python mit Stand September 2026 mit einem Rating von 17,76% an 1. Stelle vor C und C++ (lt. [https://www.tiobe.com/tiobe-index/ TPCI - TIOBE Programming Community Index]).
* Lt. [https://innovationgraph.github.com/global-metrics/programming-languages GitHub Top 50 Programming Languages Globally] lag Python im Q1/2026 auf Rang 2, vor TypeScript und hinter JavaScript.
* [https://pypl.github.io/PYPL.html PYPL] (Popularity of Programming Language Index) ist ein anderer Popularitätsindex für Programmiersprachen. Auch hier liegt Python mit großem Vorsprung auf dem ersten Platz (52,08%), gefolgt von Java (13,34%) und C/C++ (7,99%) (Stand September 2026).
=== Namensgebung ===
Der Name "Python" rührt von der Komikertruppe {{W|Monty Python}} her. Die Icons für Python (z.B. Python selbst, Eric IDE, IDLE) sind aber durch die Python-Schlangenart symbolisiert.
<gallery>
Python-logo-notext.svg|Python-Logo
Guido van Rossum in PyConUS24.jpg|{{W|Guido van Rossum}} (geb. 1956), der Erfinder von Python
</gallery>
== Ein erstes Programm ==
Kommentare werden in Python mit der Raute (#) eingeleitet. Sie werden vom Python-Interpreter ignoriert. Text kann mit der print-Funktion ausgegeben werden. Starten Sie Python und geben sie folgende Anweisungen zeilenweise ein
>>> # Das ist ein Kommentar
>>> print("Hallo Welt!")
Als Ergebnis erhalten Sie
Hallo Welt!
Der Prompt (>>>) ist selbstverständlich nicht einzutippen, sondern wird vom Python-System geliefert.
Strings können in Python entweder in Anführungszeichen (") gesetzt werden oder in Hochkommatas('). In diesem Text wird die erste Variante bevorzugt eingesetzt.
Im Gegensatz zu Julia ist es hier egal, ob zwischen <code>print</code> und der öffnenden Klammer Leerzeichen stehen.
= Python als Taschenrechner =
== Allgemeines ==
Wir wollen 3 * 5 berechnen. Dazu starten wir Python im interaktiven Modus. Geben Sie dann die Formel
>>> 3 * 5
ein, drücken die Taste ENTER/RETURN ({{Taste|↵}}) und erhalten als Ergebnis
15
Auch kompliziertere Ausdrücke sind möglich. Beispielsweise mit Winkelfunktionen, Quadratwurzeln etc. Wir wollen nun den Ausdruck <math>\sin\sqrt{15}</math> berechnen :
>>> import math
>>> math.sin(math.sqrt(15))
-0.6679052983383519
Als erstes wird das math-Modul importiert. Dann wird der mathematische Ausdruck berechnet.
Eine andere Variante, die dasselbe Ergebnis liefert, ist
>>> from math import *
>>> sin(sqrt(15))
-0.6679052983383519
Es wird also aus dem Modul <code>math</code> alles importiert (erkennbar am <code>*</code>). Will man nicht alles importieren, so kann man das auch einschränken:
>>> from math import sin, sqrt
Beenden lässt sich das Python-Programm durch Eingabe von <code>exit()</code> (und natürlich ist zur Bestätigung die RETURN-Taste zu drücken). <code>exit</code> (ohne Klammern) oder <code>quit</code> werden auch akzeptiert.
== Die Hilfefunktion von Python ==
Bei Eingabe der Anweisung <code>help</code> oder <code>help()</code> springt Python in den Hilfemodus.
Eingabe:
>>> help()
Eingabe:
help> math.sin
Ausgabe:
Help on built-in function sin in math:
math.sin = sin(x, /)
Return the sine of x (measured in radians).
Für die komplette Python-Dokumentation siehe [https://docs.python.org/3/]. Verlassen kann man den Hilfemodus durch das Drücken von STRG-C, bzw. der Eingabe von q, quit oder exit mit anschließendem Drücken der RETURN-Taste.
== Aufgaben ==
* Erkunden Sie die Tangensfunktion "tan" mittels Python-Hilfe (vergessen Sie nicht das math-Modul zu importieren und das <code>math.</code> vor <code>tan</code>)
* Berechnen Sie mit Python den Ausdruck <math>\frac{1}{2}\cdot \text{e}^2 \cdot \tan(\pi/3)</math>. Siehe für die Exponentialfunktion im Python-Hilfesystem auch den Befehl <code>math.exp</code>. Alternativ kann auch die Konstante <code>math.e</code> eingesetzt werden. Potenzieren kann man bei Python mit dem **-Operator (z.B. 2**3 = 8). Für <math>\pi</math> gibt es <code>math.pi</code>.
= Python als Scriptsprache =
Häufig wird man aber kompliziertere Anweisungsfolgen verarbeiten müssen. Diese will man normalerweise nicht jedesmal neu eingeben, sondern in einer Datei speichern und diese Datei dann zur Ausführung bringen. Speichern Sie dazu folgenden Code in einer Textdatei, z.B. unter MS Windows als c:\tmp\test1.py
# Das ist ein Kommentar
print("Hallo Welt!")
Python-Dateien werden mit der Dateiendung .py versehen. Achten Sie darauf, dass vor dem print keine Leerzeichen vorhanden sind. Das ist eine Python-Eigenheit. Wie wir später sehen werden, nutzt Python Einrückungen als syntaktisches Mittel, z.B. um bei Schleifen den Schleifenkörper zu kennzeichnen.
Danach bringen Sie die Skriptdatei test1.py (sozusagen das Hauptprogramm) folgendermaßen zur Ausführung:
1) Starten Sie unter MS Windows die Eingabeaufforderung (oder alternativ auch die Windows PowerShell). Das sieht dann etwa so aus:
Microsoft Windows [Version 10.0.19045.3693]
(c) Microsoft Corporation. Alle Rechte vorbehalten.
C:\Users\xyz>
: <small>Falls jemand nicht weiß, wie man die Eingabeaufforderung startet: Eine Möglichkeit ist, einfach in der Taskleiste von Windows das "Start"-Symbol ([[Image:Windows_logo_-_2021_(Black).svg|10px]]) mit der rechten Maustaste anklicken. "Ausführen" auswählen (oder alternativ für die PowerShell unter Windows 10 den Eintrag "Windows PowerShell", unter Windows 11 den Eintrag "Terminal"). Im sich öffnenden Dialogfenster gibt man in die "Öffnen"-Zeile das Wort <code>cmd</code> ein und mit "OK" wird das Ganze bestätigt.</small>
2) Wechseln Sie mittels <code>cd c:\tmp</code> in das Verzeichnis c:\tmp
3) Angenommen, Sie haben Python unter dem Pfad <code>c:\devel\Python\</code> installiert. Starten Sie das Programm so (der Prompt <code>c:\tmp></code>ist natürlich nicht mit einzutippen):
c:\tmp>c:\devel\Python\python.exe test1.py
4) Wie erwartet ergibt sich folgende Ausgabe am Bildschirm
Hallo Welt!
Die Vorgehensweise unter Linux ist prinzipiell gleich. Die kleinen Unterschiede, wie z.B. der Slash statt dem Backslash in Pfadangaben, sollten für Linux-Benutzer keine Hürde darstellen.
== Variablen ==
Variablenbezeichner können aus Buchstaben (A-Za-z), Ziffern (0-9) und Underscores (_) bestehen, dürfen aber nicht mit einer Zahl beginnen. Führende Underscores haben u.a. im Kontext mit der Objektorientierten Programmierung eine spezielle Bedeutung und sollten nicht für "normale" Variablenbezeichner verwendet werden.
Gültige Variablenbezeichner wären also:
xyz
x1
_wert
name_anzahl
Theoretisch kann man auch Umlaute, griechische Buchstaben u.ä. in Variablenbezeichnern nutzen, z.B.
ößÜ = 16
α = 134
print(ößÜ)
print(α)
Ausgabe:
16
134
Davon wird aber aus offensichtlichen Gründen ({{W|Englisch als Lingua franca}}) abgeraten. Das Eurozeichen (€) etc. darf man ohnehin nicht in Variablenbezeichnern verwenden, dies ergäbe einen Syntaxfehler. Siehe dazu auch [https://peps.python.org/pep-3131/].
Es gibt in Python etliche Schlüsselwörter (z.B. for, if oder return). Diese dürfen nicht als eigene Variablenbezeichner verwendet werden. Eine Liste aller Schlüsselwörter liefert das Script
import keyword
print(keyword.kwlist)
<small>Übung: Speichern Sie dieses Script in eine Datei, z.B. in c:\tmp\test1.py. Führen Sie diese Datei aus, um die Liste der Schlüsselwörter auszugeben.</small>
Da Python case-sensitiv ist, repräsentieren folgende Bezeichner verschiedene Variablen:
xyz
XYZ
xYz
Werte werden an Variablen mittels Gleich-Zeichen (=) zugewiesen. Im Folgenden wird der Code immer in der Datei c:\tmp\test1.py gespeichert.
x = 5
y = 10
z = x*y
print(z)
Bringen Sie die Datei test1.py zur Ausführung, so erhalten Sie folgende Bildschirmausgabe
50
Sie können auch mehrere Anweisungen in einer Zeile durch Semikolon getrennt schreiben. Dies führt aber zu unübersichtlichem Code.
x = 5; y = 10; z = x*y; print(z)
Ausgabe:
50
Auch aus der Programmiersprache C/C++ oder Java bekannte Konstrukte können Sie verwenden, z.B.
x = 5
# x = x - 2
x -= 2
print(x)
Bildschirmausgabe:
3
Beachten Sie, dass mit dem =-Zeichen eine Wertezuweisung durchgeführt wird. Dies ist nicht äquivalent zum mathematischen =-Zeichen, wie am vorigen Beispiel zu ersehen ist. Den Inkrement-/Dekrementoperator (z.B. x++ oder x--) aus C/C++ oder Java kennt Python aber nicht.
Variablen sind nicht an einen bestimmten Datentyp gebunden, folgendes ist mit Python problemlos möglich:
import math
wert = 10
print(wert)
wert = 35.5
print(wert)
wert = "Hallo"
print(wert)
wert = math.pi
print(wert)
Ausgabe:
10
35.5
Hallo
3.141592653589793
== Physische und logische Zeilen ==
In Python muss eine Anweisung in einer logischen Zeile Platz finden. Wird eine Anweisung aber zu lang für eine Zeile, dann kann sie in mehrere physische Zeilen unterteilt werden. Dies kann einerseits durch einen Backslash am Ende einer Zeile geschehen, z.B.
a = 2 + \
5
Dies stellt eine logische Zeile dar, die in zwei physische Zeilen unterbrochen ist.
Geklammerte Ausdrücke werden automatisch zu einer logischen Zeile verbunden, z.B.
a = (2 +
5)
Achtung: Im ersten Beispiel darf nach dem Backslash nichts mehr stehen, auch kein Kommentar. Dies trifft im zweiten Bespiel nicht zu, hier könnte noch ein Kommentar folgen, z.B.
a = (2 + # Kommentar
5)
Auch für Strings gibt es Möglichkeiten, diese auf mehrere Zeilen aufzuspalten.
# Kurzer String
str1 = "ABC"
# Langer String
str2 = """Hallo Welt,
Grüetzi Schwyzer,
Servus an alle"""
# Backslash
str3 = "UVW\
XYZ"
# Mit Klammern
str4 = ("Sehr langer Text, der automatisch .............. "
"in einer einzigen Variable zusammengefügt wird."
)
print(str1)
print(str2)
print(str3)
print(str4)
Ausgabe:
ABC
Hallo Welt,
Grüetzi Schwyzer,
Servus an alle
UVWXYZ
Sehr langer Text, der automatisch .............. in einer einzigen Variable zusammengefügt wird.
==Hexadezimale, oktale, binäre und andere Zahlen==
d = 1050 # Dezimalzahl
h = 0xAA2 # Hexadezimalzahl
o = 0o12 # Oktalzahl
b = 0b100001101 # Binärzahl
print(d)
print(h)
print(o)
print(b)
Ausgabe:
1050
2722
10
269
Groß- und Kleinbuchstaben sind in obigen Literalen übrigens egal. So kann man z.B. statt <code>0b1001</code> auch <code>0B1001</code> schreiben (siehe dazu [https://docs.python.org/3/reference/lexical_analysis.html#integer-literals]).
Sie können auch dezimale in hexadezimale Zahlen umwandeln, usw.:
h = hex(1050) # Dezimalzahl -> Hexadezimalzahl
b = bin(1050) # Dezimalzahl -> Binärzahl
o = oct(1050) # Dezimalzahl -> Oktalzahl
print(h)
print(b)
print(o)
Ausgabe:
0x41a
0b10000011010
0o2032
Gegeben sei die Zahl 121 zur Basis 3. Diese soll in eine Dezimalzahl umgewandelt werden. Das kann so geschehen:
z = int("121", 3)
print(z)
Ausgabe:
16
Dass dies richtig ist, davon kann man sich folgendermaßen überzeugen:
<math> 1 \cdot 3^2 + 2 \cdot 3^1 + 1 \cdot 3^0 = 9 + 6+ 1 = 16 </math>
Zahlen übersichtlicher schreiben kann man auch mittels Underscore, z.B.:
print("Eine Million (Variante 1) =", 1000000)
print("Eine Million (Variante 2) =", 1_000_000)
print("Eine Rechnung:", 2_000 * 400_000);
Es ergibt sich bei beiden Varianten die gleiche Ausgabe. Variante 2 ist aber im Sourcecode leichter lesbar, detto die Zahlen in der Rechnung:
Eine Million (Variante 1) = 1000000
Eine Million (Variante 2) = 1000000
Eine Rechnung: 800000000
Wie man auch die Ausgabe auf der Konsole darstellungstechnisch beeinflussen kann wird im nachfolgenden Abschnitt gezeigt.
== Strings und Platzhalter==
Ein paar einfache Beispiele:
print("Hallo {}" . format("Hugo")) # new style string formatting
print("Hallo {:s}" . format("Hugo")) # new style string formatting
print("Hallo %s" % "Hugo") # %-String
Ausgabe:
Hallo Hugo
Hallo Hugo
Hallo Hugo
Python-Code (formatted string literals, Beispiel 1):
str1 = "Hallo"
str2 = "Hugo"
print(f"{str1} {str2}")
Ausgabe:
Hallo Hugo
f-Strings (ab Python 3.6) sind die modernere Variante gegenüber %-Strings oder das ''new style string formatting''. Sie sind in der Regel auch schneller.
Python-Code (formatted string literals, Beispiel 2):
wert = 11.567
print(f"Ausgabe: {wert:.5f}")
Ausgabe:
Ausgabe: 11.56700
Komplexere Beispiele:
print("Hallo {} und {}" . format("Hugo", "Mike"))
print("Hallo {name1} und {name2}" . format(name2="Hugo", name1="Mike"))
# Füllzeichen: *
# Bündigkeit: > (=rechts), < (=links), ^ (=zentriert)
# Feldweite: 10
# Typ: s (=String), f (=Gleitkommazahl), d (=Dezimalzahl) etc.
print("Hallo {:*>10s}" . format("Hugo"))
print("Hallo {:*<10s}" . format("Hugo"))
Ausgabe:
Hallo Hugo und Mike
Hallo Mike und Hugo
Hallo ******Hugo
Hallo Hugo******
Python-Code:
str = "Hallo\t%s\t%7.2f\t%10.2e\t%i" % ("Hugo", 12.34567, 34.567, 264)
print(str)
Ausgabe:
Hallo Hugo 12.35 3.46e+01 264
Python-Code (Ganzzahlen und Gleitpunktzahlen mit f-Strings formatieren und ausgeben):
wert1 = 1_000_000
wert2 = 0.85
wert3 = 1234.567
print(f"Eine Million (Variante 1) = {wert1:_}") # _ als Tausendertrennzeichen
print(f"Eine Million (Variante 2) = {wert1:,}") # US-amerikanische Notation
print(f"In Prozent = {wert2:.0%}") # in Prozent
print(f"Gleitpunktzahl = {wert3:>12,.2f}") # [Mindestbreite][Tausendertrennzeichen].[Nachkommastellen]f
Ausgabe:
Eine Million (Variante 1) = 1_000_000
Eine Million (Variante 2) = 1,000,000
In Prozent = 85%
Gleitpunktzahl = 1,234.57
Python-Code (Gleitpunktzahl in Gleitkommazahl umwandeln (deutsche Schreibweise)):
import locale
locale.setlocale(locale.LC_ALL, 'de_DE.UTF-8')
wert = 12345.6789
print(f"{wert:n}") # rundet
print(locale.format_string("%.5f", wert, grouping=True)) # 5 Nachkommastellen, Tausendertrennpunkt
Ausgabe:
12.345,7
12.345,67890
Python-Code (innerhalb der geschweiften Klammern kann gültiger Python-Code stehen, z.B. mathematische oder String-Operationen):
wert = 10
string = "abc"
print(f"{wert + 5}")
print(f"{string.upper()}")
Ausgabe:
15
ABC
Weitere Informationen zu f-Strings sind [https://peps.python.org/pep-0498/ PEP 498 – Literal String Interpolation] zu entnehmen.
<small>Neu ab Python 3.14 sind sogenannte T-Strings (Template-Strings). Lt Google KI vom 21. Oktober 2026: ''Zusammengefasst sind T-Strings also wie „F-Strings mit Superkräften“''. Aber um uns nicht komplett mit derartigen Details zu verzetteln, wird hier nicht darauf eingegangen. Es betrifft auch weniger das Tätigkeitsfeld von Ingenieuren, sondern ist eher für Website-Entwickler (SQL-Injection-Schutz) u.dgl. von Bedeutung.</small>
== Unicode ==
Neben den bekannten ASCII-Zeichen lassen sich Zeichen auch mittels Unicode beschreiben. Griechische Buchstaben oder komplexere mathematische Operatoren - all das sollte kein Problem sein. Siehe auch {{W|Unicode}}, {{W|Liste der Unicodeblöcke}} und {{W|Unicodeblock Mathematische Operatoren}}. Im Folgenden werden ein paar Zeichen (Allquantor, Nabla-Operator, Existenzquantor), die man aus der Mathematik kennt, erzeugt.
ch1 = "\N{FOR ALL}"
ch2 = "\N{NABLA}"
ch3 = "\u2203"
print(ch1, ch2, ch3)
Ausgabe:
∀ ∇ ∃
<small>Diese Ausgabe ergibt sich z.B. mit der IDLE-Shell oder mit Cygwin. Beim Ausführen über die Windows-Eingabeaufforderung oder Windows PowerShell unter MS Windows 10 erfolgt keine korrekte Darstellung. IDLE ist die mit Python mitgelieferte IDE ('''I'''ntegrated '''D'''evelopment '''E'''nvironment, Integrierte Entwicklungsumgebung). Gegen Ende dieses Textes wird IDLE kurz beschrieben.
Das Problem mit der Windows Eingabeaufforderung lässt sich aber umgehen. Man muss nur eine Schriftart auswählen, die die Zeichen kennt, z.B. "DejaVu Sans Mono". Dazu klicken Sie einfach bei der Eingabeaufforderung mit der rechten Maustaste oben auf die weiße Leiste und wählen im aufpoppenden Fenster den Menüpunkt "Eigenschaften". Es öffnet sich ein Dialogfenster. Über den Reiter "Schriftart" lässt sich nun die Schriftart einstellen. Unter MS Windows 11 oder openSUSE Leap 15.6 (bash-Konsole) gibt es dieses Problem ohnehin nicht.</small>
== Reguläre Ausdrücke ==
Python kennt auch {{W|Regulärer Ausdruck|reguläre Ausdrücke}}. Dazu gibt es in Python das Modul <code>re</code>. Beipielsweise sollen alle Zahlen (<math>\text{zahl}\in\mathbb{N}_0</math>) in einem String gesucht und ausgegeben werden. Als String sei gegeben: <code>3x Grüße und 100 Kekse.</code> Das Muster (Pattern) ist <code>\d+</code>. <code>\d</code> steht für eine Dezimalziffer 0-9. Das Plus-Zeichen (+) steht symbolisch für ein oder mehrere Zeichen des vorherigen Ausdrucks. Hier also ein oder mehrere Dezimalziffern. Es wird die Funktion <code>findall</code> aus dem Modul <code>re</code>verwendet.
Python-Code:
from re import findall
str = "3x Grüße und 100 Kekse."
pat = "\\d+" # Doppel-Backslashes müssen verwendet werden, sonst gibt Python eine Warnung aus!
# alternativ: pat = r"\d+"
# oder: pat = "[0-9]+"
numb = findall(pat, str)
print(numb)
Ausgabe:
['3', '100']
Python kennt noch viele weitere Möglichkeiten mittels regulärer Ausdrücke zu hantieren. Dies soll hier aber nicht vertieft werden, da das Thema schon ziemlich speziell und komplex ist. Bei Bedarf siehe aber z.B. die Bücher ''Weigend, Seite 380ff'' und ''Ernesti, Kaiser'' [https://openbook.rheinwerk-verlag.de/python/28_001.html] oder die Python-Dokumentation [https://docs.python.org/3/library/re.html]. Auch [[Python unter Linux: Reguläre Ausdrücke]] liefert ein umfangreiches und brauchbares Python-2-Kapitel zu den regulären Ausdrücken. Die dort gelisteten Beispiele müssten ggf. vor Verwendung auf Python-3 umgeschrieben werden. <small>Wie macht man das? Dazu siehe z.B. [https://openbook.rheinwerk-verlag.de/python/43_001.html], [https://portingguide.readthedocs.io/en/latest/] oder [https://www.digitalocean.com/community/tutorials/how-to-port-python-2-code-to-python-3]</small>
<small>Es gibt auch ein externes Modul ''regex'', das bei Bedarf extra installiert werden muss ([https://pypi.org/project/regex/]). Es bietet zusätzliche Funktionalität und gründlicheren Unicode-Support. Dies sei hier aber nur der Vollständigkeit halber erwähnt.</small>
== Verzweigungen ==
=== if ===
Die IF-Verzweigung sei aus anderen Programmiersprachen bereits bekannt. In {{W|Pseudocode}} lässt sie sich folgendermaßen darstellen:
WENN bedingung TRUE
führe block1 aus
SONST
führe block2 aus
ENDE
Als {{W|Aktivitätsdiagramm|UML-Aktivitätsdiagramm}} sieht das in etwa so aus:
[[File:If-Then-Else-diagram.svg|200px]]
Und als {{W|Nassi-Shneiderman-Diagramm|Nassi-Shneiderman-Struktogramm}} so:
[[File:Zweiseitige Auswahl.png|250px]]
In Python gibt es keinen expliziten ENDE-Kennzeichner. Stattdessen wird der Code durch Einrückungen strukturiert. Alles mit der gleichen Einrückungstiefe gehört zum selben Block. Dies zeichnet Python vor anderen Programmiersprachen aus.
Die test1.py-Datei laute also wie folgt:
x = 5
if x < 4:
print("x ist kleiner als 4")
else:
print("Der else-Zweig wird ausgefuehrt")
print("x ist groesser oder gleich 4")
Ausgabe:
Der else-Zweig wird ausgefuehrt
x ist groesser oder gleich 4
Man achte auch auf die Doppelpunkte in der if- und else-Zeile. Darauf vergisst man gerne, wenn man von anderen Programmiersprachen kommt.
Folgendes wäre in Python ein Fehler (genauer gesagt ein IndentationError).
x = 5
if x < 4:
print("x ist kleiner als 4")
else:
print("Der else-Zweig wird ausgefuehrt")
print("x ist groesser oder gleich 4")
Auch Nachstehendes würde nicht zum gewünschten Ergebnis führen (löst aber keine Fehlermeldung aus). Der letzte print-Befehl ist schon außerhalb der IF-ELSE-Verzweigung.
x = 3
if x < 4:
print("x ist kleiner als 4")
else:
print("Der else-Zweig wird ausgefuehrt")
print("x ist groesser oder gleich 4")
Ausgabe:
x ist kleiner als 4
x ist groesser oder gleich 4
Python kennt eine Reihe von Vergleichs- und Verknüpfungsoperatoren:
<, <= ... kleiner (gleich)
>, >= ... größer (gleich)
== ... gleich
!= ... ungleich
is ... identisch
is not ... nicht identisch
and ... AND
or ... OR
not ... NOT
Beispielsweise:
a = 5
b = 9
if a<=10 and b!=7:
print("OK")
else
print("Nicht OK")
Ausgabe:
OK
Der else-Block kann übrigens auch ersatzlos entfallen. Als Pseudocode sieht das so aus
WENN bedingung TRUE
führe block aus
ENDE
Mehrfache Verzweigungen werden durch das elif-Konstrukt erstellt. In Pseudocode:
WENN bedingung1 TRUE
führe block1 aus
SONST WENN bedingung2 TRUE
führe block2 aus
SONST WENN bedingung3 TRUE
führe block3 aus
SONST
führe block4 aus
ENDE
Ein Python-Beispiel:
a = 14
if a<=10:
print("<=10")
elif a>=11 and a<=15:
print("11 bis 15")
elif a>=16 and a<=20:
print("16 bis 20")
else:
print(">20")
Ausgabe:
11 bis 15
In Python gibt es auch die Schlüsselwörter <code>True</code> (für wahr) und <code>False</code> (für falsch). Man beachte, dass sie mit Großbuchstaben beginnen. Andere Schreibweisen wären ein Fehler. Sie gehören zum Datentyp <code>bool</code>. Ihnen sind auch die Zahlen <code>1</code> und <code>0</code> zugewiesen.
Man beachte, dass {{W|Rundungsfehler}} auftreten können. D.h. man sollte bei der Verwendung von {{W|Gleitkommazahl|Gleitpunktzahlen}} niemals auf absolute Genauigkeit prüfen, sondern eine Toleranz (einen <math>\varepsilon</math>-Wert) vorgeben.
Ein klassisches Beispiel, das ein falsches Ergebnis liefert, ist:
i = 0.1 + 0.2
print(i)
if i == 0.3:
print("OK")
else:
print("NOK")
Ausgabe:
0.30000000000000004
NOK
Und das, obwohl man schon in der Volksschule lernt, dass 0.1 + 0.2 gleich 0.3 ist.
Korrekt muss das obige Beispiel z.B. so umgeschrieben werden:
ist = 0.1 + 0.2
soll = 0.3
epsilon = 0.000001
print(ist)
if abs(ist-soll) < epsilon:
print("OK")
else:
print("NOK")
Ausgabe:
0.30000000000000004
OK
Alternativ kann auch die <code>math.isclose()</code>-Funktion verwendet werden. Das sei aber hier nur erwähnt und nicht konkret ausgeführt.
<u>Aufgabe:</u> Recherchieren Sie im Internet zum Thema <code>math.isclose()</code>-Funktion.
=== match ===
Ab Python 3.10 gibt es auch die match-Anweisung. Dies ist das Python-Pendant für die switch-Anweisung in anderen Programmiersprachen, geht aber bei näherer Betrachtung weit darüber hinaus (z.B. kann man Guards oder Structural Pattern Matching verwenden). Hier nur ein einfaches Beispiel:
x = "Hello"
match x:
case "Servus" | "Ciao": # or
print("Servus an alle")
case "Grüetzi":
print("Grüetzi Schwyzer")
case _: # other, default, sonstiges ...
print("Hallo Welt")
Ausgabe:
Hallo Welt
Als Struktogramm sieht das in etwa so aus:
[[File:Mehrseitige Auswahl.png|250px]]
Für nähere Details siehe z.B. [https://www.geeksforgeeks.org/python-match-case-statement/], [https://learnpython.com/blog/python-match-case-statement/], [https://docs.python.org/3/tutorial/controlflow.html#match-statements] und das Python Enhancement Proposal (PEP) 636 – Structural Pattern Matching: Tutorial [https://peps.python.org/pep-0636] und dort insbesondere den Anhang A - Quick Intro.
<small><code>match, case, _</code> etc. sind sogenannte ''soft keywords''. Im Gegensatz zu den normalen Schlüsselwörtern dürfen ihnen auch Werte zugewiesen werden. Eine Liste der weichen Schlüsselwörter lässt sich durch <code>keyword.softkwlist</code> erstellen (die Anweisung gibt es seit Python 3.9). Siehe dazu auch [https://stackoverflow.com/questions/65800344/what-are-soft-keywords] und [https://docs.python.org/3/library/keyword.html#keyword.softkwlist].</small>
<u>Aufgaben</u>:
* Recherchieren Sie im Internet zum Begriff "Guard" im Zusammenhang mit dem match-Konstrukt. Was ist der Unterschied zu einer normalen if-else-Verzweigung? Wann verwendet man if-else und wann Guards?
* Recherchieren Sie im Internet zum Begriff "Structural Pattern Matching" im Zusammenhang mit dem match-Konstrukt.
* Wie kann man bei der match-Anweisung "Strukturen entpacken"? Recherchieren Sie im Internet.
== Schleifen ==
Kopfgesteuerte Schleife, Endlosschleife und fußgesteuerte Schleife:
[[File:Programmingloops.svg|450px]]
=== while ===
Die WHILE-Schleife ist kopfgesteuert. Sie funktioniert wie aus anderen Programmiersprachen bekannt.
In Pseudocode:
SOLANGE bedingung TRUE
führe block aus
ENDE
In Python:
x = 0
while x <= 10:
print(x)
x += 1
Ausgabe:
0
1
2
3
4
5
6
7
8
9
10
Eine Endlosschleife ergibt sich z.B. so:
i = 5
while True:
print(i)
i-=1
Beendet werden kann sie mit der Tastenkombination STRG-C.
Eine fußgesteuerte Schleife kann so simuliert werden:
i = 5
while True:
print(i)
i-=1
if i<=0:
print("Fire")
break
Ausgabe:
5
4
3
2
1
Fire
Der <code>break</code>-Befehl wird etwas [[Ing_Mathematik:_Python#break|später]] noch einmal kurz thematisiert.
=== for ===
Struktogramm einer for-Schleife:
[[File:Zählschleife.png|200px]]
In Python bspw. so:
for x in range(6):
print(x*2)
Ausgabe:
0
2
4
6
8
10
Die Schleife läuft von 0 bis 5. Ausgegeben wird jeweils der Wert x*2. Aquivalent kann diese Schleife auch so geschrieben werden:
for x in range(0, 11, 2):
print(x)
Die Ausgabe ist wie oben. Der Startwert sei 0, der Endwert ist 11-1 und die Schrittweite ist 2.
Ein anderes Beispiel sei
for x in "text":
print(x)
Ausgabe:
t
e
x
t
== Schleifen abbrechen ==
=== break ===
<code>break</code> bricht die Schleife ab und setzt mit dem nächsten Befehl außerhalb der Schleife fort.
for var in range(100):
print(var)
if var == 5:
break
Ausgabe:
0
1
2
3
4
5
=== continue ===
<code>continue</code> bricht den aktuellen Schleifendurchlauf ab und setzt mit dem nächsten Schleifendurchlauf fort.
for var in range (11):
if var == 5:
continue
print(var)
Ausgabe:
0
1
2
3
4
6
7
8
9
10
== try - except ==
try:
z1 = 12 / 0
print(z1)
except ZeroDivisionError:
print("Das Ergebnis ist unendlich")
except:
print("Kann nicht berechnet werden!")
print("Bitte die Formel korrigieren!")
print("Setze Programm fort!")
Ausgabe:
Das Ergebnis ist unendlich
Setze Programm fort!
Es wird versucht, eine Zahl durch Null zu dividieren. Das ist nicht möglich, es wird eine Ausnahme ausgelöst. Das Programm springt daher in den except-ZeroDivisionError-Block und führt die dort gelisteten Anweisungen aus (in unserem Fall eine print-Anweisung). Danach wird das Programm fortgesetzt. Würden wir dieses Programm ohne try-except ausführen, so ergibt sich aus
z1 = 12 / 0
print(z1)
folgende Fehlermeldung und ein unmittelbarer Programmabbruch
Traceback (most recent call last):
File "C:\tmp\test1.py", line 1, in <module>
z1 = 12 / 0
ZeroDivisionError: division by zero
Mit dem try-except-Mechanismus können also Ausnahmen oder Fehler aufgefangen und behandelt werden. In unserem Beispiel ist das eher trivial, aber bei größeren Programmen kann das durchaus Sinn machen.
Neu in Python 3.14 ist, dass mehrere Ausnahmen auch ohne Klammern angegeben werden können, z.B.:
bis inkl. Python 3.13 nur:
except (ZeroDivisionError, ValueError):
ab Python 3.14 auch:
except ZeroDivisionError, ValueError:
== pass ==
Ein leerer Block muss in Python mittels dem Schlüsselwort <code>pass</code> dargestellt werden. Z.B.
x = 2
if x == 1:
print("Wert ist ", x)
else:
pass
Würde man das <code>pass</code> im else-Block weglassen, so würde man eine Fehlermeldung erhalten:
IndentationError: expected an indented block after 'else' statement on line 5
= Funktionen =
== Aufrufen von Funktionen ==
Funktionen sind uns im Rahmen dieses Kurses schon zuhauf begegnet. Sei es die print()-, die math.sin()- oder die hex()-Funktion. All diese Funktionen werden von Python zur Verfügung gestellt, ohne dass man sie explizit programmieren müsste. Aufgerufen werden diese Funktionen, indem man ihren Namen eintippt, gefolgt von runden Klammern. In diesen Klammern können noch Argumente übergeben werden. Auch Rückgabewerte sind möglich.
== Funktionen selber schreiben ==
Funktionen werden mit dem def-Schlüsselwort (man definiert die Funktion) eingeleitet, danach folgt der Funktionsname, danach wiederum runde Klammern, in denen formale Argumente stehen können. Abgeschlossen wird die def-Zeile mit einem Doppelpunkt. Danach folgt der Funktionskörper. Dieser Funktionskörper muss wiederum eingerückt werden (wie von den Verzweigungen und Schleifen bekannt). Aufgerufen wird diese Funktion, indem man ihren Funktionsnamen eingibt, gefolgt von runden Klammern (ggf. mit den aktuellen Parametern). Z.B.
# Funktion definieren
def halloWelt(i):
# i ... beliebige Ganzzahl
print("Hallo " * i, end="")
print("Welt!")
# Funktion aufrufen
halloWelt(3)
Ausgabe:
Hallo Hallo Hallo Welt!
Unterschied zwischen formalen und aktuellen Parametern:
[[Datei:PythonIng_func1.jpg]]
<small>Aktuelle Parameter werden auch Argumente genannt.</small>
Rückgabe von Funktionswerten:
# Funktion definieren
def mathFunc(a, b):
r1 = a + b
r2 = a * b
return r1, r2
# Funktion aufrufen
c, d = mathFunc(3, 5)
# Ausgabe der zurückgegebenen Werte
print(c)
print(d)
Ausgabe:
8
15
Es werden r1 und r2 zurückgegeben und den Variablen c und d zugewiesen. (r1, r2) und (c, d) sind Tupel. Was Tupel konkret sind, siehe etwas später in diesem Kapitel. 3 und 5 sind die aktuellen Parameter (die Argumente). a und b sind die formalen Parameter. Die Zuweisung der aktuellen zu den formalen Parametern erfolgt in der gegebenen Reihenfolge, also die Zahl 3 wird an a übergeben und die Zahl 5 an b.
Vorgabeparameter, z.B.:
def mathFunc(a=10, b=20):
r1 = a + b
r2 = a * b
return r1, r2
c, d = mathFunc(3, 5)
print(c)
print(d)
e, f = mathFunc(5)
print(e)
print(f)
g, h = mathFunc(b=6)
print(g)
print(h)
Ausgabe:
8
15
25
100
16
60
Erklärung:
* Erster <code>mathFunc</code>-Aufruf: Es werden, wie weiter oben, die Argumente 3 und 5 an die formalen Parameter a und b übergeben. Die Rückgabewerte r1 und r2 werden an c und d übergeben. Somit ist c=8 und d=15.
* Zweiter <code>mathFunc</code>-Aufruf: Es wird nur das Argment 5 an a übergeben. b behält den Vorgabewert 20. D.h. e= 25 und f=100.
* Dritter <code>mathFunc</code>-Aufruf: Es wird nur die Zahl 6 an b übergeben, a behält seinen Vorgabewert 10. Somit ergibt sich g=16 und h=60.
Beispiel (Schlüsselwortargumente vs. Positionsargumente):
def mathFunc(a, b):
r1 = a - b
r2 = a / b
return r1, r2
c, d = mathFunc(b=3, a=5) # Schlüsselwortargumente
e, f = mathFunc(3, 5) # Positionsargumente
print(c)
print(d)
print(e)
print(f)
Ausgabe:
2
1.6666666666666667
-2
0.6
Durch die Verwendung von Schlüsselwortargumenten können die Argumente in beliebiger Reihenfolge angegeben werden. Bei den Positionsargumenten ist die Reihenfolge vorgegeben. Daraus resultiert auch der Unterschied bei den obigen Ausgaben. Werden beide Arten in einem Aufruf gemischt, so müssen die Positionsargumente zuerst angegeben werden. Den Unterschied zwischen beiden Argumentarten zu kennen ist wichtig, nicht nur bei selbst erstellten Funktionen. Auch beim Aufruf von Python-Funktionen verfolgt einen die Mischung von Schlüsselwort- und Positionsargumenten auf Schritt und Tritt, z.B. beim etwas später folgenden Abschnitt über "Grafiken zeichnen":
plt.plot(x, y1, label = "cosh(x) + 2**x", lw=5, ls="dotted")
Bei dieser <code>plot</code>-Funktion aus dem Modul <code>matplotlib.pyplot</code> sind <code>x</code> und <code>y1</code> Positionsargumente. <code>label, lw</code> und <code>ls</code> sind die Namen der Schlüsselwortargumente. Die Schlüsselwortargumente könnten auch in anderer Reihenfolge angeschrieben werden, nicht jedoch die Positionsargumente!
Siehe zu <code>matplotlib.pyplot.plot</code> auch die Seite [https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html].
== Lambda-Funktionen ==
print((lambda a, b: a*b) (3, 5))
Ausgabe:
15
Eingeleitet wird eine Lambda-Funktion (auch Lambda-Form, Lambda-Operator oder anonyme Funktion genannt) mit dem Schlüsselwort <code>lambda</code>. Es folgen die formalen Argumente, danach ein Doppelpunkt, die Berechnungsvorschrift und ggf. abschliessend in Klammern die aktuellen Parameter.
Man kann einer Lambda-Funktion auch einen Funktionsnamen geben und die Funktion über diesen Namen aufrufen, z.B.
prod = lambda a, b: a*b
print(prod(3, 5))
Als Ausgabe wird wieder die Zahl 15 geliefert.
== Rekursive Funktionen ==
Funktionen können wiederum andere Funktionen aufrufen. Von einem {{W|Rekursion|rekursiven Funktionsaufruf}} spricht man, wenn die aufgerufene Funktion gleich der aufrufenden ist.
def printFunc(i):
if (i >= 5):
return
else:
print("Hallo Welt")
printFunc(i+1)
printFunc(1)
Ausgabe:
Hallo Welt
Hallo Welt
Hallo Welt
Hallo Welt
Typische Beispiele für die Abarbeitung als rekursive Funktionen sind die {{W|Fibonacci-Folge}} und die {{W|Fakultät_(Mathematik)|Fakultät}}. Jedoch ist der iterative Ansatz (mit konventionellen Schleifen) meist schneller und speicherplatzschonender.
== Funktionsannotationen ==
Python ist sehr flexibel, was Typen angeht. Im Vorhergehenden haben wir generell keine Typangaben gemacht. Will man Typen angeben, so bietet Python das Konzept der Funktionsannotation.
def calcFunc(a: int, b: int) -> int:
return a+b
r1 = calcFunc(8, 9)
r2 = calcFunc(8.0, 9.0)
r3 = calcFunc("Hallo", "Welt")
print(r1)
print(r2)
print(r3)
Ausgabe:
17
17.0
HalloWelt
Jetzt sieht man auf den ersten Blick, welche Typen der Programmierer im Sinn hatte, als er die Funktion erstellte. Das Problem dabei ist nur, dass es Python ziemlich egal ist, welche Typen man im Endeffekt eingibt. Im obigen Beispiel können statt Integer-Typen u.a. auch Float- oder String-Typen eingegeben werden.
<small>
Siehe zum Thema "Type Checking" aber auch den später folgenden Abschnitt [[Ing_Mathematik:_Python#Type_Checker]].
</small>
== Variadische Funktionen ==
Python-Code:
def test1(a, *b):
print(a);
for c in b:
print(c);
test1("Hallo", "Welt", "Schweizer", "und alle anderen")
Ausgabe:
Hallo
Welt
Schweizer
und alle anderen
Mit dem Stern (auch als Splat-Operator bezeichnet) in der formalen Parameterliste bei der Funktion <code>test1</code> wird angezeigt, dass eine beliebige Anzahl von Argumenten übergeben wird. <small> Dies entspricht in etwa dem, was in anderen Programmiersprachen (PHP etc.) mittels Ellipse (<code>...</code>) angezeigt wird.</small>
= Tupel, Listen und andere =
[[Datei:Python 3. The standard type hierarchy.png|mini|hochkant=1.7|Datentypen und Strukturen]]
== Tupel und Listen ==
Tupel, Listen und einige andere sind Datenstrukturen oder Sequenzen.
Listen (z.B. eine Einkaufsliste) sind veränderbar (mutable). Ein Tupel kann dagegen nicht verändert werden (immutable). Listen werden beim Anlegen in eckige Klammern eingeschlossen, Tupel in runde Klammern. Beim Tupel können die Klammern auch weggelassen werden. Ein Tupel mit nur einem Element muss mit einem Beistrich abgeschlossen werden. Der Grund ist, dass Python sonst nicht entscheiden kann, ob ein Tupel angelegt werden soll, oder nur ein geklammerter Wert.
Als Gedächtnisstütze kann man sich den Unterschied zwischen Tupel und Liste ev. so leichter merken:
: T'''u'''pel ... r'''u'''nde Klammern, '''u'''nveränderlich
: L'''i'''ste ... eck'''i'''ge Klammern, veränderl'''i'''ch.
Nachfolgend werden einige Operationen mit Listen und Tupel dargestellt.
# Liste und Tupel
liste = [1, 2, "Hallo"]
tupel = (1, 2, "Hallo")
# Ausgabe von liste und tupel
print(liste)
print(tupel)
# Ausgabe von Einzelelementen
print(liste[1])
print(tupel[2])
# Element an Liste anhängen und einfügen
liste.append(55)
liste.insert(4, "Welt")
print(liste)
# Element aus Liste entfernen
liste.remove(1)
print(liste)
# einige weitere Beispiele
liste2 = [1,]
tupel2 = 1, 2
tupel3 = (1,)
print(liste2)
print(tupel2)
print(tupel3)
Ausgabe:
[1, 2, 'Hallo']
(1, 2, 'Hallo')
2
Hallo
[1, 2, 'Hallo', 55, 'Welt']
[2, 'Hallo', 55, 'Welt']
[1]
(1, 2)
(1,)
Beispiel (eine Liste von Wörtern zu einem einzigen zusammenhängenden Text verbinden):
woerter = ["Hallo", "Welt"]
satz = " ".join(woerter)
print(satz)
Ausgabe:
Hallo Welt
== Dictionaries und Mengen ==
Zu den Datenstrukturen gehören weiters auch Mengen und Dictionaries. Mengen sind von der Mathematik bekannt, sie sind ungeordnet und es kommen keine mehrfachen Elemente vor. Dictionaries sind durch Schlüssel :Wert-Paare gekennzeichnet. Mengen werden beim Anlegen wie Dictionaries in geschweifte Klammern eingeschlossen.
dict = {"vorname":"Hugo", "nachname":"Meister" }
menge = {1, 1, 3, 4, 4, 4, "Hallo"}
print(dict)
print(menge)
print(dict["vorname"])
Ausgabe:
{'vorname': 'Hugo', 'nachname': 'Meister'}
{1, 3, 4, 'Hallo'}
Hugo
Geschweifte Klammern ohne Inhalt stellen Dictionaries dar und keine Mengen:
di = {}
print(type(di))
Ausgabe:
<class 'dict'>
Leere Mengen lassen sich mit <code>set()</code> erzeugen:
menge = set() # leere Menge
print(menge)
menge.add("Hallo") # Element hinzufügen
print(menge)
Ausgabe:
set()
{'Hallo'}
Beispiel (einige Mengenoperationen):
mengeA = {"Hallo", "Welt"}
mengeB = {1, 2, "Welt", 3}
# Vereinigung
print(mengeA | mengeB)
print(mengeA.union(mengeB))
# Durchschnitt
print(mengeA & mengeB)
print(mengeA.intersection(mengeB))
# Differenz
print(mengeA - mengeB)
print(mengeA.difference(mengeB))
# Symmetrische Differenz
print(mengeA ^ mengeB)
print(mengeA.symmetric_difference(mengeB))
# Teilmenge
print(mengeA.issubset(mengeB))
# Mehrere Elemente hinzu
mengeA.update(["Super", 67, 125])
print(mengeA)
# Element löschen
mengeA.discard("Hallo")
print(mengeA)
Ausgabe:
{1, 2, 3, 'Welt', 'Hallo'}
{1, 2, 3, 'Welt', 'Hallo'}
{'Welt'}
{'Welt'}
{'Hallo'}
{'Hallo'}
{1, 2, 3, 'Hallo'}
{1, 2, 3, 'Hallo'}
False
{67, 'Super', 'Welt', 'Hallo', 125}
{67, 'Super', 'Welt', 125}
Es gibt schon seit "ewigen" Zeiten unveränderbare Mengen, die mittels <code>frozenset</code> eingeleitet werden. Neu ab Python 3.15 ist dagegen das Pendant <code>frozendict</code>, das unveränderbare Dictionaries darstellt.
fdict = frozendict({"vorname":"Hugo", "nachname":"Meister"})
fset = frozenset({"A", 1, "A"})
print(fdict)
print(fdict["vorname"])
print (fset)
try:
fdict["vorname"] = "Max"
print(fdict["vorname"])
except TypeError as e:
print(f"Fehler: {e}")
try:
fset.add("B")
print(fset)
except AttributeError as e:
print(f"Fehler: {e}")
Ausgabe:
frozendict({'vorname': 'Hugo', 'nachname': 'Meister'})
Hugo
frozenset({1, 'A'})
Fehler: 'frozendict' object does not support item assignment
Fehler: 'frozenset' object has no attribute 'add'
== List Comprehensions ==
Aus einer Eingabeliste soll eine Ausgabeliste erzeugt werden. Das kann folgendermaßen geschehen.
Mathematische Schreibweise: <math>lc = \{2x|x\in\ \mathbb{N}, 1\le x < 11\}</math>
Python-Code:
lc = [x*2 for x in range(1,11)]
print(lc)
Ausgabe:
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
Mathematische Schreibweise: <math>lc = \{2x | x \in \mathbb{N}, 1\le x < 11, x \bmod 2 = 0 \}</math>
Python-Code:
lc = [x*2 for x in range(1,11) if x%2 == 0]
print(lc)
Ausgabe:
[4, 8, 12, 16, 20]
Siehe auch {{W|List Comprehension}}.
== Set Comprehensions ==
Dies ist sehr ähnlich wie im vorigen Abschnitt beschrieben. Es wird aber keine Liste, sondern eine Menge erzeugt.
sc = {x*2 for x in range(1,11)}
print(sc)
Ausgabe:
{2, 4, 6, 8, 10, 12, 14, 16, 18, 20}
== Listen zusammenführen - zip() ==
li1 = ["A", "B", "C", "D"]
li2 = [1, 2, 3, 4]
li3 = [5.5, 6.6, 7.7, 8.8]
z = zip(li1, li2, li3)
print(z)
li4 = list(z)
print(li4)
Ausgabe:
<zip object at 0x00000283B6C6AC80>
[('A', 1, 5.5), ('B', 2, 6.6), ('C', 3, 7.7), ('D', 4, 8.8)]
== Generatorausdruck ==
g = (i*2 for i in range(1,11))
print(g)
t = tuple(g)
print(t)
print(t[1:3])
Ausgabe:
<generator object <genexpr> at 0x00000241D2A4A5A0>
(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
(4, 6)
== Slicing ==
slice ... Scheibe, Teil, in Scheiben schneiden
Beispiel: Zugriff auf Elemente eines geordneten sequentiellen Objekttyps (Liste, Tupel oder String):
str1 = "Hallo"
# Das erste Element wird mit dem Index 0 angesprochen
# [start (inkl.) : stop (exkl.) : step (default=1)]
str2 = str1[0:2]
# Alternativ auch: str2 = str1[:2]
print(str2)
tup1 = (0,1,2,3)
# Das letzte Element hat auch den Index -1, das vorletzte den Index -2 usw.
tup2 = tup1[-3:-1]
print(tup2)
lst1 = [[1, 5, 10, 20],
[30, 40, 50, 60]]
lst2 = lst1[1][1]
print(lst2)
Ausgabe:
Ha
(1, 2)
40
Beispiel:
x = ("a", "b", "c", "d", "e")
print(x[2])
print(x[-3])
print(x)
print(x[:])
print(x[2:])
print(x[:2])
print(x[::-1])
Ausgabe:
c
c
('a', 'b', 'c', 'd', 'e')
('a', 'b', 'c', 'd', 'e')
('c', 'd', 'e')
('a', 'b')
('e', 'd', 'c', 'b', 'a')
Visualisierung:
'''a''' '''b''' '''c''' '''d''' '''e'''
+-----------------------------+
| 0 | 1 |//'''2'''//| 3 | 4 |
+-----------------------------+
| -5 | -4 |/'''-3'''//| -2 | -1 |
+-----------------------------+
|/////////////////////////////|
+-----------------------------+
|/////////////''':'''///////////////|
+-----------------------------+
| | |///////'''2:'''////////|
+-----------------------------+
|////''':2'''/////| | | |
+-----------------------------+
|\\\\\<--\\\\\'''::-1'''\\\\<--\\\\\|
+-----------------------------+
Beispiel:
x = ("a", "b", "c", "d", "e")
print(x[2::2])
print(x[2::-1])
print(x[2:0:-1])
Ausgabe:
('c', 'e')
('c', 'b', 'a')
('c', 'b')
Hier sieht man sehr schön, dass beim letzen <code>print</code>-Befehl die 0, die in diesem Fall den Buchstaben "a" repräsentiert, als letzer Wert nicht mehr dazugehört (wie weiter oben angedeutet ist der End- oder Stoppwert exklusiv). Will man den Buchstaben "a" dazunehmen, so ist die vorletzte Zeile die richtige.
Beispiel: Umdrehen von Strings
str1 = "Hallo"
str2 = str1[::-1]
print(str2)
Ausgabe:
ollaH
Mit zweidimensionalen Listen/Tupels wird das Ganze schon bedeutend komplexer.
Beispiel: Verkettetes Slicing
A = [["00", "01", "02", "03"],
["10", "11", "12", "13"],
["20", "21", "22", "23"],
["30", "31", "32", "33"],
["40", "41", "42", "43"]]
print(A[2::][::2])
Ausgabe:
[['20', '21', '22', '23'], ['40', '41', '42', '43']]
Das erste Slicing erstellt folgenden Slice:
[["20", "21", "22", "23"],
["30", "31", "32", "33"],
["40", "41", "42", "43"]]
Das zweite Slicing wird dann auf diesen Slice angewendet und ergibt das genannte Endergebnis. Will man Spalten statt Zeilen, so funktioniert dieser direkte Weg nicht. Man verwendet dann List Comprehensions oder die NumPy-Bibliothek. Diese Bibliothek erlaubt [[Ing_Mathematik:_Python#Zugriff_auf_Matrizenelemente|zweidimensionales Slicing]]. Sie wird erst später bei den Grafiken eingeführt. Deshalb wird hier dazu noch kein Beispiel gezeigt.
= Objektorientierte Programmierung =
{{Wikipedia|Objektorientierte Programmierung}}
* {{W|Klasse (Objektorientierung)|Klasse}} ... die Schablone oder der Bauplan, enthält Methoden und Attribute
* {{W|Objekt (Programmierung)|Objekt}} ... eine Klasseninstanz (die konkrete Ausprägung der Klasse)
* {{W|Attribut (Programmierung)|Attribute}} ... die Eigenschaften eines Objekts
* {{W|Methode (Programmierung)|Methoden}} ... die Aktionen (Operationen), die ein Objekt ausführen kann
* {{W|Vererbung (Programmierung)|Vererbung}} ... neue Klassen (Subklassen, Unterklassen, abgeleitete Klassen) aus vorhandenen Klassen (Superklassen, Oberklassen, Basisklassen, Elternklassen) ableiten. Ermöglicht den Aufbau von Klassenhierarchien. Die Subklasse "erbt" Attribute und Methoden von der Superklasse. Python unterstützt (so wie C++, aber im Gegensatz zu Java) Mehrfachvererbung.
== UML ==
* {{W|Unified Modeling Language|UML}} ... '''U'''nified '''M'''odeling '''L'''anguage, eine Modellierungssprache. Die UML enthält zahlreiche Diagrammarten, um Programme zu modellieren. Im Nachfolgenden wird nur das {{W|Klassendiagramm}} verwendet.
[[File:UmlCd Klasse-3.svg|300px]]
* {{W|Sichtbarkeit (Programmierung)|Sichtbarkeit}}:
** + ... public (öffentlich)
** - ... private
** # ... protected
* {{W|Attribut_(UML)#Attribute_für_Instanzen_und_für_Klassen|Klassenattribute}} (statische Attribute): Werden nur einmal pro Klasse angelegt. Im Klassendiagramm werden sie unterstrichen.
[[File:Attribute-3.png|200px]]
* Vererbung:
<gallery>
InheritancePgmUML.svg | Abgeleitete Klasse erbt von Basisklasse (Einfachvererbung)
Diamond inheritance.svg | D erbt von B und C (Mehrfachvererbung). B und C erben von A (Einfachvererbung)
</gallery>
Für weitergehende Betrachtungen zur UML wird auf Spezialliteratur verwiesen, z.B.:
* Seidl et al.: UML@Classroom. dpunkt, 2012, ISBN 978-3-89864-776-2
* Rupp et al.: UML 2 glasklar. Hanser, 4. Aufl., 2012, ISBN 978-3-446-43057-0
== Eine einfache Klasse ==
[[Datei:PythonIng_uml1.svg | 200px]]
class Fahrzeug:
raeder = 4
def __init__(self, geschwindigkeit, leistung):
self.__geschwind = geschwindigkeit
self.__leistung = leistung
def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
self.__geschwind = geschwindigkeit
def setLeistung(self, leistung):
self.__leistung = leistung
def convertGeschw(self):
# geschwindigkeit in m/s rueckgeben
return self.__geschwind / 3.6
fahr = Fahrzeug(150, 90)
print(fahr.convertGeschw())
Ausgabe:
41.666666666666664
Die Klasse Fahrzeug wird durch das class-Schlüsselwort eingeleitet. raeder ist ein Klassenattribut und public. __init__ wird bei der Objekterzeugung automatisch aufgerufen (ist der sogenannte Konstruktor). Man achte darauf, dass diese Methode immer mit zwei Unterstrichen eingeleitet und abgeschlossen wird. Instanzattributen wird das Wort self vorangestellt. Wir sehen uns z.B. das Attribut self.__geschwind an. Auch hier werden zwei Unterstriche verwendet. Das bedeutet, dass dieses Attribut strikt/stark private ist. Wird nur ein Unterstrich verwendet, so deutet dies auf schwach/weakly private hin. Letzteres wird in Python deutlich häufiger verwendet. Bei den Methoden wird immer self als erster Parameter angegeben. Beim Aufruf der entsprechenden Funktion wird das self aber nicht berücksichtigt.
Besonderheiten bei stark und schwach private:
* '''stark private''':
** zwei führende Unterstriche
** Name Mangling: Name wird zu <code>_Klassenname__variablenname</code>
** Schutz vor Namenskollisionen bei Vererbung
** am Ende des Namens dürfen keine zwei Unterstriche verwendet werden. Das wären dann Magic Methods oder Dunder-Methods (z.B. __init__). Diese sind public.
* '''schwach private''':
** ein führender Unterstrich
** Name bleibt gleich
** ist nur ein Hinweis an die Programmierer, kein starker Schutz
** <code>from modul import *</code>: Objekte mit einem führenden Unterstrich werden standardmäßig nicht importiert
** Standard für die Kapselung bei Python. Schätzung: Weit mehr als 80% der nicht-öffentlichen Attribute/Methoden werden als schwach private deklariert. Weniger als 5-10% als stark private (Quelle: Google KI)
== Klassen importieren ==
Häufig ist es sinnvoll und übersichtlicher Klassen in eigenen Dateien zu speichern. Das sind dann eigene Module. Abgespeichert werden Sie mit der Endung py, wie bisher auch praktiziert. Aufgerufen werden Sie mit der import-Anweisung. Dann ist aber nur der Dateiname ohne Endung py zu verwenden. Klarer wird das mit einem Beispiel.
Datei c:\tmp\fahrzeug.py
class Fahrzeug:
raeder = 4
def __init__(self, geschwindigkeit, leistung):
self.__geschwind = geschwindigkeit
self.__leistung = leistung
def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
self.__geschwind = geschwindigkeit
def setLeistung(self, leistung):
self.__leistung = leistung
def convertGeschw(self):
# geschwindigkeit in m/s rueckgeben
return self.__geschwind / 3.6
Datei c:\tmp\test1.py
import fahrzeug
fahr = fahrzeug.Fahrzeug(150, 90)
print(fahr.convertGeschw())
Ausgabe:
41.666666666666664
Die üblichen import-Anweisungen lauten wie folgt:
{| {{prettytable}}
! import-Befehl
! Instanz
|-
| import xyz || xyz.Klasse
|-
| import xyz as x || x.Klasse
|-
| from xyz import Klasse || Klasse
|-
| from xyz import * || Klasse
|}
Der Vorteil der ersten beiden import-Anweisungen ist, dass es kaum zu Namenskollisionen kommen kann. Dafür hat man bei den letzten beiden Varianten weniger Tipparbeit.
== Vererbung ==
=== Einfachvererbung ===
[[Datei:PythonIng_uml2.svg | 200px]]
Datei fahrzeug.py:
class Fahrzeug:
raeder = 4
def __init__(self, geschwindigkeit, leistung):
self.__geschwind = geschwindigkeit
self.__leistung = leistung
def setGeschwindigkeit(self, geschwindigkeit): # geschwindigkeit in km/h
self.__geschwind = geschwindigkeit
def setLeistung(self, leistung):
self.__leistung = leistung
def convertGeschw(self):
# geschwindigkeit in m/s rueckgeben
return self.__geschwind / 3.6
class Luftfahrzeug(Fahrzeug):
def __init__(self, geschwindigkeit, leistung, fluegel):
super().__init__(geschwindigkeit, leistung)
self.__flueg = fluegel
def getFlueg(self):
return self.__flueg
Datei test1.py:
import fahrzeug
fahr = fahrzeug.Luftfahrzeug(150, 90, 4)
print(fahr.getFlueg())
Ausgabe:
4
=== Mehrfachvererbung ===
Mit Python ist auch Mehrfachvererbung möglich, z.B.:
class A:
def _printA(self):
print("Klasse A")
class B:
def _printB(self):
print("Klasse B")
class C(A,B):
def __init__(self):
self._printA()
self._printB()
c = C()
Ausgabe:
Klasse A
Klasse B
Die Klasse C erbt von A und B. In UML sieht das in etwa so aus:
+-----------------------------+ +-------------------------+
| A | | B |
+-----------------------------+ +-------------------------+
| | | |
+-----------------------------+ +-------------------------+
| # printA() | | # printB() |
+-----------------------------+ +-------------------------+
. .
/ \ / \
--- ---
| |
| |
+---------------------+
| C |
+---------------------+
| |
+---------------------+
| |
+---------------------+
<code>printA()</code> und <code>printB()</code> sind schwach private (in UML als <code>protected</code> mit einem # dargestellt). Es ist aber zu beachten, dass schwach private nur Konvention ist. Praktisch könnte man auch von außerhalb auf diese Methoden zugreifen. Das soll man aber nicht tun, und das wird in Python durch einen Unterstrich angedeutet.
== Statische Attribute, statische Methoden und Klassenmethoden ==
Beispiel:
class Math:
pi = 3.14159265
cnt = 0
@staticmethod
def expo():
return 2.71828183
@classmethod
def counterPlus(cls):
cls.cnt += 1
print(Math.pi)
print(Math.expo())
Math.counterPlus()
print(Math.cnt)
Math.counterPlus()
print(Math.cnt)
Math.counterPlus()
print(Math.cnt)
Ausgabe:
3.14159265
2.71828183
1
2
3
Statische Attribute und Methoden, bzw. Klassenmethoden, sind direkt einer Klasse zugeordnet und nicht einem Objekt. Der Unterschied zwischen statischen Methoden und Klassenmethoden ist, dass statische Methoden nicht auf Klassenattribute (bzw. statische Attribute) zugreifen können, Klassenmethoden aber schon. <code>pi</code> und <code>cnt</code> sind statische Attribute. <code>expo()</code> ist eine statische Methode. <code>counterPlus(cls)</code> ist eine Klassenmethode. Die Bezeichnung des Parameters als <code>cls</code> ist reine Konvention, man sollte sich aber daran halten. <code>@staticmethod</code> und <code>@classmethod</code> nennt man auch Dekoratoren.
= Grafiken zeichnen =
Für das Zeichnen von Grafiken wird hier das Modul <code>matplotlib</code> verwendet. <code>matplotlib</code> ist ein externes Modul und muss vor der ersten Verwendung installiert werden. Das geht so:
# Starten Sie ein Terminal (bei Windows die Eingabeaufforderung).
# Führen Sie darin folgenden Befehl aus <code>c:\devel\Python\Scripts\pip.exe install matplotlib</code>
pip ist übrigens der Paketmanager von Python ({{W|Pip_(Python)}}).
Optimalerweise installieren wir auch gleich das Modul <code>numpy</code> (Numerical Python). Wir werden es im Folgenden oft benötigen (nicht nur bei den Grafiken). Das funktioniert vom Prinzip her genauso, wie für <code>matplotlib</code> gezeigt.
<small>Verwenden Sie Spyder, so sind diese Schritte nicht nötig. Spyder inkludiert diese Pakete standardmäßig. Unter openSUSE Tumbleweed lassen sich diese Pakete mittels YaST oder zypper installieren.</small>
== 2D ==
=== Graph einer Funktion ===
Es soll die cosh-Funktion im Intervall <math>x\in[-3,3]</math> gezeichnet werden. Der Programmcode lautet in der einfachsten Form:
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(-3., 3.1, .1)
y = np.cosh(x)
plt.plot(x,y)
plt.grid()
plt.show()
Ausgabe:
[[Datei:PythonIng_cosh1.jpg]]
Der Code ist quasi selbsterklärend. Das Untermodul pyplot des matplotlib-Moduls und das numpy-Modul werden importiert. x läuft von -3 bis +3. y wird für jeden x-Wert per Formel ausgerechnet. "plt.plot()" ist der Zeichenbefehl. "plt.show" ist notwendig, um das Fenster mit der Grafik anzuzeigen.
Die Schrittweite 0.1 wurde so gewählt, um einen ausreichend glatten Verlauf des Graphen zu gewährleisten. Das ist immer ein Kompromiss zwischen Berechnungszeit und Ansehnlichkeit. Testen Sie einfach ein paar verschiedene Werte, um ein Gefühl dafür zu zu bekommen. "plt.grid()" zeichnet ein Gitter in die Grafik (kann auch weggelassen werden).
Die Bezeichnungen plt und np könnten auch anders gewählt werden. Es ist aber Konvention, diese so wie hier gezeigt zu wählen. Die "arange"-Funktion aus der NumPy-Bibliothek wird später ein bisschen genauer behandelt (siehe [[Ing_Mathematik:_Python#Zahlenfolgen|Zahlenfolgen]]).
<small>Mit der im obigen Bild gezeigten Menüleiste kann die dargestellte Grafik nachträglich noch geändert werden (Zoom, Pan, Achsenparameter, Kurvenparameter etc.). Natürlich kann man das alles auch direkt programmieren. Wie das funktioniert wird ansatzweise etwas später gezeigt.</small>
Ein etwas komplexeres Beispiel ist Folgendes:
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(-3., 3.1, .1)
y = np.cosh(x) + 2**x
plt.plot(x,y)
plt.grid()
plt.show()
Ausgabe:
[[Datei:PythonIng_cosh4.png]]
Man beachte, dass im Gegensatz zu Octave und Julia der ominöse Punkt (.) bei 2**x mit Python nicht benötigt wird. Das macht das Programmiererleben etwas einfacher.
Die Farbe des Graphen kann man über den <code>color</code>-Schalter einstellen, z.B. auf rot setzen:
plt.plot(x, y, color="red")
Das ist nur eine Möglichkeit, es gibt auch andere, z.B. mittels
* hexadezimaler Zahl, z.B. <code>color="#ff0000"</code>
* Kurzform, z.B. <code>"r"</code>
Statt <code>color</code> kann auch die Kurzform <code>c</code> verwendet werden.
<u>Kleine Aufgabe:</u> Probieren Sie diese "Farbspielereien" am Computer aus.
<small>''Exkurs:'' Neu ab Python 3.15 sind sogenannte "lazy imports". Diese können für schwergewichtige oder große Python-Bibliotheken, wie matplotlib, numpy, scipy, pandas etc. kürzere Startzeiten und geringeren Speicherbedarf bringen. Nachteilig ist u.a., dass die Fehlerbehandlung diffiziler und eine statische Analyse des Codes schwieriger ist. Im Programmcode sieht das dann so aus (die drei Punkte stehen nachfolgend stellvertretend für das entsprechende Modul etc.):
lazy import ...
lazy from ... import ...
<code>lazy</code> ist ein sogenanntes soft keyword. Nicht möglich ist z.B.
lazy from ... import *
Dies ergibt einen Syntaxfehler. Da dieses Feature mit Stand Oktober 2026 noch nagelneu ist, wird es nachfolgend nicht verwendet. Bei Interesse siehe aber z.B. [https://docs.python.org/3.15/reference/simple_stmts.html#lazy-imports].</small>
=== Graphen mehrerer Funktionen und weiteres ===
==== Mehrere Funktionen in einen Plot zeichnen ====
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(-3., 3.1, .1)
y1 = np.cosh(x) + 2**x
y2 = np.sin(x) * np.cos(x)
plt.plot(x, y1, label = "cosh(x) + 2**x")
plt.plot(x, y2, label = "sin(x) * cos(x)")
plt.grid()
plt.title("Funktionsgraphen")
plt.xlabel("x")
plt.ylabel("y")
plt.legend(loc="best")
plt.show()
[[Datei:PythonIng_cosh2.png]]
Um die Linienstile etwas individueller zu gestalten, ist folgender Programmcode gedacht:
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(-3., 3.1, .1)
y1 = np.cosh(x) + 2**x
y2 = np.sin(x) * np.cos(x)
plt.plot(x, y1, label = "cosh(x) + 2**x", lw=5, ls="dotted")
plt.plot(x, y2, label = "sin(x) * cos(x)", lw=3, ls="--")
plt.grid()
plt.title("Funktionsgraphen")
plt.xlabel("x")
plt.ylabel("y")
plt.legend(loc="best")
plt.show()
[[Datei:PythonIng_cosh3.png]]
Einige weitere Bespiele zu <code>ls</code></code>:
* - ... durchgezogene Linie
* -. ... Strichpunkt-Linie
* dashed ... gestrichelte Linie
==== Marker ====
Desweiteren kann man Marker verwenden.
Beispiel:
import matplotlib.pyplot as plt
plt.plot(10, 10, "ob", markersize=30)
plt.plot(20,20, ".r")
plt.plot(30,30, "Dg", ms=15)
plt.plot(40, 40, "ok", ms=20, mec="#FF5733", mew=3)
plt.plot(50, 50, "vk", ms=20, mec="yellow", mew=3)
plt.grid()
plt.show()
Das erste Zeichen im String nach den Koordinaten im plot-Befehl symbolisiert die Form (z.B. o für einen Kreis). Das zweite Zeichen steht für die Farbe (z.B. b für blue). <code>markersize</code> oder <code>ms</code> setzt die Größe des Markers.
Ausgabe:
[[Bild:PythonIng_formatpara1.svg|200px]]
Einige weitere Marker:
* * ... Stern
* + ... Plus
* h oder H ... Sechseck
Man kann mit den Parametern
* <code>markeredgecolor</code> oder kurz <code>mec</code> die Farbe des Markerrandes
* <code>markeredgewidth</code> oder kurz <code>mew</code> die Dicke des Randes
* <code>markerfacecolor</code> oder kurz <code>mfc</code> die Innenfarbe des Markers
bestimmen.
=== Funktion in Parameterdarstellung ===
Es soll die archimedische Spirale <math>x = t \cos(t), y = t \sin(t)</math> im Intervall <math>[0, 6\pi[</math> gezeichnet werden.
import matplotlib.pyplot as plt
import numpy as np
t = np.arange(0., 6*np.pi, .1)
x = t * np.cos(t)
y = t * np.sin(t)
plt.plot(x, y)
plt.grid()
plt.title("Archimedische Spirale")
plt.show()
[[Datei:PythonIng_spirale1.png]]
Diese Darstellung erscheint verzerrt. Will man gleiche Achsenskalierungen, so kann man den plt.axis()-Befehl verwenden.
import matplotlib.pyplot as plt
import numpy as np
t = np.arange(0., 6*np.pi, .1)
x = t * np.cos(t)
y = t * np.sin(t)
plt.plot(x, y)
plt.grid()
plt.title("Archimedische Spirale")
plt.axis("equal")
plt.show()
[[Datei:PythonIng_spirale2.png]]
=== Funktion in Polardarstellung ===
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_subplot(projection="polar")
r = np.arange(0, 1, 0.01)
theta = r**3
line = ax.plot(theta, r)
plt.show()
[[Datei:PythonIng_polar1.png]]
=== Logarithmische Achsenskalierung ===
==== Semilog ====
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(0., 10, .1)
y = 10**x
plt.plot(x, y)
plt.grid()
plt.semilogy()
plt.show()
Ausgabe:
[[Datei:PythonIng_semilog1.png]]
==== LogLog ====
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(0., 10, .1)
y = 10**x
plt.plot(x, y)
plt.grid()
plt.loglog()
plt.show()
[[Datei:PythonIng_loglog1.png]]
=== Gefüllte Fläche ===
import numpy as np
import matplotlib.pyplot as plt
x = np.arange(0, 3, 0.1)
y1 = 3*x - 1
y2 = x**2
plt.plot(x, y1, x, y2, color='black')
plt.fill_between(x, y1, y2, where=y1>=y2)
plt.show()
[[Datei:PythonIng_gefuellt.png]]
=== Linien, Pfeile, Rechtecke, Kreise und Texte ===
import matplotlib as mpl
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
r = mpl.patches.Rectangle((0, 0), 3, 3, angle=30, fill=False)
c = mpl.patches.Circle((4, 4), 2, fill=False)
ax.add_patch(r)
ax.add_patch(c)
ax.plot([-2, 7], [-2, 0], color="black")
ax.arrow(0, 7, 5, 0, length_includes_head=True, head_width=0.5, head_length=1.5,
color="black")
ax.set_aspect("equal")
plt.axis([-3, 8, -3, 8])
plt.show()
[[Datei:PythonIng_linien_pfeile_etc.png]]
Text kann mit <code>ax.text(x, y, "Text")</code> hinzugefügt werden, bspw.
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.text(0.1, 0.1, "Hallo")
ax.text(0.5, 0.5, "Welt", size="40", family="cursive", style="italic",
rotation=30.0)
plt.show()
Oder einfacher auch ohne <code>subplots</code>
import matplotlib.pyplot as plt
plt.text(0.1, 0.1, "Hallo")
plt.text(0.5, 0.5, "Welt", size="40", family="cursive", style="italic",
rotation=30.0)
plt.show()
[[Datei:PythonIng_text1.png]]
Auch Sonderzeichen (griechische Buchstaben etc.) können verwendet werden (siehe dazu auch [https://matplotlib.org/stable/users/explain/text/mathtext.html]).
import matplotlib.pyplot as plt
plt.text(.3, .5,
r'$\Omega\ \psi\ \oint\ \nabla\ \dot a\ \frac{a}{b}\ a_b$',
size="20")
plt.show()
[[Datei:PythonIng_text20.svg]]
Jetzt wird noch gezeigt, wofür <code>subplots</code> sinnvoll eingesetzt werden können.
import matplotlib.pyplot as plt
fig, ax = plt.subplots(nrows=1, ncols=2)
ax[0].text(0.1, 0.1, "Hallo")
ax[1].text(0.1, 0.5, "Welt", size="40", family="cursive", style="italic",
rotation=30.0)
plt.show()
[[Datei:PythonIng_text2.png]]
=== Anmerkungen hinzufügen ===
Anmerkungen (engl. annotations) lassen sich mit matplotlib einfach hinzufügen. Unter Anmerkung wird hier ein Pfeil mit Text verstanden.
Beispiel:
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.plot([1,10], [1,10])
ax.annotate("Test", xy=(2, 2), xytext=(3, 5),
arrowprops=dict(facecolor="red", shrink=0.0))
plt.show()
Ausgabe:
[[Datei: PythonIng_ann1.svg|400px]]
<code>shrink</code> verkürzt den Pfeil. Sinnvoll sind beim obigen Beispiel Werte irgendwo zwischen 0.0 und 0.3.
<u>Kleine Aufgabe:</u> Probieren Sie verschiedene Pfeillängen aus.
Die Schriftgröße verändern können Sie übrigens mit <code>fontsize</code> oder <code>size</code>, z.B.
ax.annotate("Test", xy=(2, 2), xytext=(3, 5),
arrowprops=dict(facecolor="red", shrink=0.0), fontsize=25)
Eine andere Schreibweise für Dictionaries, die wir weiter oben schon kennengelernt haben, die wir aber nochmals explizit aufschreiben wollen, ist
ax.annotate("Test", xy=(2, 2), xytext=(3, 5),
arrowprops={"facecolor":"red", "shrink":0.0})
=== Figure, Axes etc.===
[[Bild:PythonIng_figure33.svg|350px]]
* fig (figure) ... das übergeordnete Fenster
* ax (axes) ... "Plot", das eigentliche Zeichenfenster
* axis ... die Koordinatenachsen
* spine ... Begrenzungslinien des Zeichenfensters
* tick ... Markierung an den Achsen des Zeichenfensters
Beispiel (eine figure mit 6 axes, ax-Titel, y-axis-Titel):
import matplotlib.pyplot as plt
fig, ax = plt.subplots(nrows=3, ncols=2)
ax[0][0].text(0.1, 0.5, "11")
ax[0][1].text(0.1, 0.5, "12")
ax[1][0].text(0.1, 0.5, "21")
ax[1][1].text(0.1, 0.5, "22")
ax[2][0].text(0.1, 0.5, "31")
ax[2][1].text(0.1, 0.5, "32")
ax[0][0].set(ylabel="y-label", title="axes 1")
plt.show()
[[Bild:PythonIng_figure34.png|350px]]
Beispiel (Achsenbereiche setzen):
import matplotlib.pyplot as plt
fig, ax = plt.subplots(nrows=1, ncols=2)
ax[0].text(5, 5, "Hallo Welt")
ax[1].text(.5, .5, "Servus")
ax[0].axis((-1, 10, 1, 12))
plt.show()
[[Bild:PythonIng_figure35.svg|350px]]
Beispiel (Gitter einschalten):
import matplotlib.pyplot as plt
fig, ax = plt.subplots(nrows=1, ncols=2)
ax[0].text(5, 5, "Hallo Welt")
ax[1].text(.5, .5, "Servus")
ax[0].axis((-5, 10, 1, 12))
ax[0].minorticks_on()
ax[0].grid(which='minor')
ax[1].grid(which='major')
plt.show()
[[Bild:PythonIng_figure36.svg|350px]]
Beispiel (ticks setzen)
import matplotlib.pyplot as plt
import matplotlib.ticker as tick
fig, ax = plt.subplots()
ax.text(0.1, 0.5, "11")
pos = [0, .2, .5]
lab = ["a", "b", "c"]
ax.xaxis.set_major_locator(tick.FixedLocator(pos))
ax.xaxis.set_major_formatter(tick.FixedFormatter(lab))
plt.show()
[[Bild:PythonIng_figure37.svg|350px]]
Beispiel (Achsenkreuz beliebig setzen):
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.text(0.1, 0.5, "11")
ax.spines['top'].set_color('none')
ax.spines['right'].set_color('none')
ax.spines['bottom'].set_position(('data', 0.3))
ax.spines['left'].set_position(('data', 0.5))
plt.show()
[[Bild:PythonIng_figure38.svg|350px]]
Beispiel (Inset):
import matplotlib.pyplot as plt
# Hauptplot erstellen
fig, ax = plt.subplots()
ax.text(0.1, 0.1, "Hallo")
# Inset hinzu:
axin = ax.inset_axes([0.4, 0.4, 0.3, 0.3])
axin.text(0, 0, "Servus")
axin.plot()
plt.show()
[[Bild:PythonIng_figure40.svg|350px]]
Beispiel (Hintergrundfarben setzen):
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.set_facecolor("green")
fig.set_facecolor("yellow")
plt.plot([1, 3], [6, 8])
plt.show()
[[Bild:PythonIng_figure39.svg|300px]]
=== GridSpec ===
Mit figures und axes lassen sich schon jede Menge an Grafikdetails einstellen. GridSpec ist dann der Turbo oder Raketenantrieb den matplotlib eingebaut hat. Naja, vielleicht ist das etwas übertrieben, aber GridSpec ist sozusagen ein flexibler Layout-Manager. Bisher haben wir immer gleich große axes gezeichnet. Mit GridSpec können wir Subplots über mehrere Zeilen und Spalten ziehen.
Beispiel:
import matplotlib.pyplot as plt
import matplotlib.gridspec as gs
fig = plt.figure(constrained_layout=True)
gs = fig.add_gridspec(3, 3)
ax1 = fig.add_subplot(gs[0, :])
ax1.set_title("Bereich 1: gs[0, :]")
ax2 = fig.add_subplot(gs[1:, 0])
ax2.set_title("Bereich 2: gs[1:, 0]")
ax3 = fig.add_subplot(gs[1, 1:])
ax3.set_title("Bereich 3: gs[1, 1:]")
ax4 = fig.add_subplot(gs[2, 1:])
ax4.set_title("Bereich 4: gs[2, 1:]")
plt.show()
[[Bild:PythonIng_gridspec1.svg|350px]]
Erklärung zu <code>(gs[zeile, spalte])</code>: Slicing; damit legen Sie fest, welche Zellen ein Subplot belegt. Achtung! Die Indizes beginnen bei 0 und nicht bei 1 (d.h., die erste Zeile/Spalte hat den Index 0)
* : ... alle
* 1: ... 1 bis Ende
* etc.
<code>constrained_layout=True</code> sorgt dafür, dass sich die Subplots nicht überlappen.
Aber auch die Spaltenbreiten und Zeilenhöhen lassen sich anpassen.
Beispiel:
import matplotlib.pyplot as plt
import matplotlib.gridspec as gs
fig = plt.figure(constrained_layout=True)
# Verhältnis erste zu zweite Zeile = 1.5:1
# Verhältnis erste zu zweite Spalte = 1:4
gs = fig.add_gridspec(2, 2, figure=fig, height_ratios=[1.5, 1], width_ratios=[1, 4])
ax1 = fig.add_subplot(gs[0, 0])
ax1.set_title("Bereich 1: gs[0, 0]")
ax2 = fig.add_subplot(gs[0, 1])
ax2.set_title("Bereich 2: gs[0, 0]")
ax3 = fig.add_subplot(gs[1, 0])
ax3.set_title("Bereich 3: gs[1, 0]")
ax4 = fig.add_subplot(gs[1, 1:])
ax4.set_title("Bereich 4: gs[1, 1]")
plt.show()
[[Bild:PythonIng_gridspec2.svg|350px]]
Auch die Ränder lassen sich einstellen.
Beispiel 1:
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
fig = plt.figure()
gs = gridspec.GridSpec(2, 2, left=0.1, right=0.9, bottom=0.1,
top=0.9, wspace=0.2, hspace=0.2)
ax1 = fig.add_subplot(gs[0, 0])
ax2 = fig.add_subplot(gs[1, 0])
ax3 = fig.add_subplot(gs[0, 1])
ax4 = fig.add_subplot(gs[1, 1])
plt.show()
[[Bild:PythonIng_gridspec3.svg|300px]]
* hspace ... height space, vertikaler Abstand zwischen den Zeilen
* wspace ... width space, horizontaler Abstand zwischen den Spalten
Und im Vergleich dazu Beispiel 2:
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
fig = plt.figure()
gs = gridspec.GridSpec(2, 2, left=0.3, right=0.7, bottom=0.3,
top=0.7, wspace=0.3, hspace=0.3)
ax1 = fig.add_subplot(gs[0, 0])
ax2 = fig.add_subplot(gs[1, 0])
ax3 = fig.add_subplot(gs[0, 1])
ax4 = fig.add_subplot(gs[1, 1])
plt.show()
[[Bild:PythonIng_gridspec4.svg|300px]]
Es gibt noch einige weitere Details, die sich mit GridSpec variieren lassen (z.B. SubGridSpec ... verschachtelte Grid-Layouts). Aber wir belassen es vorerst dabei. Das bisher Gezeigte sollte für die meisten Probleme ausreichend sein.
=== Aufgaben ===
* Zeichnen Sie die Strophoide <math>x = \frac{a(t^2-1)}{t^2+1}, y = \frac{at(t^2-1)}{t^2+1}, a = 2, -3 \leq t \leq 3</math>. Das Ganze sollte in etwa so aussehen wie folgende Grafik:
[[Datei:octave_strophoide.jpg|300px|center]]
* Zeichnen Sie die verschlungene Hypozykloide <math>x = (R-r)\cos t + c\cos\frac{R-r}{r}t, y = (R-r)\sin t - c\sin\frac{R-r}{r}t, c = 3, r = 2, R = 6, -15 \leq t \leq 15</math>. Das Ganze sollte in etwa so aussehen wie folgende Grafik:
[[Datei:octave_hypozykloide.jpg|300px|center]]
* Testen Sie bei den obigen Übungsaufgaben verschiedene Linienstile und Farben. Farben können mit dem plt.plot()-Parameter color gewählt werden.
* Testen Sie bei den obigen Übungsaufgaben verschiedene Werte für a, c, r und R.
* Zeichnen Sie folgendes Bild (die Achsenbeschriftungen positionieren Sie z.B. mit den Befehlen <code>ax.set_xlabel("x", loc="right"); ax.set_ylabel("y", loc="top")</code>):
[[Bild:PythonIng_aufgabe24.svg|400px|center]]
* Zeichnen Sie mit Python, matplotlib und NumPy folgendes Bild:
[[Bild:PythonIng_figure41.svg|400px|center]]
* Zeichnen Sie mit GridSpec ein Layout, das in etwa wie folgendes aussieht (<code>height_ratios=[1, 2], width_ratios=[2, 1]</code>):
[[Bild:PythonIng_aufgabe23.svg|300px|center]]
== 3D ==
=== Räumliche Kurven ===
import matplotlib.pyplot as plt
import numpy as np
t = np.arange(0, 6*np.pi, 0.1)
x = t * np.cos(t)
y = t * np.sin(t)
z = t
fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
ax.plot(x, y, z)
plt.show()
[[Datei:PythonIng_raumkurve1.png]]
=== Flächen ===
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(0, 10, 0.1)
y = np.arange(0, 10, 0.1)
x, y = np.meshgrid(x, y)
z = np.sin(x) + 3 * np.cos(y)
fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
ax.plot_surface(x, y, z)
plt.show()
[[Datei:PythonIng_fläche1.png]]
Das Ganze in Netzdarstellung läßt sich so programmieren:
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(0, 10, 0.5)
y = np.arange(0, 10, 0.5)
x, y = np.meshgrid(x, y)
z = np.sin(x) + 3 * np.cos(y)
fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
ax.plot_wireframe(x, y, z)
plt.show()
[[Datei:PythonIng_fläche2.png]]
Ein etwas komplexeres Beispiel:
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(0.1, 10, 0.1)
y = np.arange(0.1, 10, 0.1)
x, y = np.meshgrid(x, y)
z1 = np.sin(x) + 3 * np.cos(y)
z2 = np.sin(x) + np.log(y)
z3 = x + np.cos(y)
z4 = x**2 - y
fig, ax = plt.subplots(subplot_kw={"projection": "3d"}, nrows=2, ncols=2)
ax[0][0].plot_surface(x, y, z1)
ax[0][1].plot_surface(x, y, z2)
ax[1][0].plot_surface(x, y, z3)
ax[1][1].plot_surface(x, y, z4)
plt.show()
[[Datei:PythonIng_subplot1.png]]
Man beachte, dass man die Unterbilder im Bild nach dem Ausführen des Scripts z.B. mit der mittleren Maustaste einzeln drehen, oder über die Einträge in der Menüzeile einzeln bearbeiten kann. Mit ein paar Zeilen Programmtext lässt sich also eine Menge an Funktionalität generieren.
Die Farbgebung lässt sich über <code>colormaps</code> variieren.
import matplotlib.pyplot as plt
import numpy as np
from matplotlib import cm
x = np.arange(0, 10, 0.1)
y = np.arange(0, 10, 0.1)
x, y = np.meshgrid(x, y)
z = np.sin(x) + 3 * np.cos(y)
fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
ax.plot_surface(x, y, z, cmap = cm.coolwarm)
plt.show()
[[Datei:PythonIng_colormap1.png]]
Es gibt eine Menge an Colormaps, z.B. <code>plasma, Greys, Dark2, ocean</code>. Zwecks detaillierterer Infos siehe die matplotlib-Dokumentation. <small>Verwendet man die IDE namens IDLE, so gibt es dort auch die automatische Codevervollständigung. D.h. es werden alle Möglichkeiten (in unserem Fall nach dem Eintippen von <code>cm.</code> alle verfügbaren Colormaps) angezeigt.</small>
Die "edgecolor" und Linienbreite können auch frei gewählt werden:
import matplotlib.pyplot as plt
import numpy as np
from matplotlib import cm
x = np.arange(0, 10, 0.1)
y = np.arange(0, 10, 0.1)
x, y = np.meshgrid(x, y)
z = np.sin(x) + 3 * np.cos(y)
fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
ax.plot_surface(x, y, z, cmap = cm.coolwarm, edgecolor="black", linewidth=1.0)
plt.show()
[[Datei:PythonIng_colormap2.png]]
=== Höhenlinien ===
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(0, 10, 0.1)
y = np.arange(0, 10, 0.1)
x, y = np.meshgrid(x, y)
z = np.sin(x) + 3 * np.cos(y)
fig, ax = plt.subplots()
ax.contour(x, y, z)
plt.show()
[[Datei:PythonIng_höhenlinien1.png|400px]]
Etwas abgewandelt sieht das so aus:
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(0, 10, 0.1)
y = np.arange(0, 10, 0.1)
x, y = np.meshgrid(x, y)
z = np.sin(x) + 3 * np.cos(y)
fig, ax = plt.subplots()
hl = ax.contour(x, y, z)
ax.clabel(hl, inline = True)
plt.show()
[[Datei:PythonIng_höhenlinien2.png|400px]]
Und noch eine Variante (mit einem Farbbalken) sei gezeigt.
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(0, 10, 0.1)
y = np.arange(0, 10, 0.1)
x, y = np.meshgrid(x, y)
z = np.sin(x) + 3 * np.cos(y)
fig, ax = plt.subplots()
hl = ax.contourf(x, y, z)
fig.colorbar(hl)
plt.show()
[[Datei:PythonIng_höhenlinien5.svg|400px]]
=== Aufgaben ===
* Zeichnen Sie die räumliche Kurve <math>x = 2 \cdot \cosh(t)</math>, <math>y = 5 \cdot \sin(t)</math>, <math> z = t^{2} - t</math>, <math>0 \leq t \leq 3\pi</math>.
* Zeichnen Sie die Fläche <math>z = \log(x) + \cos(y)</math>.
== Animationen und fortgeschrittenes 3D ==
=== Mit matplotlib ===
Auch mit matplotlib sind Animationen möglich. Das ist ein bisschen komplizierter und wird deshalb hier nur mit einem sehr einfachen Beispiel dargestellt (bei Interesse siehe z.B. auch das [https://matplotlib.org/stable/users/explain/animations/animations.html#animations Animations using Matplotlib-Tutorial]).
import matplotlib.pyplot as plt
import matplotlib.animation as ani
import matplotlib
import numpy as np
def update(frame):
line.set_xdata(x[:frame])
line.set_ydata(y[:frame])
return (line)
fig, ax = plt.subplots()
x = np.arange(0, 10, .1)
y = np.sin(x)
line, = ax.plot(x[0], y[0])
ax.set(xlim=[0, 10], ylim=[-1, 1])
a = ani.FuncAnimation(fig=fig, func=update, frames=100, interval=20)
plt.show()
# Speichere die Animation in einem animierten GIF (optional)
a.save(filename="c:/tmp/PythonIng_anim5.gif", writer="pillow")
[[Datei:PythonIng_anim5.gif]]
Es wird eine Sinuskurve auf den Bildschirm gezeichnet. In der letzten Zeile wird diese Animation in ein animiertes GIF gespeichert. Das ist natürlich optional und kann auch weggelassen werden.
=== Mit VPython ===
Aber auch mit dem Modul VPython lassen sich einfache 3D-Animationen erstellen. VPython ist ein externes Modul, das vorab installiert werden muss. Unter openSUSE Tumbleweed gibt es dzt. kein entsprechendes rpm-Paket. Die übliche Methode der Installation mittels YaST oder zypper ist somit nicht möglich. Auch eine direkte Verwendung von pip führt nur zu einer Fehlermeldung (<code>error: externally-managed-environment</code>). Es empfiehlt sich dort folgende Vorgehensweise:
# Erstelle zuerst eine virtuelle Umgebung, z.B.: <code>python3.11 -m venv ~/tmp/venv1</code>
# Wechsle das Verzeichnis: <code>cd ~/tmp/venv1/bin</code>
# Installiere das entsprechende Paket: <code>./pip install vpython</code>
# Führe das entsprechende Skript aus: <code>./python ~/tmp/test1.py</code>
Aktuell (März 2026) ist dieses Programmpaket lt. der [https://vpython.org/presentation2018/install.html VPython-Homepage] nur für die Python-Versionen 3.8 bis 3.12 verfügbar.
Ein Beispiel zu einer einfachen Animation wird nachfolgend geliefert.
from vpython import *
scene.width = 1200
scene.height = 600
scene.center = vector(20,0,0)
scene.background = color.white
cylinder(pos=vector(0,0,0), axis=vector(20,0,0), radius=5,
color=color.blue)
cone(pos=vector(0,0,0), axis=vector(-10,0,0), radius=5,
color=color.blue)
helix(pos=vector(20,0,0), axis=vector(40,0,0), radius=2,
coils=10, thickness=0.5, color=color.blue)
ball = sphere(pos=vector(20,0,0), color = color.green, radius = 1)
ball.p = vector(0.15, 0, 0)
toc = True
while True:
rate(200)
if(ball.pos.x <= 60 and toc == True):
ball.pos += ball.p
else:
toc = False
ball.pos -= ball.p
if(ball.pos.x <= 20 and toc == False):
toc = True
[[Datei:PythonIng_vpython_anim.JPG]]
Idealerweise öffnet sich beim Ausführen des Scripts ein Browserfenster. Darin wird die programmierte Animation gezeigt (siehe auch den obigen Screenshot). Eine Größenänderung können Sie mit der mittleren Maustaste initiieren. Die Szenerie drehen können Sie mit der rechten Maustaste.
=== Mit build123d ===
Hiermit lassen sich einfach 3D-Modelle für CAD-Systeme erstellen. [https://build123d.readthedocs.io/en/latest/ build123d] ist ein externes Modul und muss vorab, wie schon für mehrere andere Module gezeigt, installiert werden (pip, venv etc.).
Beispielcode:
from build123d import *
# Bauteil
with BuildPart() as bauteil:
# Zylinder erstellen
Cylinder(100, 60)
# Bohrung
with BuildSketch(bauteil.faces().sort_by(Axis.Z)[-1]) as loch:
Circle(radius=10)
# negativ extrudieren
extrude(amount=-60, mode=Mode.SUBTRACT)
# Dem Bauteil z.B. die Farbe rot zuweisen
# bauteil.part.color = Color("red", alpha=1.0)
# Fertiges Modell exportieren
export_step(bauteil.part, "bauteil.step")
Ausgabe ({{W|Standard for the exchange of product model data | STEP}}-Datei, z.B. in {{W|FreeCAD}} importiert, Screenshot):
[[Datei:PythonIng_build123d.jpg | 300px]]
FreeCAD ist ein freies 3D-CAD-System. Die [[Ing_Mathematik:_Python#FreeCAD | Makroprogrammierung]] in diesem System wird später noch gezeigt. STEP steht für "'''St'''andard for the '''e'''xchange of '''p'''roduct model data" und ist ein Datenaustauschformat.
=== Mit VTK ===
Komplexer, aber auch mächtiger als VPython ist die Verwendung von VTK ('''V'''isualization '''T'''ool'''k'''it). Genauer gesagt des Python-Wrappers von VTK. Dieses externe Python-Modul muss vorab installiert werden (z.B. mittels YaST, pip oder in eine virtuelle Umgebung). VTK ist eine Softwarebibliothek zur 3D-Visualisierung und wurde ursprünglich in C++ geschrieben. Verbreitet eingesetzt wird diese Bibliothek in der Wissenschaft und Forschung, z.B.
* in der medizinischen Bildgebung
* für Strömungssimulationen
* für Klimadaten
VTK funktioniert nach dem {{W|Grafikpipeline|Pipeline-Prinzip}}:
Source (Quellen) -> Filter -> Mapper (Senken) -> Actor/Renderer
Daten fließen von den Quellen zu den Senken.
Als einfaches Beispiel wird die Darstellung eines Zylinders gezeigt, der mit den Maustasten gedreht oder in der Größe geändert werden kann:
import vtk
# Zylinder erzeugen
cyl = vtk.vtkCylinderSource()
cyl.SetRadius(5.0)
cyl.SetHeight(20.0)
cyl.SetResolution(40)
# Geometrie in darstellbare Daten umwandeln
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(cyl.GetOutputPort())
# Objekt in der Szene
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# Szene verwalten
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
# Render-Fenster
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
# Maus/Tastatur-Steuerung
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)
# Starten
render_window.Render()
interactor.Start()
Ausgabe:
[[Datei:PythonIng_VTK_1.png]]
Gleiches Beispiel wie oben, aber mit einer Animationssequenz:
import vtk
import time
cyl = vtk.vtkCylinderSource()
cyl.SetRadius(5.0)
cyl.SetHeight(20.0)
cyl.SetResolution(40)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(cyl.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)
for i in range(360):
actor.RotateZ(1)
actor.RotateY(.5)
render_window.Render()
time.sleep(0.01)
Das Grafikfenster schließt sich nach Ablauf der Schleife. Das Fenster bleibt geöffnet, wenn Sie am Programmende folgenden Befehl hinschreiben
interactor.Start()
Um den animierten Zylinder grün einzufärben, müssen Sie Folgendes im obigen Programm ergänzen (Farbnamen):
colors = vtk.vtkNamedColors()
actor.GetProperty().SetColor(colors.GetColor3d("Green"))
Als Namen können Sie u.a. die CSS3 Web-Farben verwenden (siehe z.B. [https://wiki.selfhtml.org/wiki/Farbe/Farbangaben] und {{W|Webfarbe#CSS_3}}).
Alternativ funktioniert auch das ({{W|RGB-Farbraum|RGB}}):
actor.GetProperty().SetColor(0.0, 0.6, 0.0)
Wie der Zylinder mit einer Textur versehen wird, zeigt folgendes Programm:
import vtk
import time
cylinder = vtk.vtkCylinderSource()
cylinder.SetResolution(30)
cylinder.SetHeight(3.0)
cylinder.SetRadius(1.0)
cylinder.CappingOn()
texture_coords = vtk.vtkTextureMapToCylinder()
texture_coords.SetInputConnection(cylinder.GetOutputPort())
texture_coords.PreventSeamOn()
reader = vtk.vtkJPEGReader()
reader.SetFileName("PythonIng_textur.jpg")
texture = vtk.vtkTexture()
texture.SetInputConnection(reader.GetOutputPort())
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(texture_coords.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.SetTexture(texture)
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderer.AddActor(actor)
for i in range(360):
actor.RotateZ(1)
actor.RotateY(.5)
renderWindow.Render()
time.sleep(0.01)
interactor.Start()
<gallery>
PythonIng_textur.jpg | Textur-Datei
PythonIng_VTK_2.png | Ausgabe (Screenshot)
</gallery>
== Sonstige Grafikbibliotheken ==
=== Py5 ===
Im Buch ''Iacono et al.: Programmieren trainieren, mit über 150 Workouts in Java und Python; 3. Aufl., Hanser, 2023'' werden zahlreiche Aufgaben gestellt, die u.a. mit Processing zu lösen sind. Processing ist eine einfache Programmiersprache und Entwicklungsumgebung. Warum ich das erwähne? Weil in älteren Processing-Versionen auch die Programmiersprache Python 2 abgedeckt war. Bei neueren Versionen gibt es keine Python-Anbindung mehr (getestet nur mit openSUSE Tumbleweed und Python 3). Somit funktioniert der Python-Teil im genannten Buch zum Teil nicht mehr. Ist das tragisch, oder kann das Buch weggeschmissen werden? Nein! Es gibt Alternativen zu Processing. Zum einen die im Buch selbst genannten Bibliotheken tkinter oder pygame. Pygame wird dort auch kurz anhand eines Beispiels thematisiert. Aber noch besser ist es, die py5-Bibliothek zu verwenden (lt. Google KI vom 30. Sept. 2026: ''Der echte, moderne „spirituelle Nachfolger“''). Damit ist die Funktionalität von Processing gewährleistet. Man kann aber beliebige Editoren oder IDEs zur Programmerstellung verwenden, ohne an Processing als IDE gebunden zu sein. Nachfolgend werden ein paar Beispiele zu dieser externen Bibliothek gegeben. Der erste Schritt ist wieder, die py5-Bibliothek zu installieren (z.B. mittels pip in eine virtuelle Umgebung; Python>=3.10 und ein JDK>=17 müssen auch installiert sein (Stand Okt. 2026)). Dann kann es schon mit dem Programmieren losgehen.
Beispiel (angelehnt an die ''Aufgabe W.2.3 Haus'' des genannten Buchs, jedoch etwas erweitert):
import py5
def setup():
py5.size(600, 600) # Fenstergröße 600px x 600px
py5.background(255, 255, 255) # Hintergrundfarbe ... weiss
def draw():
# Haus zeichnen
py5.fill(255, 255, 255) # Hintergrundfarbe ... weiss
py5.stroke(255, 0, 0) # Linienfarbe ... rot
py5.stroke_weight(3) # Linienbreite ... 3px
py5.rect(150, 200, 300, 300) # Rechteck zeichnen (x, y, b, h)
py5.triangle(150, 200, 300, 100, 450, 200) # Dreieck zeichnen
py5.circle(250, 300, 70) # Kreis zeichnen (x, y, d)
# Bemassung zeichnen
py5.stroke(0, 255, 0)
py5.stroke_weight(1)
py5.line(300, 100, 550, 100) # Linie zeichnen
py5.line(450, 200, 550, 200)
py5.line(450, 500, 550, 500)
py5.line(150, 500, 150, 550)
py5.line(450, 500, 450, 550)
py5.text_size(20) # Textgroesse
py5.fill(0, 255, 0) # Textfarbe
py5.text("300", 280, 550) # Text zeichnen
py5.text("100", 500, 150)
py5.text("300", 500, 350)
# Gedrehtes Rechteck zeichnen
py5.stroke(255, 255, 0)
py5.stroke_weight(3)
py5.fill(200, 200, 200)
py5.translate(320, 260)
py5.rotate(0.3) # Drehung (in Radiant)
py5.rect(0, 0, 100, 50)
# Startet den Sketch
py5.run_sketch()
Ausgabe:
[[Datei:PythonIng_py5_1.png|300px]]
Das skizzierte Haus ist mit einer rudimentären Bemaßung versehen und hat zwei Fenster, ein rundes und ein gedrehtes, trübes rechteckiges.
Beispiel (Mausoperationen):
import py5
def setup():
py5.size(600, 600)
py5.background(255, 255, 255)
def draw():
pass
def mouse_pressed():
py5.text_size(15)
py5.fill(0, 0, 255)
x = py5.mouse_x
y = py5.mouse_y
py5.text("(%d, %d)" %(x, y), x, y) # Positionsdaten bei Maus-Klick schreiben
py5.run_sketch()
Ausgabe:
[[Datei:PythonIng_py5_2.png|300px]]
Obiges Bild zeigt das Resultat nach einigen Mausklicks. Man erkennt, dass links-oben der Koordinatennullpunkt ist. Die x-Achse zeigt nach rechts, die y-Achse nach unten.
Beispiel (Fünfeck):
import py5
import random
def setup():
py5.size(400, 400)
py5.no_loop() # statisches Bild (schont die Ressourcen)
def draw():
py5.translate(py5.width / 2, py5.height / 2) # KS setzen
radius = 150
eck_anzahl = 5
py5.fill(random.randint(0, 255), random.randint(0, 255),
random.randint(0, 255)) # Füllfarbe auf Zufallswert setzen
py5.stroke(155, 0, 0)
py5.stroke_weight(5)
# Fünfeck als Polygon zeichnen
py5.begin_shape()
for i in range(eck_anzahl):
winkel = i * py5.TWO_PI / eck_anzahl - py5.HALF_PI
x = py5.cos(winkel) * radius
y = py5.sin(winkel) * radius
py5.vertex(x, y)
py5.end_shape(py5.CLOSE)
py5.run_sketch()
Ausgabe, bspw.:
[[Datei:PythonIng_py5_5.png|200px]]
<u>Kleine Aufgaben:</u>
* Um die Funktionsweise von <code>py5.no_loop()</code> zu verstehen, kommentieren Sie die Anweisung im Beispiel einfach aus, und starten Sie das Programm erneut.
* Zeichnen Sie ein Siebeneck.
* Was passiert, wenn man <code>py5.CLOSE</code> im <code>py5.end_shape()</code>-Befehl weglässt?
Beispiel (Grafik laden und zeichnen):
import py5
image1 = None
def setup():
global image1
py5.size(600, 600)
py5.no_loop()
image1 = py5.load_image("PythonIng_py5_1.png")
def draw():
py5.image(image1, 0, 0)
py5.run_sketch()
Hier wird einfach das Bild vom Haus-Beispiel (Screenshot von weiter oben) geladen und gezeichnet.
Beispiel (angelehnt an ''W.5.10 Wurfparabel'' des genannten Buches; mit OOP erstellt):
import py5
class Wurfparabel(py5.Sketch):
def __init__(self, v0, angle):
super().__init__()
self.v0 = v0
self.angle = self.radians(angle)
self.g = 9.81
self.t = 0.0
self.scale = 1.5
def settings(self):
self.size(800, 600)
def setup(self):
self.background(0, 0, 0)
def draw(self):
self.t += 0.1
self.translate(50, 500)
# KS Zeichnen
self.fill(255, 255, 0)
self.stroke(255, 255, 0)
self.stroke_weight(1)
self.line(0, 0, 0, -300)
self.line(0, 0, 700, 0)
# Punkt zeichnen
cx = self.v0 * self.cos(self.angle) * self.t * self.scale
cy = -(self.v0 * self.sin(self.angle) * self.t - \
self.g/2 * self.t**2) * self.scale
self.fill(255, 0, 0)
self.stroke(255, 0, 0)
self.circle(cx, cy, 3)
# Stoppen bei Bodenkontakt
if cy >= -5:
self.no_loop()
def wurfparabel(v0=50, angle=45):
sketch = Wurfparabel(v0, angle)
sketch.run_sketch()
v0 = float(input("v0 = "))
winkel = float(input("winkel = "))
wurfparabel(v0=v0, angle=winkel)
Eingabe auf der Konsole:
v0 = 60
winkel = 45
Ausgabe:
[[Datei:PythonIng_py5_13.png|200px]]
Die benötigten Formeln der Bewegungsgleichung kann man leicht herleiten, bzw. man benutzt folgende Grafik als Hilfestellung:
[[Datei:Wurfparabel_Zusammenfassung_aktualisierung.png|700px]]
<u>Aufgabe:</u> Berechnen Sie den Scheitelpunkt und die Wurfweite bei gegebener Anfangsgeschwindigkeit und gegebenem Abwurfwinkel. Die Abwurfhöhe <math>y_0</math> sei 0. Der Wurf soll auf der Erde stattfinden (g = 9.81 m/s²). Die dazu benötigten Formeln können aus obiger Grafik entnommen werden (oder Sie leiten sie selbst her). Geben Sie die Ergebnisse auf der Konsole aus.
Beispiel (eine einfache Animation):
import py5
i = 0
def setup():
py5.size(600, 600)
py5.frame_rate(5)
py5.stroke_weight(20)
def draw():
global i
py5.background(255, 255, 255)
py5.translate(py5.width/2, py5.height/2)
py5.rotate(py5.PI/8 * i)
py5.line(-100, 0, 100, 0)
i += 1
py5.run_sketch()
Es wird eine rotierende Linie gezeichnet (z.B. wie bei einem Installationsprozess verwendet - zeigt an, dass der Installationsfortschritt nicht eingefroren ist). Hierbei ist nur aufzupassen, dass der Hintergrund in <code>draw()</code> gesetzt wird, ansonsten würden die Linien additiv gezeichnet. Das ist zwar auch schön, aber eben nicht das gewünschte Resultat.
=== Bokeh ===
Mit Bokeh kann man interaktive Datenvisualisierungen für Webbrowser in Python erstellen. Bokeh ist eine externe Bibliokek, die vorab installiert werden muss (z.B. mittels YaST oder pip).
Python-Code:
from bokeh.plotting import figure, output_file, show
x = [1, 2, 3, 4, 5, 6]
y = [10, 5, 6, 8, 9, 11]
output_file("interpolation.html")
p = figure(
title="Interpolation",
x_axis_label="x",
y_axis_label="y",
)
p.line(x, y, legend_label="Interpolierende", line_width=2, color="blue")
p.scatter(x, y, legend_label="Stützpunkte", size=7, color="orange")
p.legend.location = "top_left"
show(p)
Ausgabe:
[[File:PythonIng_bokeh1.png|300px]]
Python-Code (angelehnt an ein Beispiel aus der Bokeh-Dokumentation, aber wesentlich gekürzt
und vereinfacht):
from bokeh.layouts import layout
from bokeh.models import Spinner
from bokeh.plotting import figure, show
x = [1, 2, 3, 4, 5]
y = [2, 7, 3, 6, 4]
p = figure(x_range=(1, 5), width=500, height=350)
points = p.scatter(x=x, y=y, size=30, fill_color="blue")
spinner = Spinner(
title="Kreisgröße",
low=0,
high=60,
step=5,
value=points.glyph.size,
width=200,
)
spinner.js_link("value", points.glyph, "size")
layout = layout(
[
[spinner],
[p],
],
)
show(layout)
Ausgabe:
[[File:PythonIng_bokeh2.png|300px]]
Das letzte Komma in den Parameterlisten ist optional und wird [https://peps.python.org/pep-0008/#when-to-use-trailing-commas hängendes Komma] (trailing comma) genannt. Die Dokumentation zu Bokeh findet sich auf [https://docs.bokeh.org/en/latest/].
Hiermit belassen wir es mit den Grafikbibliotheken und wenden uns wieder "mathematischeren" Themen zu.
= Vektoren und Matrizen =
== Zahlenfolgen ==
Für das Erstellen von Zahlenfolgen bieten sich die Funktionen <code>arange</code> und <code>linspace</code> aus dem <code>numpy</code>-Modul an.
from numpy import *
start = 0
stop = 10
step = 2
num = 10
r = arange(start, stop, step) # step ... Schrittweite
l = linspace(start, stop, num) # num ... Anzahl der Werte
print("r = ", r)
print("l = ", l)
Ausgabe:
r = [0 2 4 6 8]
l = [ 0. 1.11111111 2.22222222 3.33333333 4.44444444 5.55555556
6.66666667 7.77777778 8.88888889 10. ]
Bei <code>arange</code> ist der <code>stop</code>-Wert nicht im Ergebnis enthalten, bei <code>linspace</code> standardmäßig aber sehr wohl. Jedoch kann man das bei <code>linspace</code> auch ändern. Dann ist der Stoppwert nicht mehr enthalten:
linspace(start, stop, num, endpoint=False)
== Vektoren ==
Vektoren sollten jedem aus der Linearen Algebra bekannt sein.
=== Arrays ===
In Python mit NumPy kann man Vektoren durch die Funktion array erzeugen.
import numpy as np
l1 = (-5, 3, 2)
l2 = (1, 1, 4)
a1 = np.array(l1)
a2 = np.array(l2)
a3 = a1 + a2
a4 = 2 * a2
print(a1)
print(a2)
print(a3)
print(a3[2])
print(a4)
Ausgabe:
[-5 3 2]
[1 1 4]
[-4 4 6]
6
[2 2 8]
=== Zeilen- und Spaltenvektoren ===
import numpy as np
# Zeilenvektor
z = np.array([ [-5, 3, 2] ])
# Spaltenvektor
s = np.array([[1], [1], [4]])
print(z)
print(s)
Ausgabe:
[ [-5 3 2] ]
[[1]
[1]
[4]]
=== Skalarprodukt ===
import numpy as np
a1 = np.array((-5, 3, 2))
a2 = np.array((1, 1, 4))
skalarprodukt = np.dot(a1, a2)
print(skalarprodukt)
Ausgabe:
6
=== Vektorprodukt ===
<math>a\ast b=\left(\begin{array}{c}
a_{1}\\
a_{2}\\
a_{3}
\end{array}\right)\ast\left(\begin{array}{c}
b_{1}\\
b_{2}\\
b_{3}
\end{array}\right)=\left(\begin{array}{c}
a_{2}b_{3}-a_{3}b_{2}\\
a_{3}b_{1}-a_{1}b_{3}\\
a_{1}b_{2}-a_{2}b_{1}
\end{array}\right)
</math>
Python-Code:
import numpy as np
a1 = np.array((-5, 3, 2))
a2 = np.array((1, 1, 4))
vektorprodukt = np.cross(a1, a2)
print(vektorprodukt)
Ausgabe:
[10 22 -8]
=== Transponierter Vektor ===
import numpy as np
# Zeilenvektor
z = np.array([ [-5, 3, 2] ])
# Spaltenvektor
s = np.array([[1], [1], [4]])
# transponierter Vektor
z_tp = np.transpose(z)
# transponierter Vektor
s_tp = np.transpose(s)
print(z_tp)
print(s_tp)
Ausgabe:
[[-5]
[ 3]
[ 2]]
[ [1 1 4] ]
=== Vektorfelder visualisieren ===
import matplotlib.pyplot as plt
import numpy as np
# Daten generieren
x = np.arange(0, 10, 1)
y = np.arange(0, 10, 1)
X, Y = np.meshgrid(x, y)
U = X * Y
V = Y + X
# Plotten
fig, ax = plt.subplots()
ax.quiver(X, Y, U, V, angles='xy')
plt.show()
Ausgabe:
[[Datei:PythonIng_quiver1.png]]
== Matrizen==
import numpy as np
m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
print(m1)
Ausgabe:
[[1 2 3]
[4 5 6]]
=== Zugriff auf Matrizenelemente ===
Beispiel:
import numpy as np
m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
# Element aus Zeile 2 und Spalte 3 (Achtung! Index startet bei Null)
print(m1[1,2])
Ausgabe:
6
Visualisierung:
0 1 2
+-----------+
0 | 1 | 2 | 3 |
+-----------+
1 | 4 | 5 | '''6''' |
+-----------+
Beispiel:
import numpy as np
A = [["00", "01", "02", "03"],
["10", "11", "12", "13"],
["20", "21", "22", "23"],
["30", "31", "32", "33"],
["40", "41", "42", "43"]]
B = np.matrix(A)
print(B[2::, ::2])
Ausgabe:
[['20' '22']
['30' '32']
['40' '42']]
Mit der NumPy-Bibliothek funktioniert das zweidimensionale Slicing. Mit normalen Listen/Tupels geht das nicht, was wir schon früher thematisiert haben.
=== Addition und Subtraktion von Matrizen ===
import numpy as np
m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
m2 = np.matrix([[0, 0, 2], [1, 3, 2]])
print(m1 + m2)
print(m1 - m2)
Ausgabe:
[[1 2 5]
[5 8 8]]
[[1 2 1]
[3 2 4]]
=== Transponierte Matrix ===
import numpy as np
m = np.matrix([[1, 2, 3], [4, 5, 6]])
mt = np.transpose(m)
print(m)
print(mt)
Ausgabe:
[[1 2 3]
[4 5 6]]
[[1 4]
[2 5]
[3 6]]
=== Rang einer Matrix ===
import numpy as np
m = np.matrix([[1, 3], [0, -5]])
rg = np.linalg.matrix_rank(m)
print(rg)
Ausgabe:
2
=== Inverse Matrix ===
import numpy as np
m = np.matrix([[1, 3], [0, -5]])
mi = np.linalg.inv(m)
print(mi)
Ausgabe:
[[ 1. 0.6]
[-0. -0.2]]
=== Multiplikation von Matrizen (falksches Schema) ===
import numpy as np
m1 = np.matrix([[1, 3, 4], [0, -5, 1]])
m2 = np.matrix([[1, 2], [2, 3], [0, 2]])
print(m1 @ m2)
Ausgabe:
[[ 7 19]
[-10 -13]]
=== Eigenwerte und Eigenvektoren ===
import numpy as np
m = np.matrix([[5, 8], [1, 3]])
D,V = np.linalg.eig(m)
# Eigenwerte
print(D)
# Eigenvektoren
print(V)
Ausgabe:
[7. 1.]
[[ 0.9701425 -0.89442719]
[ 0.24253563 0.4472136 ]]
=== Teilmatrizen ===
import numpy as np
m = np.matrix([[1, 3, 4], [0, -5, 1]])
print("m = ", m)
# Erste Zeile extrahieren
m1 = m[0,:]
print("m1 = ", m1)
# Das Element aus der 1. Zeile und der 2. Spalte extrahieren
m2 = m[0,1]
print("m2 = ", m2)
# Zweite Spalte extrahieren
m3 = m[:, 1]
print("m3 = ", m3)
Ausgabe:
m = [[ 1 3 4]
[ 0 -5 1]]
m1 = [ [1 3 4] ]
m2 = 3
m3 = [[ 3]
[-5]]
=== Spezielle Matrizen ===
==== Nullmatrix ====
import numpy as np
z = np.zeros((3, 2))
print(z)
Ausgabe:
[[0. 0.]
[0. 0.]
[0. 0.]]
==== Einheitsmatrix ====
import numpy as np
z = np.eye(3)
print(z)
Ausgabe:
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
==== Matrix mit lauter Einsen ====
import numpy as np
z = np.ones((3, 2))
print(z)
Ausgabe:
[[1. 1.]
[1. 1.]
[1. 1.]]
=== Spärlich besetzte Matrizen ===
Das Thema spärlich besetzter Matrizen wird hier nur kurz angerissen. Nähere Details siehe unter dem Weblink [https://docs.scipy.org/doc/scipy/reference/sparse.html#module-scipy.sparse].
Beispiel:
import numpy as np
import scipy
A = scipy.sparse.csr_array(np.eye(5))
print(A)
Ausgabe:
<Compressed Sparse Row sparse array of dtype 'float64'
with 5 stored elements and shape (5, 5)>
Coords Values
(0, 0) 1.0
(1, 1) 1.0
(2, 2) 1.0
(3, 3) 1.0
(4, 4) 1.0
csr steht für '''c'''ompressed '''s'''parse '''r'''ow.
Andere Möglichkeiten:
* coo-Format ('''coo'''rdinate Format): <code>scipy.sparse.coo_array()</code>
* lil-Format ('''li'''st of '''l'''ists): <code>scipy.sparse.lil_array()</code>
* csc-Format ('''c'''ompressed '''s'''parse '''c'''olumn): <code>scipy.sparse.csc_array()</code>
Es gibt auch <code>scipy.sparse.csr_matrix()</code> etc. Diese Befehle sind aber veraltet und es wird empfohlen, statt dessen die <code>..._array()</code>-Funktionen zu verwenden.
<u>Aufgaben:</u>
Recherchieren Sie im Internet
* generell zum Thema "spärlich besetzte Matrizen mit Python".
* Was sind die Vor-/Nachteile von csr-arrays gegenüber coo- und lil-arrays?
* Wann verwendet man sinnvollerweise csr- und wann csc-arrays?
* Wie wandelt man coo-arrays in csr-arrays um?
= Lineare Gleichungssysteme =
Sei <math>Ax = b</math> ein lineares Gleichungssystem. <math>A</math> sei die Koeffizientenmatrix, <math>x</math> der Lösungsvektor und <math>b</math> ein bekannter Vektor.
Beispiel:
import numpy as np
A = np.array([[5, 1], [0, 2]])
b = np.array([1, 2])
x = np.linalg.solve(A, b)
print(x)
Ausgabe:
[0. 1.]
Siehe dazu auch das Kapitel [[Ing Mathematik: Numerisches Lösen von linearen Gleichungssystemen]]. Dort wird dieses Themengebiet u.a. mit weitergehenden Python-Skripten vertieft.
== Aufgabe ==
* Lösen Sie folgendes Gleichungssystem mittels Python (und zur Kontrolle auch händisch):
5x + 6y - 2z = 12
3x - y - 3z = 6
2x + 2y + 4z = 5
= Polynome =
== Ein erstes einfaches Beispiel ==
Gegeben sei das Polynom <math>7x^3+5x^2+1</math>. In Python:
import numpy as np
p = np.poly1d([7, 5, 0, 1])
print(p)
Ausgabe:
3 2
7 x + 5 x + 1
== Einzelne Polynomwerte berechnen ==
import numpy as np
p = np.poly1d([7, 5, 0, 1])
print(p(1.5))
Ausgabe:
35.875
== Polynome integrieren und differenzieren ==
import numpy as np
p = np.poly1d([7, 5, 0, 1])
# 1. Ableitung
p1 = p.deriv()
p2 = p.deriv(1)
# 2. Ableitung
p3 = p.deriv(2)
# Integral
p4 = p.integ()
print(p1)
print(p2)
print(p3)
print(p4)
Ausgabe:
2
21 x + 10 x
2
21 x + 10 x
42 x + 10
4 3
1.75 x + 1.667 x + 1 x
== Nullstellen bestimmen ==
import numpy as np
p = np.poly1d([2, 5, 0, 4])
r = np.roots(p)
print(r)
Ausgabe:
[-2.7621427 +0.j 0.13107135+0.84077099j 0.13107135-0.84077099j]
== Aufgaben ==
* Berechnen Sie den Wert für x = 3 des Polynoms <math>y = 2x^4 - 3x^3 - x + 7</math>.
* Differenzieren und integrieren Sie das Polynom <math>y = 2x^4 - 3x^3 - x + 7</math>.
* Berechnen Sie die Nullstellen von <math>y = 7x^5 - 3x^2 + 12</math>.
= Nichtlineare Gleichungen und Gleichungssysteme =
== Nullstellenbestimmung ==
Löse eine beliebige Gleichung f(x) = 0, z.B. <math> f(x) = x^2 - 5\cos(x) - 10 = 0 </math>:
import scipy
import numpy as np
def f(x):
return x**2 - 5*np.cos(x) - 10
xstart = [-1, 1] # Startwerte
xn = scipy.optimize.root(f, xstart)
print(xn.x)
Ausgabe:
[-2.46813009 2.46813009]
Funktionsgraph:
[[Datei:octave_nichtlin2.jpg]]
== Gleichungssysteme ==
SymPy ist ein externes Modul, das symbolisches Rechnen ('''Sym'''bolic '''Py'''thon) ermöglicht.
Folgende Aufgabe ist dem Buch "Knorrenschild: Numerische Mathematik, Hanser, 2017, Seite 72" entnommen. Zu lösen ist das nichtlineare Gleichungssystem
<math>f_1 = 2x_1 + 4x_2 = 0 </math>
<math>f_2 = 4x_1 + 8x_2^3 = 0</math>
Mit Python ist das so möglich:
import sympy
x1, x2 = sympy.symbols("x1 x2")
f1 = 2*x1 + 4*x2
f2 = 4*x1 + 8*x2**3
s = sympy.solve((f1, f2), x1, x2)
print(s)
Ausgabe:
[(-2, 1), (0, 0), (2, -1)]
Plot:
[[Datei:IngPython_nl_gleichung1.svg|500px]]
= Komplexe Zahlen =
Die imaginäre Einheit wird in Python durch den Buchstaben <code>j</code> symbolisiert. Darstellen kann man eine komplexe Zahl bekannterweise in mehreren Formen:
* Kartesische Darstellung <math>z = \Re(z) + j \cdot \Im(z)</math>
* Polardarstellungen <math>z = r \cdot (\cos(\phi) + j \cdot \sin(\phi)) = r \cdot e^{j\cdot \phi}</math>
Die konjugiert komplexe Zahl ist <math>z^* = \Re(z) - j \cdot \Im(z)</math>
Nachfolgend einige mathematische Operationen mit Python und NumPy.
import numpy as np
z1 = 2 + 5j # kartesische Darstellung
z2 = 3 * np.exp(3j) # Polardarstellung
# Addition
res = z1 + z2
print("z1 + z2 = ", res)
# Multiplikation
res = z1 * z2
print("z1 * z2 = ", res)
# Realteil
res = np.real(z2)
print("Realteil von z2 = ", res)
# Imaginärteil
res = np.imag(z2)
print("Imaginaerteil von z2 = ", res)
# Betrag
res = np.abs(z1)
print("Betrag von z1 = ", res)
# Argument
res = np.angle(z1)
print("Argument von z1 = ", res)
# Konjugiert komplexe Zahl
res = np.conj(z1)
print("Konjugiert komplexe Zahl von z1 = ", res)
Ausgabe:
z1 + z2 = (-0.9699774898013365+5.423360024179601j)
z1 * z2 = (-8.05675510050068-14.003167400647481j)
Realteil von z2 = -2.9699774898013365
Imaginaerteil von z2 = 0.4233600241796016
Betrag von z1 = 5.385164807134504
Argument von z1 = 1.1902899496825317
Konjugiert komplexe Zahl von z1 = (2-5j)
= Interpolation =
import numpy as np
import scipy
import matplotlib.pyplot as plt
# Stützpunkte
xp = np.arange(1, 6)
yp = (0, -5, 2, 7, 6)
ti = np.arange(1, 5, 0.01)
i1 = scipy.interpolate.interp1d(xp, yp, kind = "linear")
i2 = scipy.interpolate.interp1d(xp, yp, kind = "cubic")
plt.plot(xp, yp, "rx")
plt.plot(xp, i1(xp))
plt.plot(ti, i2(ti))
plt.show()
Ausgabe:
[[Datei:PythonIng_interpol1.png]]
<code>scipy.interpolate.interp1d()</code> gilt als veraltet ([https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.interp1d.html]). Stattdessen soll man modernere Alternativen wie <code>scipy.interpolate.Akima1DInterpolator()</code> oder <code>scipy.interpolate.CubicSpline()</code> benutzen. Für die lineare Interpolation tut es <code>np.interp()</code>.
<u>Aufgaben:</u>
* Recherchieren Sie im Internet zu den oben genannten modernen Alternativen.
* Schreiben Sie obiges Programm auf die genannten moderneren Alternativen um.
= Differenzialrechnung =
== Numerisches Differenzieren ==
Als Beispiel differenzieren wir <math>y = 5x\sin{x}</math> und stellen das Ganze grafisch dar.
from findiff import Diff
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0, 10, 1000)
f = 5 * x * np.sin(x)
dx = x[1] - x[0]
# Ableitung
d_dx = Diff(0, dx)
df_dx = d_dx(f)
# Grafik
plt.plot(x, f, label = "y")
plt.plot(x, df_dx, label = "y'")
plt.grid()
plt.legend(loc="best")
plt.show()
Ausgabe:
[[Datei:octave_diff1.jpg]]
<small>findiff ist ein externes Modul. Dieses muss installiert werden (z.B. so: ...\Python\Scripts\pip.exe install --upgrade findiff). Für die Vorgehensweise unter openSUSE Tumbleweed siehe das Kapitel [[Ing_Mathematik:_Python#Mit_VPython | VPython]], nur dass das Ganze mit einer aktuelleren Python-Version exekutiert wird, z.B. mit Python 3.13. Das im Buch "Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler, Rheinwerk" verwendete Modul "scipy.misc" ist veraltet (deprecated ... missbilligt). Lt. [https://docs.scipy.org/doc/scipy-1.17.0/dev/roadmap-detailed.html#misc SciPy-Dokumentation für die Version 1.17.0] wurden alle entsprechenden Features schon entfernt.</small>
== Symbolisches Differenzieren ==
Differenzieren Sie die Funktionen <math>f_1(x) = x^2</math> und <math>f_2(x) = \sin(x)\cos\left(\frac{x}{2}\right)</math>.
import sympy
x = sympy.symbols("x")
f1 = x**2;
f2 = sympy.sin(x) * sympy.cos(x/2.)
d1 = sympy.diff(f1, x)
d2 = sympy.diff(f2, x)
print(d1)
print(d2)
Ausgabe:
2*x
-0.5*sin(0.5*x)*sin(x) + cos(0.5*x)*cos(x)
== Aufgaben ==
* Differenzieren Sie die Funktion <math>y = \log(x) + 10x</math> und stellen Sie y, sowie y' grafisch am Bildschirm dar.
* Differenzieren Sie die Funktion <math>y = \frac{\sinh(x)}{(1+x)}</math> und stellen Sie y, sowie y' grafisch am Bildschirm dar.
= Integralrechnung =
== Numerisches Integrieren ==
Berechnen Sie das Integral <math>\int_{0}^{3}x^2 dx</math>.
import scipy
def f(x):
return x**2
i = scipy.integrate.quad(f, 0, 3)
print(i)
Ausgabe:
(9.000000000000002, 9.992007221626411e-14)
Das trifft den exakten Wert 9.0 ziemlich genau.
Berechnen Sie das Integral <math>\int_{0}^{\infty} 2^{-x} dx</math>.
import scipy
import numpy as np
def f(x):
return 2**(-x)
i = scipy.integrate.quad(f, 0, np.inf)
print(i)
Ausgabe:
(1.4426950408889556, 4.486558477977586e-09)
== Symbolisches Integrieren ==
Berechnen Sie <math>\int x^2 \text{d}x</math> und <math>\int \sin{x}\cos{\frac{x}{2}} \text{d}x</math>.
import sympy
x = sympy.symbols("x")
f1 = x**2
f2 = sympy.sin(x) * sympy.cos(x/2.)
i1 = sympy.integrate(f1, x)
i2 = sympy.integrate(f2, x)
print(i1)
print(i2)
Ausgabe:
x**3/3
-0.666666666666667*sin(0.5*x)*sin(x) - 1.33333333333333*cos(0.5*x)*cos(x)
Berechnen Sie das Integral <math>\int_{0}^{\infty} 2^{-x} \text{d}x</math>.
import sympy
x = sympy.symbols("x")
f = 2**(-x)
i = sympy.integrate(f, (x, 0, sympy.oo))
print(i)
Ausgabe:
1/log(2)
<code>sympy.oo</code> steht für das {{W|Unendlichzeichen}} <math>\infty</math> (die liegende Acht oder das Möbiusband). Mit <code>sympy.pprint(i)</code> ließe sich letzere Ausgabe etwas schöner schreiben:
1
──────
log(2)
Man beachtete, <code>log</code> steht hier für den natürlichen Logarithmus <code>ln</code>.
== Aufgaben ==
* Integrieren Sie die Funktion <math>y = \log(x) + 10x</math> von 1 bis 5.
* Integrieren Sie die Funktion <math>y = x^3</math> von 0 bis 4.
* Integrieren Sie <math>\int x^x(\log (x) + 1)\mathrm dx</math> symbolisch.
= Gewöhnliche Differenzialgleichungen =
== DGL numerisch lösen ==
Für die Lösung von Differenzialgleichungen steht u.a. die Funktion scipy.integrate.solve_ivp() zur Verfügung. Diese Funktion implementiert auch das Runge-Kutta-Verfahren (RK45).
{{Wikipedia | Runge-Kutta-Verfahren}}
Beispiel <math>y' = x^2 + y^3</math>:
import scipy
import numpy as np
import matplotlib.pyplot as plt
def dy_dx(x, y):
return x**2 + y**3
y0 = [1]
xi = [0, 1]
x = np.arange(0, 1, 0.01)
z = scipy.integrate.solve_ivp(dy_dx, xi, y0, method="RK45", dense_output=True)
y = z.sol(x)
plt.plot(x, y.T)
plt.grid()
plt.show()
[[Datei:PythonIng_dgl1.png]]
== DGL symbolisch lösen ==
Beispiel <math>y' = x^2 + y^3</math>:
import sympy
x = sympy.symbols("x")
y = sympy.Function("f")(x)
dgl = x**2 + y**3
lsg = sympy.dsolve(dgl, y)
print(lsg)
Ausgabe:
[Eq(f(x), (-x**2)**(1/3)), Eq(f(x), (-x**2)**(1/3)*(-1 - sqrt(3)*I)/2), Eq(f(x), (-x**2)**(1/3)*(-1 + sqrt(3)*I)/2)]
Mit <code>sympy.pprint</code> (pretty print) lässt sich die Ausgabe etwas übersichtlicher darstellen.
import sympy
x = sympy.symbols("x")
y = sympy.Function("f")(x)
dgl = x**2 + y**3
lsg = sympy.dsolve(dgl, y)
sympy.pprint(lsg)
Ausgabe:
⎡ _____ _____ ⎤
⎢ _____ 3 ╱ 2 3 ╱ 2 ⎥
⎢ 3 ╱ 2 ╲╱ -x ⋅(-1 - √3⋅ⅈ) ╲╱ -x ⋅(-1 + √3⋅ⅈ)⎥
⎢f(x) = ╲╱ -x , f(x) = ────────────────────, f(x) = ────────────────────⎥
⎣ 2 2 ⎦
== Aufgaben ==
* Lösen Sie die Differenzialgleichung <math>y' = \frac{1}{x\cdot y}</math> mit Python. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung <math>m' = -k\cdot m</math>. Kontrollieren Sie das Ergebnis, indem Sie die DGl händisch lösen.
* Lösen Sie die Differenzialgleichung <math>y' = \sqrt{|y|}</math>.
=Laplace-Transformation=
Laplace-Transformation:
<math>F(s) =\mathcal{L} \left\{f\right\}(s) = \int_{0}^{\infty} f(t) \mathrm e^{-st} \,\mathrm{d}t, \qquad s\in\mathbb{C}
</math>
Inverse Laplace-Transformation:
<math>\mathcal{L}^{-1} \left\{F\right\}(t)
= \frac{1}{2 \pi \mathrm j} \int_{ \gamma - \mathrm j \infty}^{ \gamma + \mathrm j \infty} \mathrm e^{st} F(s)\,\mathrm ds
= \begin{cases}
f(t) & \text{für } t \geq 0 \\
0 & \text{für } t < 0
\end{cases}
</math>
Siehe auch [[Ing_Mathematik:_Laplace-Transformation]]
Code:
import sympy
from sympy.abc import t, s
# Laplace-Transformation der Funktion f(t) = 1 (Heaviside-Fkt.)
f = 1
# alternativ: f = sympy.Heaviside(t)
F = sympy.laplace_transform(f, t, s, noconds=True)
print("Laplace-Transformierte F(s):", F)
# Inverse Laplace-Transformation zurück in den Zeitbereich
f_inv = sympy.inverse_laplace_transform(F, s, t)
print("Inverse Transformation f(t):", f_inv)
Ausgabe:
Laplace-Transformierte F(s): 1/s
Inverse Transformation f(t): Heaviside(t)
Die Zeile
from sympy.abc import t, s
steht alternativ für
t = sympy.symbols("t")
s = sympy.symbols("s")
<u>Aufgaben</u>: Ermitteln Sie mittels SymPy die <math>\mathcal{L}</math>-Transformierten und dann wieder die <math>\mathcal{L}^{-1}</math>-Transformationen (ähnlich wie beim obigen Beispiel):
* <math>\sin(t) \circ\! -\! \bullet \ ?</math>
* <math>t^3 \circ\! -\! \bullet \ ?</math>
* <math>\text{e}^{\omega t} \circ\! -\! \bullet \ ?</math>
=Fourier-Reihen=
<math>
f(x)\approx \frac{a_{0}}{2}+\sum_{k=1}^{\infty}\left(a_{k}\cos\left(kx\right)+b_{k}\sin\left(kx\right)\right)
</math>
<math>
a_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\cos\left(kx\right)\mathrm dx\quad\text{für }k\geq0
</math>
<math>
b_{k} = \frac{1}{\pi}\int_{-\pi}^{\pi}f(x)\cdot\sin\left(kx\right)\mathrm dx\quad\text{für }k\geq1
</math>
Für die Sägezahnfunktion <math>y=x;\, 0 < x < 2\pi</math> sei die Fourierreihe mit einem Python-Programm (unter Mithilfe von sympy) hergeleitet.
Code:
from sympy import fourier_series, pi, symbols, pprint
x = symbols('x')
f = x
s = fourier_series(f, (x, 0, 2*pi))
pprint(s.truncate(n=4))
Ausgabe:
2⋅sin(3⋅x)
-2⋅sin(x) - sin(2⋅x) - ────────── + π
3
Siehe auch [[Ing Mathematik: Fourierreihen]].
Ein komplizierteres Beispiel:
[[Datei:IngMath fourier bsp13.svg | 300px]]
<math>0\le t < T/2\text{:}\quad f(t) = H</math>
<math>T/2 \le t \le T\text{:}\quad f(t) = \frac{2H}{T}\left( t-\frac{T}{2}\right)</math>
Code:
import sympy as sp
H = sp.Symbol('H', positive=True)
T = sp.Symbol('T', positive=True)
t = sp.Symbol('t')
f = sp.Piecewise(
(H, (t > 0) & (t < T/2)),
(2*H/T*(t-T/2), (t > T/2) & (t < T))
)
f_series = sp.fourier_series(f, (t, 0, T))
sp.pprint(f_series.truncate(4))
Ausgabe:
⎛2⋅π⋅t⎞ ⎛4⋅π⋅t⎞ ⎛6⋅π⋅t⎞ ⎛2⋅π⋅t⎞ ⎛6⋅π⋅t⎞
H⋅sin⎜─────⎟ H⋅sin⎜─────⎟ H⋅sin⎜─────⎟ 2⋅H⋅cos⎜─────⎟ 2⋅H⋅cos⎜─────⎟
⎝ T ⎠ ⎝ T ⎠ ⎝ T ⎠ ⎝ T ⎠ ⎝ T ⎠ 3⋅H
──────────── - ──────────── + ──────────── + ────────────── + ────────────── + ───
π 2⋅π 3⋅π 2 2 4
π 9⋅π
=Rechnen mit wirklich großen Zahlen=
Bekannt ist, dass Python kaum Einschränkungen beim Wertebereich von Ganzzahlen hat, z.B.
print(10**300)
Ausgabe (gekürzt):
100000000000000000000...00000000000000000000000000000000000000000000000000000000000000000000000
Ähnliches geht auch mit Gleitpunktzahlen, z.B. durch die Verwendung des Moduls [https://mpmath.org/ mpmath]:
import mpmath
print(mpmath.mpf(1500.4)**mpmath.mpf(300))
Ausgabe:
7.27975299218612e+952
Anderes Beispiel:
from mpmath import mp, pi
mp.dps = 100
print(pi)
Ausgabe:
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068
mpmath kann noch einiges mehr, dazu sei aber auf die entsprechende Dokumentation auf der mpmath-Homepage verwiesen. mpmath ist Bestandteil von SymPy, kann aber auch separat installiert werden.
Aber auch Python selbst besitzt eine Möglichkeit, um mit großen bzw. exakten Gleitpunktzahlen zu rechnen, nämlich das interne Modul decimal. Dieses hat einige Vorteile gegenüber mpmath, aber auch gravierende Nachteile. Diese seien hier nicht detailliert aufgezählt. Grob gesagt hat decimal im Finanzwesen seine Berechtigung. Für wissenschaftliche Anwendungen wird aber mpmath vorzuziehen sein, da es u.a. vielfältige mathematische Funktionen bereit stellt. Nachfolgend ein einfaches Beispiel mit decimal:
import decimal
print("Potenzierung:", decimal.Decimal(1500.4) ** decimal.Decimal(300.0))
print("Einfache Addition:", 0.1 + 0.2)
decimal.getcontext().prec = 50
print("Addition mit decimal:", decimal.Decimal("0.1") + decimal.Decimal("0.2"))
Ausgabe:
Potenzierung: 7.279752992186121551039839134E+952
Einfache Addition: 0.30000000000000004
Addition mit decimal: 0.3
<u>Aufgabe:</u> Recherchieren Sie im Internet die genauen Vor- und Nachteile von decimal und mpmath. Verwenden Sie dazu auch KI (z.B. von Google, chatgpt).
= Umgang mit großen Datenmengen =
Hier wird nur schlagwortartig auf diese Thematik eingegangen.
* h5py ist eine externe Bibliothek, die als Schnittstelle zum {{W|Hierarchical Data Format|HDF5-Datenformat}} dient.
* h5py ermöglicht es, große Mengen an numerischen Daten effizient auf der Festplatte zu speichern und extrem schnell zu verarbeiten.
* h5py wird u.a. für das {{W|Maschinelles Lernen|maschinelle Lernen}} eingesetzt.
* Die h5py-Homepage findet sich auf [https://www.h5py.org/].
= pint - mit physikalischen Größen rechnen =
[[File:Pint-Glas_UK.jpg|right|100px]]
pint ist ein externes Python-Paket zur Manipulation von physikalischen Einheiten. Es muss vor der ersten Benutzung installiert werden (Vorgehensweise wie immer: pip, YaST, via venv etc.).
Beispiel:
import pint
import numpy as np
ureg = pint.UnitRegistry()
# Einfache Berechnung
print(3 * ureg.meter + 4 * ureg.cm)
# Mit NumPy
npeinzel = [3, 4] * ureg.meter + [2, 5] * ureg.cm
print(npeinzel)
npsum = np.sum(npeinzel)
print(npsum)
# Konvertierung von Einheiten
npsum_inch = npsum.to(ureg.inch)
print(npsum_inch)
print(npeinzel.magnitude)
print(npeinzel.units)
print(npeinzel.dimensionality)
Ausgabe:
3.04 meter
[3.02 4.05] meter
7.07 meter
278.3464566929134 inch
[3.02 4.05]
meter
[length]
Die Dokumentation zu pint findet sich auf [https://pint.readthedocs.io/en/stable/].
=Regelungstechnische Aufgabenstellungen=
Für regelungstechnische Aufgaben gibt es u.a. das externe Paket <code>control</code>. Hier soll nicht detailliert darauf eingegangen werden. Anhand eines Beispiels soll anschließend nur die Visualisierung in Form eines Bode-Diagramms und der Sprungantwort gezeigt werden. Gegeben sei ein P-Regler mit <math>R = \frac{5}{2}</math> und eine Strecke <math>S= \frac{1}{30s^3+20s^2+10s+1,5}</math>. Gesucht sei vorerst ein Bode-Diagramm für den offenen Regelkreis und das Führungsverhalten.
import numpy as np
import control as ct
import matplotlib.pyplot as plt
zaehler1 = np.array([1.])
nenner1 = np.array([30., 20., 10., 1.5])
strecke = ct.tf(zaehler1, nenner1)
zaehler2 = np.array([5.])
nenner2 = np.array([2.])
regler = ct.tf(zaehler2, nenner2)
G0 = regler*strecke # oder: G0 = ct.series(regler, strecke)
Gw = ct.feedback(G0)
ct.bode_plot(G0, label='G0')
ct.bode_plot(Gw, label='Gw')
plt.show()
[[Datei:PythonIng_bode1.svg]]
Nun noch für obiges Beispiel die Sprungantwort. Diese zeigt einige große Überschwinger, d.h. der Regler kann sicher noch optimiert werden.
import numpy as np
import control as ct
import matplotlib.pyplot as plt
zaehler1 = np.array([1.])
nenner1 = np.array([30., 20., 10., 1.5])
strecke = ct.tf(zaehler1, nenner1)
zaehler2 = np.array([5.])
nenner2 = np.array([2.])
regler = ct.tf(zaehler2, nenner2)
G0 = regler*strecke
Gw = ct.feedback(G0)
t, y = ct.step_response(Gw)
plt.plot(t,y)
plt.title('Sprungantwort')
plt.xlabel('t')
plt.ylabel('h(t)')
plt.grid()
plt.show()
[[Datei:PythonIng_bode3.svg]]
Einige weitere wichtige Daten (Phasenreserve, Amplitudenreserve, Durchtrittsfrequenz) lassen sich mittels der <code>control</code>-Funktion <code>margin()</code> ermitteln. Die Ortskurve lässt sich mit der Funktion <code>nyquist_plot()</code> zeichnen. Dies sei hier aber nicht weiter ausgeführt.
==Aufgaben==
* Zeichen Sie mit Python die Ortskurve für obiges Beispiel.
* Was passiert, wenn man die Reglerverstärkung weiter aufdreht (z.B. auf <math>R = \frac{25}{2}</math>)?
* Wie sehen das Bode-Diagramm und die Sprungantwort aus, wenn ein PI-Regler verwendet wird?
= Stereostatik etc. =
Das Modul SymPy bietet einige Möglichkeiten einfache Bauwerke zu berechnen, z.B. Balken oder Fachwerke. Nachfolgend wird ein einfaches Fachwerk berechnet und gezeichnet.
Python-Code:
from sympy.physics.continuum_mechanics.truss import Truss
t = Truss()
# Knoten
t.add_node(("A", -3, 0), ("B", 0, 0), ("C", 4, 0), ("D", 7, 0),
("E", 6, 1.5), ("F", 2, 3), ("G", -2, 1.5))
# Stäbe
t.add_member(("AB","A","B"), ("BC","B","C"), ("CD","C","D"))
t.add_member(("AG","A","G"), ("GB","G","B"), ("GF","G","F"))
t.add_member(("BF","B","F"), ("FC","F","C"), ("CE","C","E"))
t.add_member(("FE","F","E"), ("DE","D","E"))
# Auflager; roller ... Loslager, pinned ... Festlager
t.apply_support(("A","roller"), ("D","pinned"))
# Einwirkende Kräfte
t.apply_load(("G", 5, 270), ("E", 3, 90))
# Berechnung
t.solve()
print("Reaction Forces: ", t.reaction_loads)
print("Internal Forces: ", t.internal_forces)
# Fachwerk zeichnen
p = t.draw()
p.show()
Ausgabe auf der Konsole:
Reaction Forces: {'R_A_y': 4.20000000000000, 'R_D_x': 0, 'R_D_y': -2.20000000000000}
Internal Forces: {'AB': 2.80000000000000, 'BC': 0.333333333333333, 'CD': -1.46666666666667,
'AG': -5.04777178564958, 'GB': -2.05555555555556, 'GF': -1.23413387432364,
'BF': 0.411111111111111*sqrt(13), 'FC': -0.3*sqrt(13), 'CE': 1.50000000000000,
'FE': 0.284800124843917, 'DE': 2.64407093534026}
Zeichnung:
[[File:PythonIng_fachwerk1.svg|300px]]
Details zu diesem Thema siehe z.B. [https://docs.sympy.org/latest/modules/physics/continuum_mechanics/index.html Continuum Mechanics] oder [https://docs.sympy.org/latest/tutorials/physics/continuum_mechanics/index.html Continuum Mechanics Tutorials]. Auch andere mechanische Probleme werden von SymPy abgehandelt ([https://docs.sympy.org/latest/tutorials/physics/index.html Physics Tutorials]).
== Aufgabe ==
Gegeben sei ein einseitig eingespannter Kragträger. Belastet wird er durch eine Einzellast am Trägerende. Für die Daten siehe folgende ASCII-Skizze:
| 20 kN
//|---> x |
//| V
//|----------------------
//| 10 m |
Elastizitätsmodul E = 2,1*10⁵ N/mm²
Flächenträgheitsmoment I = 0.001 m⁴
Berechnen Sie die Auflagerreaktionen, den Querkraft- und Biegemomentenverlauf, sowie die Verformungen.
Stellen Sie dies mit Hilfe von SymPy graphisch und auch mittels Formeln dar. Verwenden Sie dazu auch pprint (pretty print) aus dem SymPy-Modul. Zwecks Lösungsansatz siehe die oben aufgeführte Seite "Continuum Mechanics Tutorials". Achten Sie auch auf die Einheiten! Kontrollieren Sie das Ganze mittels händischer Rechnung. In dem genannten Tutorial ist von "Singularity Functions" die Rede. Gemeint ist damit in diesem Kontext die {{W|Föppl-Klammer}}.
Einige Python-Programme, vorrangig zu Maschinenelementen, finden sich auf [https://baymp.de/download_python.html BayMP für Python] (Balken, Zahnräder, Stabknickung usw.).
=Thermodynamik=
== PYroMat ==
Für thermodynamische Aufgabenstellungen gibt es verschiedene externe Module. Eines davon ist PYroMat (siehe auch [http://pyromat.org]). Damit lassen sich thermodynamische Stoffdaten für viele Substanzen berechnen.
Beispiel (einige Stoffdaten für Wasser bei 400°C und 20 bar berechnen):
import pyromat as pm
# Wasserdaten laden:
H2O = pm.get('mp.H2O')
# Stoffdaten berechnen:
T = 673.15 # Temperatur in Kelvin
p = 20 # Druck in bar
v = H2O.v(T, p)
h = H2O.h(T, p)
s = H2O.s(T, p)
print(f"Spezifisches Volumen: {v} m³/kg")
print(f"Spezifische Enthalpie: {h} kJ/kg")
print(f"Spezifische Entropie: {s} kJ/(kg K)")
Ausgabe:
Spezifisches Volumen: [0.1512163] m³/kg
Spezifische Enthalpie: [3248.3789473] kJ/kg
Spezifische Entropie: [7.12924142] kJ/(kg K)
<small>
PYroMat muss vorab installiert werden (z.B. mittels pip, in eine virtuelle Umgebung)
</small>
<code>mp</code> steht für "multi phase". Für ein ideales Gas wäre <code>ig</code> zuständig, z.B. <code>'ig.O2'</code>.
Beispiel (T-s-Diagramm für Wasser zeichnen):
import numpy as np
import matplotlib.pyplot as plt
import pyromat as pm
# Konfigurieren
pm.config["unit_pressure"] = "bar"
pm.config["unit_temperature"] = "K"
fluid = pm.get("mp.H2O")
# Temperaturbereich für das Nassdampfgebiet
T_tripel = 273.16
T_crit = 647.096
T = np.linspace(T_tripel, T_crit - 0.1, 200)
# Sättigungslinien berechnen und zeichnen
for x in np.linspace(0.0, 1.0, 5):
s = fluid.s(T=T, x=x)
if(x<=0.0):
plt.plot(s, T, label="Siedelinie x=%3.1f" % x, linewidth=2.0)
elif(x>=1.0):
plt.plot(s, T, label="Taulinie x=%3.1f" % x, linewidth=2.0)
else:
plt.plot(s, T, label="x=%3.1f" % x, linewidth=1.0)
# Isobaren zeichnen
p_values = [0.1, 1, 10, 50, 100]
T_isobar = np.linspace(T_tripel, 1000, 200)
t = 0.7
for p in p_values:
s_iso = fluid.s(T=T_isobar, p=p)
plt.plot(s_iso, T_isobar, 'k-', alpha=0.8, linewidth=0.8)
t += .05
idx = int(len(s_iso) * t)
plt.text(s_iso[idx], T_isobar[idx], f"{p} bar", fontsize=9, alpha=0.8)
# Diagramm zeichnen
plt.title("T-s-Diagramm für Wasser")
plt.xlabel("Spezifische Entropie s in kJ/kg K", fontsize=10)
plt.ylabel("Temperatur T in K", fontsize=10)
plt.legend(loc="best")
plt.grid(True)
plt.show()
Ausgabe (in etwa so):
[[Datei:T-s-Diagramm fuer Wasser.svg|400px]]
== CoolProp ==
Auch mit CoolProp können Stoffdaten berechnet werden. Siehe auch [https://coolprop.org/coolprop/wrappers/Python/index.html]
Beispiel (Wasser bei 20bar und 400°C):
import CoolProp.CoolProp as CP
fluid = 'Water'
T = 673.15 # Temperatur in Kelvin
P = 20e5 # Druck in Pascal
dichte = CP.PropsSI('D', 'T', T, 'P', P, fluid)
enthalpie = CP.PropsSI('H', 'T', T, 'P', P, fluid)
entropie = CP.PropsSI('S', 'T', T, 'P', P, fluid)
print(f"Spez. Volumen: {1/dichte:.6f} m³/kg")
print(f"Spez. Enthalpie: {enthalpie:.2f} J/kg")
print(f"Spez. Entropie: {entropie:.2f} J/kgK")
Ausgabe:
Spez. Volumen: 0.151215 m³/kg
Spez. Enthalpie: 3248344.02 J/kg
Spez. Entropie: 7129.16 J/kgK
== iapws ==
Um Werte für Wasser(dampf) zu erhalten (IAPWS; '''I'''nternational '''A'''ssociation for the '''P'''roperties of '''W'''ater and '''S'''team) gibt es die Bibliothek iapws. Siehe auch [https://iapws.org/] und [https://pypi.org/project/iapws/]
Beispiel (Wasser für 20bar und 400°C):
from iapws import IAPWS97
dampf = IAPWS97(P=2.0, T=673.15)
print(f"Spezifisches Volumen: {dampf.v:.6f} m³/kg")
print(f"Spezifische Enthalpie: {dampf.h:.2f} kJ/kg")
print(f"Spezifische Entropie: {dampf.s:.4f} kJ/(kgK)")
print(f"Phase: {dampf.phase}")
Ausgabe:
Spezifisches Volumen: 0.151208 m³/kg
Spezifische Enthalpie: 3248.23 kJ/kg
Spezifische Entropie: 7.1290 kJ/(kgK)
Phase: Gas
== TESPy ==
Ein anderes Modul für einen anderen Aufgabenzweck ist TESPy ('''T'''hermal '''E'''ngineering '''S'''ystems in '''Py'''thon). Dieses Modul ist für die Anlagensimulation zuständig. Für nähere Informationen siehe [https://tespy.readthedocs.io/en/main/getting_started/introduction.html]. Als Beipiel sei hier vorerst Code, der von der Google KI generiert wurde, angeführt. Der Code wurde überarbeitet, damit keine Warnungen auftreten. Bitte aber den Code trotzdem mit Vorsicht genießen, auch KI-generierter Code kann Fehler aufweisen. Eine Pumpe wird berechnet:
from tespy.components import Sink, Source, Pump
from tespy.connections import Connection
from tespy.networks import Network
# 1. Netzwerk definieren (Zentrales Steuerungselement)
# Wir wählen Wasser als Fluid und bar/Celsius als Einheiten
nw = Network(fluids=["water"])
nw.units.set_defaults(pressure="bar", pressure_difference="bar",
temperature="°C", enthalpy="kJ / kg")
# 2. Komponenten erstellen
eingang = Source("Wasserquelle")
ausgang = Sink("Wasserspeicher")
pumpe = Pump("Speisewasserpumpe")
# 3. Verbindungen definieren (Komponenten miteinander verknüpfen)
c1 = Connection(eingang, "out1", pumpe, "in1")
c2 = Connection(pumpe, "out1", ausgang, "in1")
# Verbindungen dem Netzwerk hinzufügen
nw.add_conns(c1, c2)
# 4. Randbedingungen und Parameter festlegen
# Zustand am Eingang (Druck, Temperatur, Massenstrom, Fluid-Zusammensetzung)
c1.set_attr(
v=1, # Massenstrom: 1 kg/s
T=20, # Temperatur: 20 °C
p=1, # Druck: 1 bar
fluid={"water": 1}, # 100% Wasser
)
# Zustand am Ausgang / Zielwerte der Pumpe
c2.set_attr(p=10) # Ziel-Druck nach der Pumpe: 10 bar
# Pumpeneigenschaften festlegen
pumpe.set_attr(eta_s=0.8) # Isentroper Wirkungsgrad von 80%
# 5. Simulation ausführen
nw.solve(mode="design")
# 6. Ergebnisse ausgeben
nw.print_results()
# Spezifische Werte direkt auslesen
print("\n--- Auswertung ---")
print(f"Erforderliche Pumpenleistung: {pumpe.P.val / 1000:.2f} kW")
print(f"Temperatur nach der Pumpe: {c2.T.val:.2f} °C")
Ausgabe (gekürzt):
iter | residual | progress | massflow | pressure | enthalpy | fluid | component
-------+------------+------------+------------+------------+------------+------------+------------
1 | 7.04e+04 | 12 % | 9.96e+02 | 0.00e+00 | 8.81e+04 | 0.00e+00 | 0.00e+00
2 | 5.91e-12 | 100 % | 1.11e-13 | 0.00e+00 | 7.39e-12 | 0.00e+00 | 0.00e+00
3 | 5.80e-12 | 100 % | 0.00e+00 | 0.00e+00 | 7.25e-12 | 0.00e+00 | 0.00e+00
4 | 5.80e-12 | 100 % | 0.00e+00 | 0.00e+00 | 7.25e-12 | 0.00e+00 | 0.00e+00
Total iterations: 4, Calculation time: 0.01 s, Iterations per second: 480.85
##### RESULTS (Pump) #####
+-------------------+----------+----------+-----------+----------+----------+----------+
| | P | pr | dp | eta | eta_s | head |
|-------------------+----------+----------+-----------+----------+----------+----------|
| Speisewasserpumpe | 1.12e+06 | 1.00e+01 | -9.00e+00 | 8.00e-01 | 8.00e-01 | 9.19e+01 |
+-------------------+----------+----------+-----------+----------+----------+----------+
...
...
--- Auswertung ---
Erforderliche Pumpenleistung: 1124.77 kW
Temperatur nach der Pumpe: 20.07 °C
= Stochastik =
Die {{W|Stochastik}} ist ein sehr weites Feld. Hier werden etliche wichtige Themen kurz angerissen. Python stellt mit den Moduln math und statistics Software zu diesem Zwecke bereit. math und statistics sind bereits im Lieferumfang von Python enthalten. Aber auch mit den externen Modulen NumPy, SciPy, stochastic und pandas kann man Stochastik in Python betreiben. Die Theorie der Wahrscheinlichkeitsrechnung und Statistik soll etwas später in Band 5 dieser Buchreihe behandelt werden.
== Lageparameter ==
import statistics
werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
m1 = statistics.mean(werte)
m2 = statistics.mode(werte)
m3 = statistics.median(werte)
print("Arithmetischer Mittelwert = ", m1)
print("Modalwert = ", m2)
print("Median = ", m3)
Ausgabe:
Arithmetischer Mittelwert = 3.5
Modalwert = 1
Median = 3.0
== Streuungsparameter ==
Beispiel (Berechnung der Standardabweichung):
import statistics
werte = [1, 3, 4, 4, 1, 7, 9, 1, 2, 3]
s = statistics.stdev(werte)
print("Standardabweichung = ", s)
Ausgabe:
Standardabweichung = 2.6770630673681683
Beispiel (Berechnung des Variationskoeffizienten V = Standardabweichung/Mittelwert)
import numpy as np
from scipy import stats
import statistics
k = 50
dat1 = [14, 21, 18, 25, 30, 17, 20]
dat = np.array(dat1)
# Mit SciPy
v = stats.variation(dat)
vddof = stats.variation(dat, ddof=1)
print("V SciPy: ", v)
print("V DDOF SciPy: ", vddof)
print(k*"-")
# mit NumPy
mittelwert1 = np.mean(dat)
std_abw1 = np.std(dat)
std_abw1ddof = np.std(dat, ddof=1)
v1= std_abw1 / mittelwert1
v1ddof = std_abw1ddof / mittelwert1
print("Mittelwert NumPy: ", mittelwert1)
print("Std.abw. NumPy: ", std_abw1)
print("Std.abw. DDOF NumPy: ", std_abw1ddof)
print("V NumPy: ", v1)
print("V DDOF NumPy: ", v1ddof)
print(k*"-")
# nur mit reinem Python
mittelwert2 = statistics.mean(dat1)
std_abw2 = statistics.stdev(dat1)
v2 = std_abw2 / mittelwert2
print("Mittelwert Python: ", mittelwert2)
print("Std.abw. Python: ", std_abw2)
print("V Python:", v2)
print(k*"-")
Ausgabe:
V SciPy: 0.23890355966467272
V DDOF SciPy: 0.25804533701889254
--------------------------------------------------
Mittelwert NumPy: 20.714285714285715
Std.abw. NumPy: 4.948716593053935
Std.abw. DDOF NumPy: 5.3452248382484875
V NumPy: 0.23890355966467272
V DDOF NumPy: 0.2580453370188925
--------------------------------------------------
Mittelwert Python: 20.714285714285715
Std.abw. Python: 5.3452248382484875
V Python: 0.2580453370188925
--------------------------------------------------
Der Unterschied bei der Standardabweichung zwischen reinem Python und den externen Bibliotheken SciPy und NumPy entsteht dadurch, dass einmal durch (n-1) und das andere Mal nur durch n dividiert wird. Dies kann bei NumPy und SciPy dadurch entschärft werden, indem <code>ddof=1</code> gesetzt wird. ddof steht für '''D'''elta '''D'''egrees '''o'''f '''F'''reedom. <small>Je größer die Anzahl der Datensätze n wird, umso weniger spielt das eine Rolle.</small>
== Kombinatorik ==
Beispiel:
import math
n = 7
k = 5
print("n! = ", math.factorial(n))
print("Kombinationen (n über k) = ", math.comb(n, k))
Ausgabe:
n! = 5040
Kombinationen (n über k) = 21
Siehe zu diesem Thema auch [[Ing Mathematik: Permutationen, Kombinationen, binomischer Lehrsatz]]. Die Anzahlen lassen sich einfach aus den dortigen Formeln ermitteln, z.B. bei Permutationen mit <math>n!</math> oder Variationen mit Wiederholungen als <math>n^k</math>. Will man die Kombinationen oder Variationen aber auch als Liste ausgeben, so kann das Modul <code>itertools</code> nützlich sein.
Beispiel (Variationen ohne Wiederholung):
from itertools import permutations
menge = ["A", "B", "C", "D"] # n = 4
k = 3
variationen = list(permutations(menge, k))
for v in variationen:
print("".join(v))
print(50*"-")
print(len(variationen))
Ausgabe (gekürzt):
ABC
ABD
ACB
...
DCA
DCB
--------------------------------------------------
24
Siehe zum Modul <code>itertools</code> auch die Website [https://docs.python.org/3/library/itertools.html].
* Variationen mit Wiederholung: <code>itertools.product()</code>
* Kombinationen ohne Wiederholung: <code>itertools.combinations()</code>
* Kombinationen mit Wiederholung: <code>itertools.combinations_with_replacement()</code>
== Zufallszahlen ==
Beispiel:
import random
# Ganzzahlige Zufallszahl von 1 bis 10
zufallszahl1 = random.randint(1, 10)
# Gleitpunktzahlen
# zwischen 0.0 und 1.0
zufallszahl2 = random.random()
# Zahl zwischen 1.5 und 9.5
zufallszahl3 = random.uniform(1.5, 9.5)
# aus Liste auswählen
farbe = ["Rot", "Grün", "Blau"]
zufallswert = random.choice(farbe)
print(zufallszahl1)
print(zufallszahl2)
print(zufallszahl3)
print(zufallswert)
Ausgabe, z.B.:
5
0.14147945849015753
6.894003397570905
Rot
Benötigt man mehrere Zufallszahlen, so ist das Modul <code>numpy</code> zu bevorzugen, z.B.:
* Normalverteilung: <code>np.random.normal(...)</code>
* Gleichverteilung: <code>np.random.uniform(...)</code>
== Histogramm ==
Zum Thema Histogramm siehe {{W|Histogramm}}.
Beispiel (mit Matplotlib):
import matplotlib.pyplot as plt
import numpy as np
daten = np.random.normal(loc=50, scale=10, size=1000)
plt.hist(daten, bins=25, edgecolor='darkgray')
plt.show()
Ausgabe:
[[Datei:IngMath_histogramm.svg|300px]]
Beispiel (mit Seaborn):
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
daten = np.random.normal(loc=50, scale=10, size=1000)
sns.set_theme(style="darkgrid")
sns.histplot(data=daten)
plt.show()
Ausgabe:
[[Datei:IngMath_histogramm2.svg|300px]]
Das Kürzel <code>sns</code> ist Konvention und steht für die fiktive Figur '''S'''amuel '''N'''orman '''S'''eaborn aus der US-Fernsehserie {{W|The West Wing – Im Zentrum der Macht | The West Wing}}.
== Box-Plot ==
[[File:Elements of a boxplot.svg|400px]]
Siehe auch {{W|Box-Plot}}.
Beispiel (mit Seaborn erstellt):
import seaborn as sns
import matplotlib.pyplot as plt
df = sns.load_dataset("tips")
sns.boxplot(data=df, x="day", y="tip", hue="day", legend=False)
plt.show()
Ausgabe:
[[Datei:IngMath_boxplot.svg|400px]]
Beispiel (mit Matplotlib erstellt):
import matplotlib.pyplot as plt
daten = [12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25]
plt.boxplot(daten, patch_artist=True)
plt.title("Boxplot mit Matplotlib")
plt.ylabel("Daten")
plt.show()
Ausgabe:
[[Datei:IngMath_boxplot2.svg|300px]]
Um mehrere Box-Plots unterschiedlicher Farbe mit Matplotlib in einem Diagramm zu zeichnen, können Sie folgendermaßen vorgehen:
import matplotlib.pyplot as plt
daten = [[12, 15, 18, 19, 22, 25, 28, 30, 31, 35, 42, 55, 12, 25],
[10, 19, 20, 21, 20, 30, 19, 40, 11, 17, 19, 21]]
farben = ["green", "blue"]
boxplot = plt.boxplot(daten, patch_artist=True)
for patch, farbe in zip(boxplot['boxes'], farben):
patch.set_facecolor(farbe)
plt.title("Boxplot mit Matplotlib")
plt.ylabel("Daten")
plt.show()
== Regressionsrechnung ==
Beispiel:
import numpy as np
import matplotlib.pyplot as plt
# Messpunkte
x = np.array([1, 3, 5, 6, 8, 10, 20])
y = np.array([3, 4, 5, 5, 7, 9, 11])
# Regressionskurve (Grad 1 = lineare Regression, 2 = Polynom-Regression 2. Gr.)
# y = kx + d
k, d = np.polyfit(x, y, deg=1)
# y = ax**2 + bx + c
a, b, c = np.polyfit(x, y, deg=2)
x_l = np.linspace(1, 20, 100)
y_p = a * x_l**2 + b * x_l + c
# Zeichnen
plt.scatter(x, y, color='green', label='Messpunkte')
plt.plot(x, k*x + d, color='blue', label='Regressionsgerade')
plt.plot(x_l, y_p, color='red', label='Regressionspolynom 2. Gr.')
plt.xlabel('x')
plt.ylabel('y')
plt.grid()
plt.axis("equal")
plt.legend(loc="best")
plt.show()
Ausgabe:
[[Datei:IngMath_regression.svg|400px]]
== Korrelationsrechnung ==
Beispiel:
import pandas as pd
import matplotlib.pyplot as plt
# Messdaten
x = [1, 3, 4, 5, 6]
y = [2, 4, 6, 8, 5]
daten = {'X': x, 'Y': y}
df = pd.DataFrame(daten)
# Korrelation
korr = df['X'].corr(df['Y'])
print(f"Korrelationskoeff.: {korr}")
# Messpunkte zeichnen
plt.scatter(x, y, color='green', label='Messpunkte')
plt.grid()
plt.axis("equal")
plt.legend(loc="best")
plt.show()
Ausgabe:
Korrelationskoeff.: 0.7556096518348252
[[Datei:IngMath_korrelation.svg|300px]]
== Mengen und Venn-Diagramme ==
Beispiel:
import matplotlib.pyplot as plt
from matplotlib_venn import venn2
menge_a = {1, 2, 3, 4, 5, 6}
menge_b = {4, 5, 6, 7, 8}
vereinigung = menge_a | menge_b
schnitt = menge_a & menge_b
print("Vereinigungsmenge = ", vereinigung)
print("Schnittmenge = ", schnitt)
venn2([menge_a, menge_b], set_labels=('Menge A', 'Menge B'))
plt.show()
Ausgabe:
Vereinigungsmenge = {1, 2, 3, 4, 5, 6, 7, 8}
Schnittmenge = {4, 5, 6}
[[Datei:IngMath_venn.svg|300px]]
Siehe auch {{W|Mengendiagramm#Venn-Diagramme}}.
== Verteilungs- und Dichtefunktion ==
* CDF ... '''C'''umulative '''D'''istribution '''F'''unction, Verteilungsfunktion
* PDF ... '''P'''robability '''D'''ensity '''F'''unction, Dichtefunktion
Beispiel (Normalverteilung):
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm
my, sigma = 0, 1
x = np.linspace(-4, 4, 50)
pdf = norm.pdf(x, my, sigma)
cdf = norm.cdf(x, my, sigma)
plt.plot(x, pdf, lw=2, label="Dichtefunktion")
plt.plot(x, cdf, lw=2, label="Verteilungsfunktion")
plt.legend()
plt.grid()
plt.show()
Ausgabe:
[[Datei:IngMath_cdf_pdf.svg|300px]]
Beispiel (<math>\chi^2</math>-Verteilung):
import numpy as np
import matplotlib.pyplot as plt
import scipy.stats as stats
x = np.linspace(0, 20, 500)
# df ... degree of freedom, Freiheitsgrad
pdf = (stats.chi2.pdf(x, df=2), stats.chi2.pdf(x, df=5), stats.chi2.pdf(x, df=10))
for i in range(0,3):
if(i==0):
lab = "Freiheitsgrad 2"
elif(i==1):
lab = "Freiheitsgrad 5"
else:
lab = "Freiheitsgrad 10"
plt.plot(x, pdf[i], label=lab, lw=2)
plt.grid()
plt.legend()
plt.show()
Ausgabe:
[[Datei:IngMath_chi2.svg | 300px]]
== Schätzen und Testen ==
=== Intervallschätzung ===
Als Beispiel seien Daten gegeben, die von ''Dürr, Mayer: Wahrscheinlichkeitsrechnung und Schließende Statistik; 7. Aufl., Hanser, 2014, Seite 137'' stammen. Und zwar soll das 95%-Vertrauensintervall für den Mittelwert des Kaloriengehalts (kcal/100g) von Hähnchen ermittelt werden. Wir wollen das mit Python inkl. NumPy und SciPy durchführen. Die Stichprobe ist groß (50 Hähnchen):
Python-Code:
import numpy as np
import scipy.stats as stats
# Stichprobe
daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
242, 236, 174, 240, 195, 223, 213, 209, 200, 203]
# Parameter definieren
konfidenzniveau = 0.95
mean = np.mean(daten)
std = np.std(daten, ddof=1)
stdfehler = stats.sem(daten)
intervall = stats.norm.interval(confidence=konfidenzniveau, loc=mean, scale=stdfehler)
print(f"Mittelwert: {mean}")
print(f"Standardabweichung: {std}")
print(f"Konfidenzintervall: {intervall}")
Ausgabe:
Mittelwert: 215.48
Standardabweichung: 33.14238915925757
Konfidenzintervall: (np.float64(206.29356722321992), np.float64(224.66643277678006))
Diese Werte stimmen gerundet mit denen im genannten Buch überein. Zum Code selbst:
* sem steht für '''s'''tandard '''e'''rror of the '''m'''ean.
* <code>scipy.stats.norm</code> ... Modul für die Normalverteilung.
=== Punktschätzung ===
Gleiche Daten wie oben bei der Intervallschätzung.
Python-Code:
import numpy as np
from scipy import stats
daten = [309, 202, 234, 252, 240, 225, 241, 212, 118, 191,
236, 204, 213, 220, 219, 218, 195, 159, 195, 206,
207, 232, 215, 210, 204, 332, 241, 225, 235, 193,
238, 187, 189, 203, 190, 252, 227, 212, 180, 178,
242, 236, 174, 240, 195, 223, 213, 209, 200, 203
]
mu_hat, sigma_hat = stats.norm.fit(daten)
print(f"Schätzer für den Erwartungswert (μ): {mu_hat:.4f}")
print(f"Schätzer für die Standardabweichung (σ): {sigma_hat:.4f}")
Ausgabe:
Schätzer für den Erwartungswert (μ): 215.4800
Schätzer für die Standardabweichung (σ): 32.8093
=== Hypothesentests ===
Beispiel:
import numpy as np
import scipy.stats as stats
x_quer = 12.075 # Stichproben-Mittelwert
var = 0.069 # Stichproben-Varianz
n = 90 # Stichprobengröße
my_0 = 12.0 # Nullhypothese
alpha = 0.05 # Signifikanzniveau
z_stat = (x_quer - my_0) / np.sqrt(var / n)
p_val = 2 * (1 - stats.norm.cdf(np.abs(z_stat)))
print(f"Z-Statistik: {z_stat:.4f}")
if p_val < alpha:
print(f"p-Wert: {p_val:.6f} < alpha:", alpha)
print("Die Nullhypothese wird verworfen.")
else:
print(f"p-Wert: {p_val:.6f} > alpha:", alpha)
print("Die Nullhypothese wird nicht verworfen.")
Ausgabe:
Z-Statistik: 2.7087
p-Wert: 0.006755 < alpha: 0.05
Die Nullhypothese wird verworfen.
== Statistische Qualitätskontrolle ==
Beispiel (Mittelwertkarte):
import numpy as np
import matplotlib.pyplot as plt
# Gegeben
sollwert = 50.0
varianz = 4.0
stichproben_umfang = 1
daten = [49.5, 50.2, 53.0, 48.1, 52.6, 53.4, 49.8]
# Berechnung
standardabweichung = np.sqrt(varianz)
streuung = standardabweichung / np.sqrt(stichproben_umfang)
cl = sollwert
ucl = cl + 3 * streuung
lcl = cl - 3 * streuung
# Darstellung
plt.plot(daten, marker='o', linestyle='-', color='b', label='Messdaten')
plt.axhline(cl, color='green', linestyle='-', label=f'CL: {cl}')
plt.axhline(ucl, color='red', linestyle='--', label=f'UCL: {ucl:.2f}')
plt.axhline(lcl, color='red', linestyle='--', label=f'LCL: {lcl:.2f}')
plt.title('Mittelwertkarte')
plt.xlabel('Stichprobe')
plt.ylabel('Wert')
plt.legend(loc='lower left')
plt.grid(True)
plt.show()
Ausgabe:
[[Datei:IngMath_mittelwertkarte.svg|300px]]
Siehe auch {{W|Shewhart-Regelkarte}} und {{W|Qualitätsregelkarte}}.
* UCL ... '''U'''pper '''C'''ontrol '''Limit''', Obere Eingriffsgrenze
* LCL ... '''L'''ower '''C'''ontrol '''Limit''', Untere Eingriffsgrenze
* CL ... '''C'''enter '''L'''ine, Mittellinie
= Ein- und Ausgabe =
== print ==
Die Anweisung print haben wir schon oft verwendet. Hier soll anhand von Beispielen kurz beschrieben werden, was der Befehl print leisten kann.
print("Hallo", "Welt", 1, sep="-")
print("Hallo", end=" ")
print("Welt")
Ausgabe:
Hallo-Welt-1
Hallo Welt
== input ==
a = int(input("Zahl 1: "))
b = int(input("Zahl 2: "))
print("a + b = ", a+b)
Ausgabe (nach Eingabe der beiden Ganzzahlen):
Zahl 1: 4
Zahl 2: 5
a + b = 9
== Aus Dateien lesen ==
Es seinen die datei.txt
Hallo Welt.
Wie geht es dir?
...
und test1.py
dat = open("datei.txt", mode = "r")
print(dat.read())
dat.close()
Ausgabe
Hallo Welt.
Wie geht es dir?
...
Mit dem open()-Befehl wird die Datei datei.txt im Lesemodus geöffnet (r ... read). Mit dem read()-Befehl wird die Datei eingelesen und mittels print ausgegeben.
== In Dateien schreiben ==
dat = open("datei.txt", mode = "a", encoding = "utf-8")
dat.write("Hänge Zeile an\n")
dat.close()
Die Datei datei.txt sieht nach Abarbeitung des obigen Skripts nun so aus
Hallo Welt.
Wie geht es dir?
...
Hänge Zeile an
Es wird die Datei im Schreibmodus geöffnet (a ... append (anhängend), w ... write (überschreibend)).
write() fügt hier also eine Zeile Text am Dateiende ein. close() schließt die Datei wieder.
Das close() kann man sich mit der with-Anweisung auch sparen.
with open("datei.txt", mode="a", encoding="utf-8") as dat:
dat.write("Hänge Zeile an\n")
= Benutzeroberflächen erstellen =
== tkinter ==
{{Wikipedia | Tkinter}}
Python bietet standardmäßig das Modul tkinter zur Programmierung von Benutzeroberflächen. Es müssen also bei der Verwendung von tkinter keine externen Module installiert werden. Hier wird eine (sehr) kurze Einführung in das Erstellen von grafischen Oberflächen mittels tkinter gegeben.
import tkinter as tk
win = tk.Tk()
win.title("Hallo Welt!")
win.minsize(300, 50)
but = tk.Button(win, text = "Push the button")
but.pack()
win.mainloop()
Ausgabe:
[[Datei:PythonIng_gui1.jpg]]
Ein etwas komplizierteres Beispiel sei nachfolgend gezeigt. Es sollen zwei Strings miteinander verknüpft und ausgegeben werden.
import tkinter as tk
win = tk.Tk()
win.title("Hallo Welt!")
def on_button_clicked():
str = ent1.get() + ent2.get()
lab2["text"] = str
ent1 = tk.Entry(win)
ent2 = tk.Entry(win)
lab1 = tk.Label(win, text="verknuepfen mit")
lab2 = tk.Label(win, text="")
but = tk.Button(win, text = "=", command=on_button_clicked)
ent1.pack(side="left")
lab1.pack(side="left")
ent2.pack(side="left")
but.pack(side="left")
ent2.pack(side="left")
lab2.pack(side="left")
win.mainloop()
Ausgabe (vor der Eingabe der Teilstrings):
[[Datei:PythonIng_gui2.jpg]]
Ausgabe (nach der Eingabe der Teilstrings und dem Drücken des =-Buttons):
[[Datei:PythonIng_gui3.jpg]]
== curses ==
{{Wikipedia | curses}}
Mit dem curses-Modul lassen sich u.a. TUIs ('''T'''ext '''U'''ser '''I'''nterfaces) erstellen. Ein sehr einfaches Beispiel zur allgemeinen Funktionsweise wird nachstehend geliefert.
import curses
stdscr = curses.initscr()
curses.start_color()
curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
stdscr.clear()
stdscr.addstr("Hallo Welt", curses.color_pair(1))
stdscr.refresh()
stdscr.getch()
curses.endwin()
Als Ausgabe sollte <span style="color:#FF0000;">Hallo Welt</span> (rote Schrift auf weißem Hintergrund) auf dem Terminal/der Konsole erscheinen. Getestet wurde dies mit openSUSE Tumbleweed, Python-Version 3.13.12. Das entsprechende Python-curses-Package muss installiert sein.
Allgemeine Informationen zur Terminal-/Konsolengröße und Cursorposition liefert folgendes Programm:
import curses
stdscr = curses.initscr()
stdscr.addstr(3, 5, "LINES: %d" % curses.LINES)
stdscr.addstr(4, 5, "COLS: %d" % curses.COLS)
(y,x) = stdscr.getyx()
stdscr.addstr(5, 5, "Momentane Cursorposition: [%d, %d]" % (y, x))
(y,x) = stdscr.getbegyx()
stdscr.addstr(6, 5, "Koordinatenursprung: [%d, %d]" % (y, x))
(y,x) = stdscr.getmaxyx()
stdscr.addstr(7, 5, "Fenstergröße: [%d, %d]" % (y, x))
stdscr.addstr(11, 2, "Taste drücken -> Ende")
stdscr.refresh()
stdscr.getch()
curses.endwin()
Es sollte sich in etwa folgende Ausgabe ergeben:
LINES: 44
COLS: 110
Momentane Cursorposition: [4, 15]
Koordinatenursprung: [0, 0]
Fenstergröße: [44, 110]
Taste drücken -> Ende
Zur Funktionsweise von curses siehe auch das Wikibook [[ncurses]]. Zum Verständnis sind dort allerdings elementare Kenntnisse in der Programmiersprache C erforderlich.
== Qt ==
{{Wikipedia | Qt (Bibliothek)}}
Auch für das Qt-Framework gibt es eine Anbindung an Python. Nachfolgend ein einfaches Beispiel.
import sys
from PySide6.QtWidgets import QApplication, QLabel
app = QApplication(sys.argv)
label = QLabel("Hallo Welt!")
label.show()
sys.exit(app.exec())
Ausgabe:
[[Datei:PythonIng_gui10.png]]
== Gtk ==
{{Wikipedia | GTK (Programmbibliothek)}}
Eine idente Ausgabe, wie oben für Qt gezeigt, erzeugt z.B. folgendes Gtk-Programm:
import gi
gi.require_version("Gtk", "4.0")
from gi.repository import Gtk
def on_activate(app):
win = Gtk.ApplicationWindow(application=app)
lab = Gtk.Label(label="Hallo Welt!")
win.set_child(lab)
win.present()
app = Gtk.Application()
app.connect('activate', on_activate)
app.run(None)
Auch für die Benutzung von Qt und Gtk müssen die jeweiligen Packages installiert sein. Getestet wurden die entsprechenden Python-Programme nur unter openSUSE Tumbleweed. Wie das GTK-Paket unter MS Windows 11 installiert wird, siehe z.B. [https://www.gtk.org/docs/installations/windows Setting up GTK for Windows].
Damit sei aber das Thema "Benutzeroberflächen erstellen" hier abgeschlossen, da dies schon ein sehr spezielles Aufgabengebiet ist, das eher Informatiker und nicht so sehr Ingenieure anspricht. Bei Bedarf siehe aber ggf. die entsprechenden Links unten in diesem Tutorial. Dort sind weiterführende Informationen zu finden.
= Pandas kurz erklärt =
Hier wird kurz auf das externe Modul Pandas eingegangen. Pandas steht für '''Pan'''el '''Da'''ta und ist ein Modul für die Datenanalyse und -manipulation.
== Series ==
Vorstellbar ist eine "Series" wie eine einzelne Spalte in einem Tabellenkalkulationsprogramm.
Beispiel (Index implizit vorgegeben):
import pandas as pd
temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5]) # Temperaturwerte
print(temp)
Ausgabe:
0 8.5
1 11.0
2 12.5
3 10.0
4 13.0
5 11.0
6 14.5
dtype: float64
Das Kürzel <code>pd</code> ist Konvention. Es seien Temperaturwerte gegeben. Die erste Spalte bei der Ausgabe ist der Index. Die zweite Spalte enthält die Werte.
Beispiel (separater Zugriff auf den Index und auf die Werte):
import pandas as pd
temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5])
print(temp.index)
print(temp.values)
Ausgabe:
RangeIndex(start=0, stop=7, step=1)
[ 8.5 11. 12.5 10. 13. 11. 14.5]
Beispiel (Index explizit vorgegeben):
import pandas as pd
temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
index=["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"])
print("*** Die gesamte Series ***")
print(temp)
print("*** Temperatur am Donnerstag ***")
print(temp["Do"])
print("*** Tage wärmer als 12 Grad ***")
temp_gr_12 = temp[temp > 12]
print(temp_gr_12)
Ausgabe:
*** Die gesamte Series ***
Mo 8.5
Di 11.0
Mi 12.5
Do 10.0
Fr 13.0
Sa 11.0
So 14.5
dtype: float64
*** Temperatur am Donnerstag ***
10.0
*** Tage wärmer als 12 Grad ***
Mi 12.5
Fr 13.0
So 14.5
dtype: float64
== DataFrame ==
Ein DataFrame entspricht einer Tabelle.
Beispiel (Erzeugen eines DataFrames):
import pandas as pd
tag = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]
stadt = ["Linz", "Salzburg", "Innsbruck"]
v1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
index=tag)
v2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
index=tag)
v3 = pd.Series(["Hallo", 16, 17, 18, 19, 20, 21],
index=tag)
tab = pd.concat([v1, v2, v3], axis=1)
tab.columns = stadt
print(tab)
print(type(tab))
Ausgabe:
Linz Salzburg Innsbruck
Mo 1 8 Hallo
Di 2 9 16
Mi 3 10 17
Do 4 11 18
Fr 5 12 19
Sa 6 13 20
So 7 14 21
<class 'pandas.core.frame.DataFrame'>
Wir haben hier drei Datenspalten (v1, v2, v3) mit den Spaltennamen "Linz", "Salzburg" und "Innsbruck", sowie sieben Zeilen "Mo" bis "So".
Beispiel (Zugriff auf eine Spalte):
import pandas as pd
ind = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]
stadt = ["Linz", "Salzburg", "Innsbruck"]
temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
index=ind)
temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
index=ind)
temp3 = pd.Series(["Hallo", 16, 17, 18, 19, 20, 21],
index=ind)
tab = pd.concat([temp1, temp2, temp3], axis=1)
tab.columns = stadt
print(tab["Salzburg"])
Ausgabe:
Mo 8
Di 9
Mi 10
Do 11
Fr 12
Sa 13
So 14
Name: Salzburg, dtype: int64
Beispiel (Zugriff auf eine Zeile):
import pandas as pd
ind = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]
stadt = ["Linz", "Salzburg", "Innsbruck"]
temp1 = pd.Series([1, 2, 3, 4, 5, 6, 7],
index=ind)
temp2 = pd.Series([8, 9, 10, 11, 12, 13, 14],
index=ind)
temp3 = pd.Series(["Hallo", 16, 17, 18, 19, 20, 21],
index=ind)
tab = pd.concat([temp1, temp2, temp3], axis=1)
tab.columns = stadt
print(tab.loc["Di"])
Ausgabe:
Linz 2
Salzburg 9
Innsbruck 16
Name: Di, dtype: object
== Grafiken erstellen ==
Hier sei nur ein Torten- oder Kreisdiagramm gezeichnet:
import pandas as pd
import matplotlib.pyplot as plt
temp = pd.Series([8.5, 11.0, 12.5, 10.0, 13.0, 11.0, 14.5],
index=["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"])
expl = [0, 0.2, 0, 0, 0, 0, 0]
temp.plot.pie(figsize=(5,5), explode=expl)
plt.show()
Ausgabe:
[[Datei:IngPython_pandas1.svg|350px]]
Die <code>figsize</code> hat nichts mit der Spaltenanzahl zu tun, sondern setzt die Fenster- oder Diagrammgröße in Inches (Breite * Höhe).
Mit Pandas kann man auch noch andere Diagrammarten erstellen, z.B. Linien- oder Balkendiagramme. Dies wird hier aber nicht vorgeführt.
== Arbeiten mit CSV- und LibreOffice-Dateien ==
Gegeben sei eine CSV-Datei test1.csv:
Mai;Juni;Juli
12;17;45
15;65;65
16;32;23
4;14;7
23;17;Keine Daten verfügbar
67;Keine Daten verfügbar;45
15;24;12
Lesen von dieser CSV-Datei:
import pandas as pd
tab = pd.read_csv("test1.csv", sep=";")
print(tab)
Ausgabe:
Mai Juni Juli
0 12 17 45
1 15 65 65
2 16 32 23
3 4 14 7
4 23 17 Keine Daten verfügbar
5 67 Keine Daten verfügbar 45
6 15 24 12
Schreiben in eine CSV-Datei test2.csv:
import pandas as pd
val = pd.read_csv("test1.csv", sep=";")
val.to_csv("test2.csv", index=False)
Ausgabedatei:
Mai,Juni,Juli
12,17,45
15,65,65
16,32,23
4,14,7
23,17,Keine Daten verfügbar
67,Keine Daten verfügbar,45
15,24,12
Die Ausgabedatei ist beinahe gleich wie die Eingabedatei. Es werden aber Kommas statt Strichpunkten verwendet. Daher kommt auch der Name CSV ('''C'''omma '''S'''eparated '''V'''alue). Will man wieder Strichpunkte, so kann man dies über den Parameter <code>sep=";"</code> in der <code>to_csv</code>-Funktion machen.
Um direkt von einer ODS-Datei (LibreOffice Calc, '''O'''pen '''D'''ocument '''S'''preadsheet) zu lesen muss das Modul odfpy extra installiert sein (per YaST, pip etc.). Gelesen wird dann folgendermaßen:
import pandas as pd
df = pd.read_excel('test1.ods', engine='odf')
print(df)
Ausgabe:
Mai Juni Juli
0 12 17 45
1 15 65 65
2 16 32 23
3 4 14 7
4 23 17 Keine Daten verfügbar
5 67 Keine Daten verfügbar 45
6 15 24 12
Die Datei "test1.ods" sei die Datei, aus der das obige "test1.csv" generiert wurde. Schreiben kann man ebenfalls in eine ODS-Datei:
import pandas as pd
daten = {
"Name": ["Hugo", "Richie", "Wilhelmine"],
"Alter": [38, 30, 29],
"Ort": ["Linz", "Innsbruck", "Salzburg"]
}
tab = pd.DataFrame(daten)
with pd.ExcelWriter("test2.ods", engine="odf") as writer:
tab.to_excel(writer, sheet_name="Daten", index=False)
Es ergibt sich eine "test2.ods"-Datei (Screenshot):
[[Datei:IngPython_pandas2.png|250px]]
== Sonstiges ==
Hier seien stichpunktartig einige weitere Features von Pandas angeführt:
* {{W|Pivot-Tabelle|Pivot-Tabellen}} (pivot ... Dreh-, Angelpunkt): Zweck - große Datenmengen schnell zusammenfassen, filtern und analysieren.
* NaN ('''n'''ot '''a''' '''n'''umber): In einem Datensatz fehlt ein Wert oder ist nicht definiert.
* groupby-Funktion: Daten strukturieren, aggregieren oder Zwischensummen bilden.
* {{W|Binning#Datenverarbeitung_und_-analyse|Binning}}: Klassenbildung.
* Mehrstufige Indizierung (Hierarchical Indexing oder MultiIndex).
* Zeitreihen (Time Series).
* MS Excel-Dateien lesen und schreiben mit dem Modul openpyxl.
Für tiefergehende und weiterführende Informationen wird auf das Buch von ''Klein: Numerisches Python; Hanser, 2023'' und [https://pandas.pydata.org/ pandas] verwiesen.
= Style Guide, flake8, pylint, Black etc. =
== Style Guide ==
Wie man schönen und richtigen Python-Code schreibt, erfahren Sie in
* [https://peps.python.org/pep-0008/ PEP 8 – Style Guide for Python Code]
== Formatter und Linter ==
Ein Modul, das prüft, ob die Richtlinien im Style Guide eingehalten wurden, ist ''flake8'':
* [https://flake8.pycqa.org/en/latest/ Flake8: Your Tool For Style Guide Enforcement]
Code formatieren kann man auch mit [https://pypi.org/project/black/ Black]. Z.B. übersetzt <code>black test1.py</code> die Datei <code>test1.py</code>
import sympy as sp
H = sp.Symbol("H", positive=True)
T = sp.Symbol("T", positive=True)
t = sp.Symbol("t")
f = sp.Piecewise(
(H, (t > 0) & (t < T / 2)),
(2 * H / T * (t - T / 2), (t > T / 2) & (t < T))
)
f_series = sp.fourier_series(f, (t, 0, T))
sp.pprint(f_series.truncate(4))
in
import sympy as sp
H = sp.Symbol("H", positive=True)
T = sp.Symbol("T", positive=True)
t = sp.Symbol("t")
f = sp.Piecewise(
(H, (t > 0) & (t < T / 2)), (2 * H / T * (t - T / 2), (t > T / 2) & (t < T))
)
f_series = sp.fourier_series(f, (t, 0, T))
sp.pprint(f_series.truncate(4))
Die Programmausgabe ist
reformatted test1.py
All done! ✨ 🍰 ✨
1 file reformatted.
Der Unterschied zwischen Black und Flake8:
* Black ist ein Code-Formatter. Er formatiert Ihren Code um, sodass er im Einklang mit PEP 8 steht.
* Flake8 ist ein {{W|Lint (Programmierwerkzeug) | Code-Linter}}. Flake8 verändert Ihren Code nicht, sondern durchsucht ihn nach potenziellen Fehlern etc.
Am obigen Beispiel sieht man auch, dass flake8 und Black nicht immer einer Meinung sind. Flake8 (<code>flake8 test1.py</code>) würde standardmäßig den mit Black formatierten Code bemängeln:
test1.py:8:80: E501 line too long (80 > 79 characters)
Diese Diskrepanz kann beseitigt werden. Da 79 Zeichen auf modernen Bildschirmen meist als zu kurz empfunden werden, ist ein Limit von 88 Zeichen (Black-Standard) oder mehr empfehlenswert. Um dies zu implementieren, erstellen Sie in Ihrem Projektverzeichnis eine <code>.flake8</code>-Datei mit dem Inhalt
[flake8]
max-line-length = 88
Und schon ignoriert Flake8 dieses Problem.
Ein anderer Linter ist pylint. Der würde beim Abarbeiten des obigen Beispiels, z.B. mit <code>pylint test1.py</code> noch eine Kleinigkeit bemängeln:
************* Module test1
/home/hr/tmp/test1.py:1:0: C0114: Missing module docstring (missing-module-docstring)
------------------------------------------------------------------
Your code has been rated at 8.57/10 (previous run: 8.57/10, +0.00)
Auch pylint muss vor der ersten Verwendung installiert werden (z.B. mittels pip, virtuelle Umgebung, YaST). Die Dokumentation zu pylint findet sich auf [https://pylint.readthedocs.io/en/latest/].
<u>Aufgabe:</u> Fügen Sie einen "module docstring" in die <code>test1.py</code>-Datei ein und testen Sie erneut mit flake8, Black und pylint. <small>Sehen Sie zum Thema docstrings auch [https://peps.python.org/pep-0257/#what-is-a-docstring PEP 257 – Docstring Conventions].</small>
Es gibt noch weitere Formatierungswerkzeuge für Python-Code. Z.B. [https://docs.astral.sh/ruff/ Ruff], ein moderner Code-Formatter und -Linter. Mittels <code>ruff check test1.py</code> würde obiger Code geprüft (Linter). <code>ruff format test1.py</code> formatiert den Code (Formatter).
== Type Checker ==
"Type Checker" sind z.B.
* mypy
* pyright
* ty
Diese prüfen die Datentypen, z.B. in folgendem Code
def greetings(name: str) -> str:
return "Hello, %s" % name
print(greetings(42))
Python selbst, flake8, ruff oder black würden diesen Code ohne zu murren akzeptieren. "Type Checker" würden aber sehr wohl Alarm schlagen, z.B. liefert <code>mypy</code> folgende Ausgabe
test1.py:5: error: Argument 1 to "greetings" has incompatible type "int"; expected "str" [arg-type]
Found 1 error in 1 file (checked 1 source file)
Das funktioniert übrigens nicht nur bei Funktionsannotationen, sondern auch mit Variablen etc.
from typing import Final
# "Konstante", ab Python 3.8
NUMBER: Final = 123
print(NUMBER)
NUMBER = 125
print(NUMBER)
# Variable
a: int = 345
print(a)
a = "Irgendwas"
print(a)
# Variable (Pipe-Symbol), ab Python 3.10
b : int|str = 567
print(b)
b = "sonstiges"
print(b)
Ausgabe mit python:
123
125
345
Irgendwas
567
sonstiges
Ausgabe mit mypy:
test3.py:6: error: Cannot assign to final name "NUMBER" [misc]
test3.py:12: error: Incompatible types in assignment (expression has type "str", variable has type "int") [assignment]
Found 2 errors in 1 file (checked 1 source file)
Python kennt übrigens keine Konstanten. Man kann diese mittels Großbuchstaben andeuten. Das ist aber nur Konvention, hat aber keine sonstigen Auswirkungen. Oder man verwendet wie oben gezeigt <code>Final</code>. Dann werfen Typchecker Errors aus.
==pydoc==
pydoc ist ein Werkzeug, um Python-Module, -Funktionen und -Klassen zu dokumentieren.
Beispiel <code>test1.py</code>:
"""Rechen-Modul.
Funktionen die von pydoc gelesen werden.
"""
def multiply(a, b):
"""Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
Argumente:
a -- erste Zahl
b -- zweite Zahl
"""
return a * b
def add(a, b):
"""Addiert zwei Zahlen und gibt das Ergebnis zurück.
Argumente:
a -- erste Zahl
b -- zweite Zahl
"""
return a + b
if __name__ == '__main__':
print(multiply(3, 5))
print(add(4, 6))
Ausgabe mit <code>python3.13 -m pydoc test1</code> auf der Konsole:
Help on module test1:
NAME
test1 - Rechen-Modul.
DESCRIPTION
Funktionen die von pydoc gelesen werden.
FUNCTIONS
add(a, b)
Addiert zwei Zahlen und gibt das Ergebnis zurück.
Argumente:
a -- erste Zahl
b -- zweite Zahl
multiply(a, b)
Multipliziert zwei Zahlen und gibt das Ergebnis zurück.
Argumente:
a -- erste Zahl
b -- zweite Zahl
FILE
/home/xyz/tmp/test1.py
Siehe zu diesem Thema z.B. auch [https://docs.python.org/3/library/pydoc.html]. Mittels <code>python3.13 -m pydoc -w test1</code> kann man auch eine HTML-Dokumentation erstellen.
Wofür <code>if __name__ == '__main__':</code> steht, siehe z.B. etwas später im Abschnitt [[Ing_Mathematik:_Python#Doctests]].
== Sonstige Tools ==
Andere Tools für die {{W|Statische Code-Analyse|statische Codeanalyse}}, die aber für Ingenieure weniger interessant sein dürften, sind z.B.
* Radon: Liefert verschiedene {{W|Softwaremetrik|Codemetriken}} (Komplexität, Wartbarkeitsindex ...)
* Bandit: Findet Sicherheitslücken
Tools für die {{W|Dynamisches Software-Testverfahren|dynamische Codeanalyse}}, z.B.:
* DynaPyt (Framework zur dynamischen Programmanalyse)
* cProfile (Profiler)
* Memory Profiler (Speicheranalyse)
* Memray (Speicheranalyse)
* tracemalloc (Speicheranalyse)
Paket- und Projektmanagement (pip-Ersatz etc.):
* uv
* Poetry
* Conda
* pipx
Packaging-Tools (Freezer) und {{W|Compiler#Sonderformen|Transpiler}} :
* pyinstaller
** erstellt eigenständige, ausführbare Binärdatei
** kein Cross-Compiler
** kein Schutz vor Reverse-Engineering
** langsam
** packt alles in eine Datei
** sehr große Datei
** Befehl, z.B.: <code>pyinstaller --onefile test1.py</code>
** GUI: <code>auto-py-to-exe</code>
* cx_Freeze
* nuitka
** Übersetzt Python-Code in C/C++-Code und weiter in eine ausführbare Datei
** kein Cross-Compiler
** Schutz vor Reverse-Engineering
** Befehl, z.B.: <code>nuitka --standalone --onefile test1.py</code>
* cython
= Einige Integrierte Entwicklungsumgebungen (IDEs)=
Werden Programmtexte größer und umfangreicher, so ist das Arbeiten mit der interaktiven Programmierumgebung bzw. das direkte Ausführen von Python-Skripten mühsam. Man wünscht sich z.B. Hilfen zum Debuggen oder die automatische Code-Vervollständigung. Zu diesem Zweck wurden IDEs (Integrated Development Environments) geschaffen. Von diesen seinen nachfolgend auszugsweise einige kurz beschrieben. Testen Sie einfach aus, welche davon für Sie bzw. für Ihr Python-Projekt geeignet sind.
== IDLE ==
IDLE ist die mit dem Python-Programmpaket mitgelieferte IDE. Der Name leitet sich einerseits ab vom Monty-Python-Mitglied Eric Idle, andererseits steht es als Abkürzung für "'''I'''ntegrated '''D'''evelopment and '''L'''earning '''E'''nvironment. IDLE ist einfach zu bedienen, bietet aber schon einen beachtlichen Leistungsumfang. Nachfolgend wird ein Screenshot zu IDLE geliefert. Rechts ist das Editor-Fenster zu sehen, links die interaktive Programmierumgebung. Um das Beispiel selbst nachvollziehen zu können, starten Sie IDLE. Das geht ähnlich, wie Sie die interaktive Programmierumgebung von Python starten (nur, dass Sie eben das IDLE-Icon doppelklicken und nicht das Python-Icon. Unter Linux geben Sie einfach in einem Terminal <code>idle3.13</code> o. Ä. ein). Weiter geht es mit "File - Open - ...". Die auszuführende Datei auswählen (im konkreten Fall ein "Hallo-Welt"-Programm). Es erscheint das rechte Fenster. Dort "Run - Run Module" auswählen. Und schon wird im linken Fenster "Hallo Welt!" ausgegeben.
[[Datei:PythonIng_idle1.jpg | 600px]]
Siehe auch {{W|IDLE}}.
== PyCharm ==
PyCharm ist ein kommerzielles Produkt. Es gab aber auch eine kostenlose Community Edition. Seit 2025 sind beide Varianten vereint. Für die ersten 30 Tage sind die Pro-Funktionen frei verfügbar, danach nur noch die Kernfunktionalitäten (oder man bezieht kostenpflichtig die Pro-Version). Zu beziehen ist PyCharm unter dem Weblink [https://www.jetbrains.com/pycharm/]. Nachfolgend ein etwas abgewandeltes "Hallo Welt"-Programm, editiert und ausgeführt mit PyCharm.
[[Datei:PyCharm_IDE_2023_screenshot.png | 600px]]
Siehe auch {{W|PyCharm}}.
== Eric ==
Auch eric ist Open Source und steht unter der GNU General Public License Version 3 oder später. Zu beziehen ist diese Software unter [https://eric-ide.python-projects.org/].
[[Datei:Screenshot_Eric_4.png | 600px]]
Siehe auch {{W|eric (Software)}}.
<small>
Unter openSUSE Tumbleweed sollte sich eric auch mit YaST installieren lassen. Bei mir gibt es aber dann beim Ausführen des eric-Programms eine Fehlermeldung (Stand März 2026):
...
ModuleNotFoundError: No module named 'PyQt6.QtPdfWidgets'
Umgehen kann man dieses Problem aber wieder mit dem Erstellen einer virtuellen Umgebung, in etwa so
python3.13 -m venv ~/tmp/venv1
cd ~/tmp/venv1/bin
./python3.13 -m pip install --upgrade --prefer-binary eric-ide
./eric7_ide
</small>
== PyScripter ==
Vom Funktionsumfang vergleichbar mit den vorherigen IDEs ist PyScripter. Auch PyScripter ist Open Source. Die Projekt-Homepage findet sich auf [https://sourceforge.net/projects/pyscripter/]. PyScripter ist nur für MS Windows verfügbar.
[[Datei:PythonIng_pyscripter1.jpg | 600px]]
== Spyder IDE ==
Spyder enthält bereits eine stabile Python-Version und etliche Module (z.B. matplotlib, numpy, control). Ansonsten kann dieses Softwarepaket vom Funktionsumfang her mit den anderen genannten IDEs locker mithalten. Spyder wurde unter der MIT-Lizenz veröffentlicht. Diese Software findet sich auf [https://www.spyder-ide.org].
[[Datei:Spyder-windows-screenshot.png | 600px]]
Siehe auch {{W|Spyder (Software)}}
== Eclipse IDE==
Die {{W|Eclipse_(IDE)|Eclipse-IDE}} kann für Python aufgerüstet werden. Dazu gibt es das PyDev-Plugin. Installiert wird es über
* Help > Eclipse Marketplace...
* Find - PyDev - Install
Danach muss noch der Pfad zum Python-Interpreter festgelegt werden
* Window > Preferences > PyDev > Interpreters > Python Interpreter > New ...
Das Ergebnis ist ähnlich wie im folgenden Bild, nur dass statt C/C++ Python Verwendung findet.
[[Datei:Setting Up Eclipse CDT helloout.png | 600px]]
== Sonstige ==
Die genannten IDEs sind nicht die Einzigen. Es gibt, um dem Image Pythons als beliebteste Programmiersprache gerecht zu werden, noch einige andere. Sowohl Open Source-Programme als auch kommerzielle Programme sind im Web zu finden, z.B. Thonny oder {{W|Visual Studio Code}}. Unter Linux kann man auch {{W|KDevelop}}, ausgestattet mit dem Python3-Plugin, einsetzen. Braucht man den Umfang von ausgewachsenen IDEs nicht, so kann man auch normale Texteditoren verwenden (z.B. {{W|Geany}} oder {{W|Kate_(Texteditor)|Kate}}).
= Debuggen und Testen =
Das Debuggen und Testen von Programmen sind wichtige Bestandteile der Programmierung. Syntaxfehler lassen sich i.A. leicht beheben. Schwieriger ist das Eingrenzen von logischen Fehlern, die ev. nur in bestimmten Situationen auftreten und keine explizite Fehlermeldung hervorrufen. Das Programm liefert falsche Ergebnisse oder es stürzt aus heiterem Himmel ab. Um das zu verhindern gibt es verschiedene Werkzeuge, die bei der Fehlersuche behilflich sein können. Vorerst siehe aber zwecks Begriffsklärung noch folgende Links:
* {{W|Debuggen}}
* {{W|Debugger}}
* {{W|Softwaretest}}
<gallery>
First Computer Bug, 1947.jpg
Test ganzheitlich.png
V-Modell.svg
</gallery>
== Das Modul pdb ==
Python bringt schon ein Modul zum Debuggen mit. Siehe z.B. [https://docs.python.org/3/library/pdb.html pdb — The Python Debugger].
Komfortabler lässt sich das aber mittels Integrierter Entwicklungsumgebungen (IDEs) angehen.
== Debuggen mit IDEs ==
Für die IDEs IDLE und Spyder sei kurz auf die entsprechenden Webseiten verwiesen:
* [https://www.cs.uky.edu/~keen/help/debug-tutorial/debug.html Debugging under IDLE].
* [https://docs.spyder-ide.org/current/panes/debugging.html Spyder Debugger]
Dort wird die Vorgehensweise auch mittels Screenshots erläutert.
== assert ==
assert ... behaupten, zusichern ({{W|Assertion (Informatik)}})
Python-Code:
def print1(x, y):
assert type(x) == float
assert type(y) == float
assert y != 0.0
print(x/y)
print1(10., 5.)
print1(10., 0.)
Ausgabe:
2.0
Traceback (most recent call last):
File "/home/hr/Develop/test1.py", line 8, in <module>
print1(10., 0.)
File "/home/hr/Develop/test1.py", line 4, in print1
assert y != 0.0
^^^^^^^^
AssertionError
Python-Code:
def print1(x, y):
assert type(x) == float
assert type(y) == float
assert y != 0.0
print(x/y)
print1(10., 5.)
print1("10.", "5.")
Ausgabe:
2.0
Traceback (most recent call last):
File "/home/hr/Develop/test1.py", line 8, in <module>
print1("10.", "5.")
File "/home/hr/Develop/test1.py", line 2, in print1
assert type(x) == float
^^^^^^^^^^^^^^^^
AssertionError
Aber auch bei nachfolgendem Code gibt es eine Fehlermeldung:
def print1(x, y):
assert type(x) == float
assert type(y) == float
assert y != 0.0
print(x/y)
print1(10., 5.)
print1(10, 5)
Ausgabe:
2.0
Traceback (most recent call last):
File "/home/hr/Develop/test1.py", line 8, in <module>
print1(10, 5)
File "/home/hr/Develop/test1.py", line 2, in print1
assert type(x) == float
^^^^^^^^^^^^^^^^
AssertionError
Damit letzteres funktioniert, kann man den Programmcode so umschreiben:
def print1(x, y):
assert type(x) == float or type(x) == int
assert type(y) == float or type(y) == int
assert y != 0.0
print(x/y)
print1(10., 5.)
print1(10, 5)
Ausgabe:
2.0
2.0
Und jetzt fangen wir den <code>AssertionError</code> auf:
def print1(x, y):
try:
assert type(x) == float or type(x) == int
assert type(y) == float or type(y) == int
assert y != 0.0
print(x/y)
except(AssertionError):
print("Hallo")
print1(10., 5.)
print1("10.", "5.")
Ausgabe:
2.0
Hallo
Ich hoffe, es ist wenigstens im Ansatz klar geworden, wofür <code>assert</code> gut sein kann. Ausschalten kann man die <code>assert</code>-Überprüfung übrigens mit dem Python-Schalter <code>-O</code>.
== Doctests ==
Innerhalb eines Docstrings kann die Arbeit im interaktiven Modus simuliert werden. Nach den Promptzeichen (>>>) erfolgen dann bei unserem Beispiel innerhalb des Docstrings simulierte Aufrufe der Funktion <code>print1()</code>. Danach folgen jeweils die Sollresultate. Wird das Modul oder die Datei als Hauptprogramm aufgerufen, so wird die Funktion <code>doctest.testmode()</code> aufgerufen und ein Bericht auf der Konsole ausgegeben. Wird das Modul nicht als Hauptprogramm aufgerufen, sondern importiert, dann wird diese <code>testmod</code>-Funktion nicht aufgerufen. D.h. dieser Code kann sowohl für Testzwecke als auch für den produktiven Einsatz verwendet werden. Das ist auch sinnvoll, weil wenn man Teile der Datei immer löschen bzw. einfügen müsste, so würden sich Fehlerquellen auftun. Das würde den Sinn und Zweck von Doctests konterkarieren.
def print1(x=0., y=1.):
""" Dividiere zwei Zahlen
Autor: Intruder
Datum: 12.08.2025
>>> print1(2., 1.)
2.0
>>> print1(5., 2.)
2.5
>>> print1(5.)
5.0
"""
print(x/y)
if __name__ == "__main__":
import doctest
doctest.testmod(verbose=True)
Ausgabe:
Trying:
print1(2., 1.)
Expecting:
2.0
ok
Trying:
print1(5., 2)
Expecting:
2.5
ok
Trying:
print1(5.)
Expecting:
5.0
ok
1 items had no tests:
__main__
1 items passed all tests:
3 tests in __main__.print1
3 tests in 2 items.
3 passed and 0 failed.
Test passed.
Das gezeigte Beispiel ist so ziemlich das einfachste, das es gibt. Für weiterführende Details siehe z.B.:
* [https://peps.python.org/pep-0257/ PEP 257 – Docstring Conventions]
* [https://docs.python.org/3/library/doctest.html doctest — Test interactive Python examples]
''Einschub:'' Ganz ähnlich kann man auch Klassen testen, z.B. in folgendem Code-Fragment
class Fahrzeug:
# siehe Abschnitt "Objektorientierte Programmierung"
# ...
if __name__ == "__main__":
vauweh = Fahrzeug(170, 90)
beemweh = Fahrzeug(200, 120)
print(vauweh.convertGeschw())
print(beemweh.convertGeschw())
Wird das Script als Hauptprogramm ausgeführt (z.B. zu Testzwecken), so erfolgt die Ausgabe der zwei, via <code>convertGeschw()</code>, umgerechneten Geschwindigkeiten. Wird es aber als Modul eingebunden, so wird der letzte Programmabschnitt nicht ausgeführt (<code>__name__ == "__main__"</code> ergibt <code>False</code>).
== pytest ==
Siehe zu diesem Thema auch {{W|Modultest}}.
pytest ist ein externes Modul und muss vorab installiert werden, z.B. mittels
pip install -U pytest
pip install -U pytest-html
Python-Code, Datei test1.py:
def add(x, y):
return x + y
def test_answer():
assert add(1, 1) == 3
Starten von pytest in der Konsole:
pytest test1.py
Ausgabe:
==================================================== test session starts ====================================================
platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
rootdir: /home/hr/Develop
plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
collected 1 item
test1.py F [100%]
========================================================= FAILURES ==========================================================
________________________________________________________ test_answer ________________________________________________________
def test_answer():
> assert add(1, 1) == 3
E assert 2 == 3
E + where 2 = add(1, 1)
test1.py:6: AssertionError
================================================== short test summary info ==================================================
FAILED test1.py::test_answer - assert 2 == 3
===================================================== 1 failed in 0.09s =====================================================
Hier erhalten wir einen Fehler, da 1+1 eindeutig ungleich 3 ist. Aber aus irgendeinem Grund wollte der Programmierer oder Tester in diesem Fall, dass dies so ist. Testfälle werden übrigens mit dem Präfix <code>test_</code> eingeleitet.
Python-Code:
def add(x, y):
return x + y + 1
def test_answer():
assert add(1, 1) == 3
Ausgabe:
==================================================== test session starts ====================================================
platform linux -- Python 3.12.11, pytest-8.4.1, pluggy-1.6.0
rootdir: /home/hr/Develop
plugins: anyio-4.10.0, metadata-3.1.1, html-4.1.1
collected 1 item
test1.py . [100%]
===================================================== 1 passed in 0.01s =====================================================
Jetzt ist alles in Ordnung. Weiterführendes siehe z.B.
* [https://docs.pytest.org/en/stable/ pytest: helps you write better programs]
== unittest ==
Auch unittest dient zur Durchführung von Testreihen, ist aber Bestandteil von Python. Hier wird vorerst nicht näher darauf eingegangen. Siehe z.B.
* [https://docs.python.org/3/library/unittest.html unittest — Unit testing framework]
Lt. ''Inden: Python Challenge; dpunkt, 2021, Seite 481'' soll unittest weniger komfortabel als pytest sein.
Einen Vergleich von unittest mit pytest findet man in
* [https://knapsackpro.com/testing_frameworks/difference_between/pytest/vs/unittest pytest vs unittest]
= Python und Anwendungsprogramme =
Bisher stand immer alleine die Programmiersprache Python (ev. unter Einbeziehung von Modulen) im Mittelpunkt der Betrachtungen. Aber Python kann auch als Makrosprache für Anwendungsprogramme auftreten. Als Beispiele seien {{W|FreeCAD}} und {{W|LibreOffice}} genannt.
== FreeCAD ==
FreeCAD ist ein freies 3D-CAD-Programm. Hier soll nicht auf die Bedienung dieses CAD-Pakets eingegangen werden, sondern nur auf die Möglichkeit, mittels Python Makros zu schreiben. Als einfacher Einstieg soll ein Makro erstellt werden, welches eine Kugel (rot) und einen Quader (blau) zeichnet. Folgende Vorbereitungsschritte sind erforderlich (es sei vorausgesetzt, dass FreeCAD schon am Rechner installiert ist. Downloaden können Sie das Programm von der Website [https://www.freecad.org/downloads.php?lang=en]):
* FreeCAD starten
* Leere Datei erstellen
* Makro > Makros > Erstellen ...
Es öffnet sich ein leeres Editorfenster, in das Sie folgenden Code eingeben können:
import FreeCAD
import Part
doc = FreeCAD.newDocument()
# Kugel
kugel = Part.makeSphere(10)
form_element = doc.addObject("Part::Feature", "Kugel")
form_element.Shape = kugel
kug = FreeCAD.ActiveDocument.getObject("Kugel")
kug.ViewObject.ShapeColor = (1.0, 0.0, 0.0)
neuePosition = App.Vector(5, 2.5, 2.5)
kug.Placement = App.Placement(neuePosition, kug.Placement.Rotation)
# Quader
quader = Part.makeBox(5, 5, 50)
form_element = doc.addObject("Part::Feature", "Quader")
form_element.Shape = quader
quad = FreeCAD.ActiveDocument.getObject("Quader")
quad.ViewObject.ShapeColor = (0.0, 0.0, 1.0)
doc.recompute()
Diesen Code können Sie nun ausführen:
* Makro > Makro ausführen
Es ergibt sich folgende Ausgabe (gedreht und gezoomt):
[[Datei: PythonIng_freecad1.png|500px]]
Siehe auch [https://wiki.freecad.org/Python_scripting_tutorial/de# Anleitung Skripterstellung mit Python]. Getestet wurde obiges Beispiel mit FreeCAD 1.1.3 unter Linux und 1.1.1 unter MS Windows.
== LibreOffice ==
LibreOffice ist ein freies Officepaket ([https://de.libreoffice.org/]). Hier soll nur das Tabellenkalkulationsprogramm Calc kurz betrachtet werden. Es seinen in den ersten 3 Zellen (A1 bis A3) Zahlen gegeben. Diese sollen mit einem Python-Makro addiert und das Resultat in der Zelle A5 ausgegeben werden. Auch hier sind Vorbereitungsarbeiten nötig:
* zuerst muss unter Linux das Verzeichnis <code>~/.config/libreoffice/4/user/Scripts/python</code> erstellt werden
* für MS Windows ist es das Verzeichnis <code>%APPDATA%\LibreOffice\4\user\Scripts\python</code>
** drücken Sie zuerst Win + R (es öffnet sich das Ausführen-Fenster)
** geben Sie <code>%appdata%</code> ein, danach drücken Sie Enter (es öffnet sich der Explorer)
** navigieren Sie zu dem genannten Verzeichnis bzw. erstellen Sie das Verzeichnis
* in diesem Verzeichnis wird dann mit einem beliebigen Texteditor das Python-Makro erstellt, in unserem Fall die Datei <code>summiere_zellen.py</code>:
import uno
def summiere_zellen(*args):
# Zugriff auf das aktuelle Dokument und das aktive Tabellenblatt
ctx = uno.getComponentContext()
smgr = ctx.getServiceManager()
desktop = smgr.createInstanceWithContext("com.sun.star.frame.Desktop", ctx)
doc = desktop.getCurrentComponent()
sheet = doc.getCurrentController().getActiveSheet()
# Werte aus den Zellen A1 bis A3 auslesen
w1 = sheet.getCellRangeByName("A1").Value
w2 = sheet.getCellRangeByName("A2").Value
w3 = sheet.getCellRangeByName("A3").Value
# Addition der drei Werte
summe = w1 + w2 + w3
# Ergebnis in die Zelle A5 schreiben
sheet.getCellRangeByName("A5").Value = summe
* siehe dazu ggf. auch [https://help.libreoffice.org/latest/de/text/sbasic/python/python_locations.html?DbPAR=BASIC].
Weiter geht es in LibreOffice Calc mit dem Menü ''Extras > Makros > Makros verwalten > Python''. Dort wird das Makro <code>summiere_zellen</code> ausgeführt. Es ergibt sich z.B. folgendes Resultat
[[Datei:PythonIng_libreoffice1.png]]
Das Kürzel <code>uno</code> steht für '''U'''niversal '''N'''etwork '''O'''bjects. Etwas einfacher geht's auch so:
def summiere_zellen():
desktop = XSCRIPTCONTEXT.getDesktop()
model = desktop.getCurrentComponent()
sheets = model.getSheets()
sheet = sheets.getByIndex(0)
w1 = sheet.getCellRangeByName("A1").Value
w2 = sheet.getCellRangeByName("A2").Value
w3 = sheet.getCellRangeByName("A3").Value
cell = sheet.getCellRangeByName("A5")
cell.setValue(w1 + w2 + w3)
Empfohlen wird auch, das Erweiterungspaket APSO ('''A'''lternative '''P'''ython '''S'''cript '''O'''rganizer, apso.oxt) zu installieren. Die Vorgehensweise wird hier nicht gezeigt, sondern nur darauf hingewiesen, dass man das einfach "googeln" kann. Siehe zur Python-Programmierung für LibreOffice auch [https://wiki.documentfoundation.org/Macros/Python_Guide/de Makros/Python-Handbuch]. Getestet wurden obige Beispiele mit LibreOffice 26.2.5.1 unter Linux und 26.2.1.2 unter MS Windows.
= Ausblick =
Dies war eine kurze Einführung in die Berechnungs- und Darstellungsmöglichkeiten mit Python. Es sollten etliche relevante Themen behandelt, oder zumindest kurz angesprochen worden sein. Wem dieser Text nicht ausreichend ist, der sei auf die entsprechenden weiterführenden Weblinks, Bücher und die Python-Hilfefunktion verwiesen. Python kennt noch viel mehr Befehle, als hier dargestellt wurden. Das Themenspektrum ist auch durch die Einbindung externer Module fast beliebig erweiterbar.
= Weblinks=
== Python allgemein ==
* [https://www.python.org/ Python Homepage]
== Externe mathematische Module ==
* [https://numpy.org/ NumPy]
* [https://numpy.org/doc/stable/user/numpy-for-matlab-users.html NumPy for MATLAB users]
* [https://scipy.org/ SciPy]
* [https://www.sympy.org/en/index.html SymPy]
* [https://pandas.pydata.org/ pandas]
* [https://github.com/maroba/findiff findiff]
* [https://mpmath.org/ mpmath]
== Externe Module für Grafiken ==
* [https://matplotlib.org/ Matplotlib]
* [https://vpython.org/ VPython]
* [https://build123d.readthedocs.io/en/latest/ build123d]
* [https://docs.vtk.org/en/latest/api/python.html VTK]
* [https://docs.bokeh.org/en/latest/docs/first_steps.html bokeh]
* [https://py5coding.org/ py5]
== Erstellung von User Interfaces ==
* [https://docs.python.org/3/library/tkinter.html tkinter - Python interface to Tcl/Tk]
* [https://docs.python.org/3/library/curses.html curses - Terminal handling for character-cell displays]
* [https://wiki.qt.io/Qt_for_Python Qt for Python]
* [https://www.gtk.org/docs/language-bindings/python GTK and Python]
== Erstellen virtueller Umgebungen ==
* [https://docs.python.org/3/library/venv.html venv - Creation of virtual environments]
== Sonstige ==
* [https://python-control.readthedocs.io/en/stable/ Python Control Systems Library]
* [https://pypi.org/project/regex/ regex - Regular Expressions]
* [http://pyromat.org/ PYroMat]
* [https://coolprop.org/coolprop/wrappers/Python/index.html CoolProp]
* [https://pypi.org/project/iapws/ iapws]
* [https://tespy.readthedocs.io/en/main/getting_started/introduction.html TESPy - Thermal Engineering Systems in Python]
* [https://pint.readthedocs.io/en/stable/ pint]
* [https://www.h5py.org/ h5py]
= Bücher =
== Gedruckte Bücher, OpenBooks, Magazine ==
* Diverse: c't Python Lernen, Verstehen, Anwenden; Heise, 2022
* Ernesti, Kaiser: Python3 - das umfassende Handbuch; 5. Aufl., Rheinwerk, [https://openbook.rheinwerk-verlag.de/python/ OpenBook]
* Iacono et al.: Programmieren trainieren; 3. Aufl., Hanser, 2023, ISBN 978-3-446-47766-7
* Inden: Python Challenge; dpunkt, 2021, ISBN 978-3-86490-809-5
* Klein: Numerisches Python; 2. Aufl., Hanser, 2023, ISBN 978-3-446-47170-2
* Steinkamp: Der Python-Kurs für Ingenieure und Naturwissenschaftler; Rheinwerk, 2021, ISBN 978-3-8362-7316-9
* Weigend: Python 3 - Das umfassende Praxisbuch; 9. Aufl., mitp, 2022, ISBN 978-3-7475-0544-1
* Woyand: Python für Ingenieure und Naturwissenschaftler; 4. Aufl., Hanser, 2021, ISBN 978-3-446-46483-4
== Andere Wikibooks ==
* [[:en:Subject:Python_programming_language | Englische Wikibooks zum Thema Python]]
* [[Python|Deutschsprachiges Python-Wikibook]] [[Bild:2von10.png|20%]]
* [[Python unter Linux|Python 2.7 unter Linux]] [[Bild:10von10.png|100%]]
{{Navigation_zurückhochvor_buch|
zurücktext=Julia für Ingenieure|
zurücklink=Ing Mathematik: Julia|
hochtext=Gesamtinhaltsverzeichnis|
hochlink=Ing:_Mathematik_für_Ingenieure|
vortext=Landau-Notation|
vorlink=Ing Mathematik: Landau}}
27or5ochyvpzvxamgywwvx0xpcf6qun
Internet: Basics: Hausanschluss/ CIX
0
123188
1092403
2026-10-23T13:41:34Z
Netzikon
116920
Seite neu erstellt
1092403
wikitext
text/x-wiki
<noinclude><div class="noprint">{{:Internet/ NAV/ Basics}}</div>
<div style="float:right; margin-left:20px; margin-bottom:20px; font-size:0.9em;"> __TOC__ </div>
</noinclude>
Wenn zwei Provider Daten austauschen wollen, haben sie zwei Möglichkeiten. Entweder jeder von ihnen zahlt einen großen Netzbetreiber dafür, die Daten weiterzuleiten. Oder beide treffen sich an einem Ort und verbinden ihre Netze direkt miteinander. Dieser Ort heißt Internet-Knoten, englisch Internet Exchange Point (IXP). Ältere Knoten tragen die Bezeichnung CIX für Commercial Internet Exchange.
;Warum es Internet-Knoten gibt:
Der direkte Austausch hat zwei Vorteile. Er ist billiger, weil kein Dritter dafür bezahlt werden muss. Und er ist schneller, weil die Daten einen kürzeren Weg nehmen. Schreiben Sie eine E-Mail an Ihren Nachbarn, der bei einem anderen Provider ist, dann treffen sich beide Provider an einem solchen Knoten. Ohne ihn liefe die Nachricht möglicherweise über Frankfurt, Amsterdam oder London.
Den direkten Datenaustausch zwischen zwei Netzen nennt man Peering. Kauft ein Provider den Transport seiner Daten stattdessen bei einem größeren Netzbetreiber ein, spricht man von Transit.
;Wie ein Internet-Knoten aufgebaut ist:
Technisch ist ein Internet-Knoten ein großer Switch oder ein Verbund mehrerer Switches. Jeder angeschlossene Netzbetreiber legt ein Glasfaserkabel dorthin und steckt es an einen Port. Über diese eine Verbindung kann er anschließend mit allen anderen Teilnehmern Daten austauschen, sofern sie sich darauf einigen. Der Betreiber des Knotens stellt nur die Technik bereit, über den Datenaustausch entscheiden die Teilnehmer selbst.
Internet-Knoten stehen in Rechenzentren, meist in mehreren über eine Stadt verteilten Gebäuden. Rechenzentren, in denen viele Netzbetreiber zusammentreffen, werden auch Carrier-Hotels genannt.
;Der DE-CIX in Frankfurt:
Der größte deutsche Internet-Knoten ist der DE-CIX in Frankfurt am Main, 1995 gegründet. Mehr als tausend Netze aus aller Welt sind dort angeschlossen. Zu Spitzenzeiten werden mehrere Terabit pro Sekunde übertragen.
Dass ausgerechnet Frankfurt diese Rolle hat, ist der Grund für die hohe Zahl an Rechenzentren im Rhein-Main-Gebiet: Wer nah am Knoten sitzt, hat kurze Wege zu allen anderen Netzen.
Weitere Knoten in Deutschland sind der BCIX in Berlin, der ECIX an mehreren Standorten und der INXS in München. International bekannt sind der AMS-IX in Amsterdam und der LINX in London.
{{clear}}
{{:Internet/ Vorlage/ Links|Internet-Knoten|
* {{w|Internet-Knoten|Internet-Knoten}}
* [https://netzikon.net/lexikon/c/carrier-hotel.html Carrier-Hotel]
* [https://netzikon.net/misc/rechenzentren/ Rechenzentren mit Internetknoten in Deutschland – Standortverzeichnis]
}}
6ur97hghodh2u0ixl9xyq3nbp8s43k6