diff --git a/src/4_Arrays_Linear_Algebra.ipynb b/src/4_Arrays_Linear_Algebra.ipynb
index 924b065667daf25ce0d275d42f579b09eef2d632..8e195a068000ec7b4e186f86e8b83a63b0efc07d 100644
--- a/src/4_Arrays_Linear_Algebra.ipynb
+++ b/src/4_Arrays_Linear_Algebra.ipynb
@@ -9,6 +9,14 @@
"# Arrays, Vectors, Matrices and Linear Algebra"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "2af2061a-6e63-4efd-86f9-8636473f0645",
+ "metadata": {},
+ "source": [
+ "# Arrays, Vektoren, Matrizen und Lineare Algebra"
+ ]
+ },
{
"attachments": {},
"cell_type": "markdown",
@@ -23,6 +31,18 @@
"There are several ways to create a new array; the simplest is to enclose the elements in square brackets (`[ ]`):"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "0e2d205f-2d14-4f9f-ac94-9addc71dd662",
+ "metadata": {},
+ "source": [
+ "## Arrays\n",
+ "\n",
+ "Ein Array ist eine Sequenz von Werten, die jeden beliebigen Typs sein können. Die Werte in einem Array werden Elemente oder manchmal auch Items genannt.\n",
+ "\n",
+ "Es gibt mehrere Möglichkeiten, ein neues Array zu erstellen; die einfachste besteht darin, die Elemente in eckige Klammern (`[ ]`) einzuschließen:\n"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -44,6 +64,14 @@
"The first example is an array of four integers. The second is an array of five strings. The elements of an array don’t have to be the same type. The following array contains a string, a float, an integer, and another array:"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "c60badf7-a824-45ed-9334-ae7cd61e9930",
+ "metadata": {},
+ "source": [
+ "Das erste Beispiel ist ein Array von vier Ganzzahlen. Das zweite ist ein Array von fünf Zeichenketten. Die Elemente eines Arrays müssen nicht denselben Typ haben. Das folgende Array enthält eine Zeichenkette, eine Gleitkommazahl, eine Ganzzahl und ein weiteres Array:"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -64,6 +92,15 @@
"An array that contains no elements is called an empty array; you can create one with empty brackets, `[]`."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "9b2b7f36-e8a4-4d5a-afd8-e0598dca60bc",
+ "metadata": {},
+ "source": [
+ "Ein Array innerhalb eines anderen Arrays ist verschachtelt.\n",
+ "Ein Array, das keine Elemente enthält, wird als leeres Array bezeichnet; Sie können eines mit leeren Klammern, `[]`, erstellen.\n"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -88,6 +125,16 @@
"The syntax for accessing the elements of an array is the bracket operator. The expression inside the brackets specifies the index. Remember that the indices start at 1:"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "f84a7afa-2329-4fae-bdb8-cf84d89d2d1b",
+ "metadata": {},
+ "source": [
+ "Die Art des Arrays wird zwischen geschweiften Klammern angegeben und besteht aus einem Typ und einer Zahl. Die Zahl gibt die Dimensionen an. Das leere Array enthält Werte vom Typ `Any`, d.h. es kann Werte aller Typen aufnehmen.\n",
+ "\n",
+ "Die Syntax zum Zugriff auf die Elemente eines Arrays ist der eckige Klammernoperator. Der Ausdruck innerhalb der Klammern gibt den Index an. Beachten Sie, dass die Indizes bei 1 beginnen:\n"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -107,6 +154,14 @@
"Unlike tuples, arrays are **mutable**. When the bracket operator appears on the left side of an assignment, it identifies the element of the array that will be assigned: "
]
},
+ {
+ "cell_type": "markdown",
+ "id": "d927a90b-f602-4e02-9183-3d96233f0e9d",
+ "metadata": {},
+ "source": [
+ "Im Gegensatz zu Tupeln sind Arrays **veränderlich**. Wenn der eckige Klammernoperator auf der linken Seite einer Zuweisung erscheint, identifiziert er das Element des Arrays, das zugewiesen wird:"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -132,6 +187,19 @@
"The `∈` (or `in`) operator also works on arrays:"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "1f6ef27c-3265-4fb1-95ef-cd782d67c529",
+ "metadata": {},
+ "source": [
+ "Die Regeln für Array-Indizes lauten wie folgt:\n",
+ " - Jeder ganze Ausdruck kann als Index verwendet werden.\n",
+ " - Wenn Sie versuchen, ein Element zu lesen oder zu schreiben, das nicht existiert, erhalten Sie einen `BoundsError`.\n",
+ " - Das Schlüsselwort `end` zeigt auf den letzten Index des Arrays.\n",
+ "\n",
+ "Der Operator `∈` (oder `in`) funktioniert auch bei Arrays:"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -154,6 +222,16 @@
"The most common way to traverse the elements of an array is with a for loop. The syntax is the same as for strings:"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "7b1e1fab-3c3e-405c-b7dd-f03d4a23d200",
+ "metadata": {},
+ "source": [
+ "### Durchlaufen eines Arrays\n",
+ "\n",
+ "Die häufigste Methode, um die Elemente eines Arrays zu durchlaufen, ist mit einer for-Schleife. Die Syntax ist die gleiche wie bei Zeichenketten:"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -175,6 +253,14 @@
"This works well if you only need to read the elements of the array, as you will get only copies of the elements and changing the copies does not change the array. But if you want to write or update the elements, you need the indices. A common way to do that is to use the built-in function `eachindex`:"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "512d919e-cb7a-483c-aa61-0ef08baab3ad",
+ "metadata": {},
+ "source": [
+ "Dies funktioniert gut, wenn Sie nur die Elemente des Arrays lesen müssen, da Sie nur Kopien der Elemente erhalten und das Ändern der Kopien das Array nicht verändert. Wenn Sie jedoch die Elemente schreiben oder aktualisieren möchten, benötigen Sie die Indizes. Eine gängige Methode, dies zu tun, ist die Verwendung der integrierten Funktion `eachindex`:\n"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -196,6 +282,14 @@
"A `for` loop over an empty array never runs the body:"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "f4a5928a-fcc0-4121-b117-fc6a66b7aa78",
+ "metadata": {},
+ "source": [
+ "Eine `for`-Schleife über ein leeres Array führt niemals den Körper aus:"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -218,6 +312,15 @@
"Although an array can contain another array, the nested array still counts as a single element. The length of this array is four:"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "7938c983-b5a4-420c-88b4-c1c9a5c5cc90",
+ "metadata": {},
+ "source": [
+ "`length` gibt die Anzahl der Elemente im Array zurück.\n",
+ "Obwohl ein Array ein anderes Array enthalten kann, zählt das verschachtelte Array immer noch als ein einzelnes Element. Die Länge dieses Arrays beträgt vier:"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -239,6 +342,15 @@
"The slice operator lets you select parts of an array."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "a8557e05-a1f2-4a93-b834-df5b9936bb3c",
+ "metadata": {},
+ "source": [
+ "### Array-Schnitte\n",
+ "Der Slice-Operator ermöglicht es Ihnen, Teile eines Arrays auszuwählen."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -261,6 +373,15 @@
"Since arrays are mutable, it is often useful to make a copy before performing operations that modify arrays."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "406a15ee-6bd8-45eb-a03b-fed62fe7f99a",
+ "metadata": {},
+ "source": [
+ "Der Slice-Operator `[:]` erstellt eine Kopie des gesamten Arrays. Beachten Sie, dass `t2 = t` keine Kopie erstellt. \n",
+ "Da Arrays veränderlich sind, ist es oft nützlich, eine Kopie zu erstellen, bevor Operationen durchgeführt werden, die Arrays verändern."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -284,6 +405,14 @@
"A slice operator on the left side of an assignment can update multiple elements:"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "ba8b2dcc-0f00-42f1-a850-579448a86d8e",
+ "metadata": {},
+ "source": [
+ "Ein Slice-Operator auf der linken Seite einer Zuweisung kann mehrere Elemente aktualisieren:"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -305,6 +434,15 @@
"Julia provides functions that operate on arrays. For example, `push!` adds a new element to the end of an array (note the exclamation mark, as it is impure). `pushfirst!` adds a new element at the beginning of the array."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "1ce6853d-6d8e-4bea-a342-4969c63352d5",
+ "metadata": {},
+ "source": [
+ "### Array-Bibliothek\n",
+ "Julia stellt Funktionen bereit, die auf Arrays wirken. Zum Beispiel fügt `push!` ein neues Element am Ende eines Arrays hinzu (beachten Sie das Ausrufezeichen, da es veränderlich ist). `pushfirst!` fügt ein neues Element am Anfang des Arrays hinzu."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -327,6 +465,14 @@
"`append!` add the elements of the second array to the end of the first:"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "4770945a-ff8e-4c60-82a2-0b545f569f47",
+ "metadata": {},
+ "source": [
+ "`append!` fügt die Elemente des zweiten Arrays am Ende des ersten hinzu:"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -349,6 +495,14 @@
"The function `insert!` inserts an element at a given index:"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "769aee98-5aeb-402b-81d7-23d81d596966",
+ "metadata": {},
+ "source": [
+ "Die Funktion `insert!` fügt ein Element an einem bestimmten Index ein:"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -369,6 +523,14 @@
"`sort!` arranges the elements of the array from low to high, while `sort` returns a copy of the elements of the array in order: "
]
},
+ {
+ "cell_type": "markdown",
+ "id": "2e5a4efd-a107-4129-b3ee-de9af8ce0284",
+ "metadata": {},
+ "source": [
+ "`sort!` ordnet die Elemente des Arrays von niedrig nach hoch, während `sort` eine Kopie der Elemente des Arrays in sortierter Reihenfolge zurückgibt:"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -396,6 +558,14 @@
"There are several ways to delete elements from an array. If you know the index of the element you want to delete, you can use `splice!`. `splice!` modifies the array and returns the element that was removed. `deleteat!` does the same without returning the element."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "c3e790e9-fa20-41d1-b43b-67ba30f89229",
+ "metadata": {},
+ "source": [
+ "Es gibt mehrere Möglichkeiten, Elemente aus einem Array zu löschen. Wenn Sie den Index des zu löschenden Elements kennen, können Sie `splice!` verwenden. `splice!` ändert das Array und gibt das entfernte Element zurück. `deleteat!` tut dasselbe, gibt jedoch das Element nicht zurück."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -418,6 +588,14 @@
"`pop!` deletes and returns the last element:"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "b74c89cd-8d90-459f-a403-5276474736ee",
+ "metadata": {},
+ "source": [
+ "`pop!` löscht das letzte Element und gibt es zurück:"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -441,6 +619,15 @@
" - The core functionality provides several other functions which act on an array. Given an array `x` try the following functions and try to guess what they do: `ndims(x)`, `eltype(x)`, `length(x)`, `size(x)`, `size(x, 1)`, `reshape(x, 3, 3)`."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "4c08249e-8340-424a-8ce2-4469df29e8ed",
+ "metadata": {},
+ "source": [
+ "### Übung\n",
+ " - Die Kernfunktionalität bietet mehrere andere Funktionen, die auf ein Array wirken. Versuchen Sie die folgenden Funktionen mit einem Array `x` und versuchen Sie zu erraten, was sie tun: `ndims(x)`, `eltype(x)`, `length(x)`, `size(x)`, `size(x, 1)`, `reshape(x, 3, 3)`."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -462,6 +649,15 @@
"For every binary operator like `^`, there is a corresponding dot operator .^ that is automatically defined to perform ^ element-by-element on arrays. For example, `[1, 2, 3]^3` is not defined, but `[1, 2, 3].^3` is defined as computing the elementwise result `[1^3, 2^3, 3^3]`:"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "cc1d4b7f-5639-4638-aea3-52e2d52f8fd4",
+ "metadata": {},
+ "source": [
+ "### Punkt-Syntax\n",
+ "Für jeden binären Operator wie `^` gibt es einen entsprechenden Punktoperator `.^`, der automatisch definiert ist, um ^ elementweise auf Arrays anzuwenden. Zum Beispiel ist `[1, 2, 3]^3` nicht definiert, aber `[1, 2, 3].^3` ist definiert und berechnet das ergebnis für jedes Element `[1^3, 2^3, 3^3]`:"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -481,6 +677,14 @@
"Any Julia function `f` can be applied elementwise to any array with the dot syntax. For example to capitalize an array of strings, we don’t need an explicit loop:"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "7a18830c-f3cd-469d-a0b9-f206ee7aec7b",
+ "metadata": {},
+ "source": [
+ "Jede Julia-Funktion `f` kann mit der Punkt-Syntax elementweise auf jedes Array angewendet werden. Zum Beispiel, um ein Array von Zeichenketten zu großzügig machen, benötigen wir keine explizite Schleife:"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -503,6 +707,16 @@
"A string is a sequence of characters and an array is a sequence of values, but an array of characters is not the same as a string. To convert from a string to an array of characters, you can use the function `collect`:"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "073001cf-0661-4827-b693-a08ca06967b7",
+ "metadata": {},
+ "source": [
+ "### Arrays und Zeichenketten\n",
+ "\n",
+ "Eine Zeichenkette ist eine Sequenz von Zeichen und ein Array ist eine Sequenz von Werten, aber ein Array von Zeichen ist nicht dasselbe wie eine Zeichenkette. Um von einer Zeichenkette zu einem Array von Zeichen zu konvertieren, können Sie die Funktion `collect` verwenden:"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -522,6 +736,14 @@
"If you want to break a string into words, you can use the `split` function. The default delimiter is the space, but you can pass a custom delimiter as a second argument."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "72c17230-0d1b-46ba-9711-1eb3328839c5",
+ "metadata": {},
+ "source": [
+ "Wenn Sie eine Zeichenkette in Wörter zerlegen möchten, können Sie die Funktion `split` verwenden. Das Standardtrennzeichen ist das Leerzeichen, aber Sie können ein benutzerdefiniertes Trennzeichen als zweites Argument übergeben."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -542,6 +764,14 @@
"Finally, `join` is the inverse of split. It takes an array of strings and concatenates the elements:"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "51981f83-608f-4c41-9321-13de5facb204",
+ "metadata": {},
+ "source": [
+ "Finally, `join` is the inverse of split. It takes an array of strings and concatenates the elements:"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -565,6 +795,15 @@
" - Write a function called `reverse_array(x)` which takes as input an array and returns a **new** array with the elements in reverse order."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "acf522cd-0297-4f5c-873a-3309ce68b9d8",
+ "metadata": {},
+ "source": [
+ "### Übungen\n",
+ " - Schreiben Sie eine Funktion namens `reverse_array(x)`, die als Eingabe ein Array nimmt und ein **neues** Array mit den Elementen in umgekehrter Reihenfolge zurückgibt."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -584,6 +823,14 @@
" - Write a function called `reverse_array!(x)` which modifies in place the array by reversing its elements."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "927e6892-cc03-452f-bd65-ec895cae47ff",
+ "metadata": {},
+ "source": [
+ " - Schreiben Sie eine Funktion namens `reverse_array!(x)`, die das Array vor Ort ändert, indem sie seine Elemente umkehrt."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -603,6 +850,14 @@
" - Write a function `even_numbers(x)` which takes as input an array of integers and returns a new array containing only the elements which are even."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "b0311dcb-964b-457c-b041-789673f732ca",
+ "metadata": {},
+ "source": [
+ " - Schreiben Sie eine Funktion namens `even_numbers(x)`, die als Eingabe ein Array von Ganzzahlen nimmt und ein neues Array zurückgibt, das nur die geraden Elemente enthält."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -616,19 +871,22 @@
{
"attachments": {},
"cell_type": "markdown",
- "id": "756cd401-77f2-4b90-9a87-10b4fcc6c7a7",
+ "id": "8eb3354b-49b7-46df-9246-29dd520b92af",
"metadata": {},
"source": [
- "## Vectors and Matrices"
+ "## Vectors and Matrices\n",
+ "\n",
+ "In general arrays can have any number of dimensions, with this line we are instantiating a 2x3x4 array made of integer zeros."
]
},
{
- "attachments": {},
"cell_type": "markdown",
- "id": "1c5d8a88-f00e-41a9-ac62-245a25d8c803",
+ "id": "d4b62fae-5d5d-46ac-94d8-b99b9f8aeb13",
"metadata": {},
"source": [
- "In general arrays can have any number of dimensions, with this line we are instantiating a 2x3x4 array made of integer zeros."
+ "## Vektoren und Matrizen\n",
+ "\n",
+ "Im Allgemeinen können Arrays beliebig viele Dimensionen haben. Mit dieser Zeile instantiieren wir ein 2x3x4-Array aus ganzen Nullen."
]
},
{
@@ -651,6 +909,14 @@
"However, if the dimension of the array is 1 or 2 the type is respectively `Vector` or `Matrix`."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "d806b78a-e97f-47b1-9ecb-409bf5a2c1c2",
+ "metadata": {},
+ "source": [
+ "Wenn jedoch die Dimension des Arrays 1 oder 2 ist, ist der Typ entsprechend `Vector` oder `Matrix`."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -673,6 +939,14 @@
" **Note:** instantiating a matrix does not require the commas between the elements. The following like will produce a 1x3 matrix and not a vector."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "3e29c3ab-1fdb-4e74-b4fc-ca77690a33f1",
+ "metadata": {},
+ "source": [
+ "**Hinweis:** Zur Instantiierung einer Matrix sind keine Kommas zwischen den Elementen erforderlich. Die folgende Zeile wird eine 1x3-Matrix und nicht einen Vektor erzeugen."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -693,6 +967,14 @@
"You can also explicitly check that a Vector is simply a 1d Array and that a Matrix is simply a 2d array."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "62dfd73b-dd75-4dcc-970d-02c9881627bf",
+ "metadata": {},
+ "source": [
+ "Sie können auch explizit überprüfen, dass ein Vektor einfach ein eindimensionales Array ist und dass eine Matrix einfach ein zweidimensionales Array ist."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -714,6 +996,14 @@
"**Note:** `Array` and `Vector` are always concrete types, independently from the type of the elements. So the usual type relations don't give the expected results:"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "a2957207-e7b7-43d4-9015-c2649bcc4183",
+ "metadata": {},
+ "source": [
+ "**Hinweis:** `Array` und `Vector` sind immer konkrete Typen, unabhängig von der Art der Elemente. Daher geben die üblichen Typbeziehungen nicht die erwarteten Ergebnisse:"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -728,19 +1018,22 @@
{
"attachments": {},
"cell_type": "markdown",
- "id": "1205c3f4-2e97-4952-86f2-bc8e44d638f7",
+ "id": "b9b86c55-2754-489e-87c6-851a3807d41d",
"metadata": {},
"source": [
- "### Vectors"
+ "### Vectors\n",
+ "\n",
+ "Vectors can be created using square brakets `[]` or by using the `Vector` construct. The data type can be explicitly stated."
]
},
{
- "attachments": {},
"cell_type": "markdown",
- "id": "a6a69a05-dfa3-42f9-a011-579478a8a9c1",
+ "id": "a101372e-20c1-4ff6-87c7-99ac21ac9f88",
"metadata": {},
"source": [
- "Vectors can be created using square brakets `[]` or by using the `Vector` construct. The data type can be explicitly stated."
+ "### Vektoren\n",
+ "\n",
+ "Vektoren können mit eckigen Klammern `[]` erstellt werden oder durch Verwendung des `Vector`-Konstrukts. Der Datentyp kann explizit angegeben werden."
]
},
{
@@ -765,6 +1058,14 @@
"There are other short ways to generate arrays with usual content, like zeros, ones or random numbers."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "a312114c-525c-42e5-8676-40e382a789c0",
+ "metadata": {},
+ "source": [
+ "Es gibt auch andere schnelle Möglichkeiten, Arrays mit üblichen Inhalten wie Nullen, Einsen oder Zufallszahlen zu erzeugen."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -787,6 +1088,14 @@
"It is also possible to enforce a specific data type."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "59c0734e-99e9-4450-a9e1-e970233d5b44",
+ "metadata": {},
+ "source": [
+ "Es ist auch möglich, einen bestimmten Datentyp zu erzwingen."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -809,6 +1118,14 @@
"Standard mathematical operation can be performed with the usual notation."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "28a32ca8-3eb2-4113-a293-822e95f96b81",
+ "metadata": {},
+ "source": [
+ "Standardmäßige mathematische Operationen können mit der üblichen Notation durchgeführt werden."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -832,6 +1149,14 @@
"The scalar product can be computed using the `dot` function, which is part of the `LinearAlgebra` package."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "43b66537-bb2c-487f-8144-d3774f6d8cdf",
+ "metadata": {},
+ "source": [
+ "Das Skalarprodukt kann mit der `dot`-Funktion berechnet werden, die Teil des `LinearAlgebra`-Pakets ist."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -853,6 +1178,14 @@
"Finally, the transpose can be accessed using the `'` operator."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "15727030-afce-436e-98ec-e1703b793f2c",
+ "metadata": {},
+ "source": [
+ "Schließlich kann die Transponierte mit dem `'`-Operator abgerufen werden."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -867,19 +1200,22 @@
{
"attachments": {},
"cell_type": "markdown",
- "id": "3aad0875-2339-47f6-ae1f-bd5ca455bec2",
+ "id": "027dced2-896d-4070-93e3-1a175c537dc4",
"metadata": {},
"source": [
- "### Matrices"
+ "### Matrices\n",
+ "\n",
+ "Matrices can be again initialized in various ways."
]
},
{
- "attachments": {},
"cell_type": "markdown",
- "id": "243b7d80-11c6-4b2f-af93-0e4f5a56deee",
+ "id": "8996d0f1-a663-4489-8cde-d81110e093b5",
"metadata": {},
"source": [
- "Matrices can be again initialized in various ways."
+ "### Matrizen\n",
+ "\n",
+ "Matrizen können wieder auf verschiedene Arten initialisiert werden."
]
},
{
@@ -905,6 +1241,14 @@
"If you have the diagonal (vector) and you want to construct a diagonal matrix, you can use the `diagm` function."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "7339ad4b-fe9b-4161-9eeb-2bad5df510c0",
+ "metadata": {},
+ "source": [
+ "Wenn Sie die Diagonale (als Vektor) haben und eine Diagonalmatrix konstruieren möchten, können Sie die Funktion `diagm` verwenden."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -924,6 +1268,14 @@
"The identity matrix is represented as a `I`. **Note**: this is not really a matrix, but rather a `UniformScaling` which brings the effect of the identity operation without needing allocated space. The uniform scalings automatically adapt to the size of the matrices they act on."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "e591d680-3ba9-43a6-a014-5799dfcc1959",
+ "metadata": {},
+ "source": [
+ "Die Einheitsmatrix wird als `I` dargestellt. **Hinweis**: Dies ist eigentlich keine Matrix, sondern eher eine `UniformScaling`, die die Wirkung der Identitätsoperation ohne die Notwendigkeit von alloziertem Speicher bringt. Die einheitlichen Skalierungen passen sich automatisch an die Größe der Matrizen an, auf die sie wirken."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -944,6 +1296,14 @@
"Again the `+` and `-` operations can be readily used on matrices, but in this case also the `*` operation is defined."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "77643776-b23a-4b2e-b6ee-b84304541d9a",
+ "metadata": {},
+ "source": [
+ "Auch die Operationen `+` und `-` können problemlos auf Matrizen angewendet werden, aber in diesem Fall ist auch die Operation `*` definiert."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -965,6 +1325,14 @@
"To invert the matrices it is possible to use the function `inv` or a more subtle `/` operation."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "03daee60-cf26-4d80-87a4-18ddebedb8b7",
+ "metadata": {},
+ "source": [
+ "Um die Matrizen zu invertieren, können Sie die Funktion `inv` oder die subtilere Operation `/` verwenden."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -986,6 +1354,14 @@
"The transpose works also on matrices, and note that for complex numbers it is an adjoint."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "11e3d462-b24f-4099-9590-3ae27af92985",
+ "metadata": {},
+ "source": [
+ "Die Transponierte funktioniert auch bei Matrizen, und beachten Sie, dass bei komplexen Zahlen eine Adjunkte vorliegt."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -1007,6 +1383,14 @@
"Finally, it is also possible to compute the determinant and the trace using respectively the `det` and `tr` functions."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "a9429302-aeb6-4207-880d-d87ebf87974e",
+ "metadata": {},
+ "source": [
+ "Schließlich ist es auch möglich, den Determinanten und die Spur mithilfe der Funktionen `det` bzw. `tr` zu berechnen."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -1030,6 +1414,16 @@
"The `LinearAlgebra` package implement various more advanced operations."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "8c1cc9db-da30-4ffd-828c-3fdc1611e113",
+ "metadata": {},
+ "source": [
+ "## Weiterführende Lineare Algebra\n",
+ "\n",
+ "Das Paket `LinearAlgebra` implementiert verschiedene fortgeschrittenere Operationen."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -1049,6 +1443,14 @@
" - Eigenvalue decomposition"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "026f77af-fb87-4d41-88e3-a5f27f2e7305",
+ "metadata": {},
+ "source": [
+ " - Eigenwertzerlegung"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -1069,6 +1471,14 @@
" - Singular value decomposition"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "e9ef9a44-6305-4549-b93e-10b77d2dcd0c",
+ "metadata": {},
+ "source": [
+ " - Singulärwertzerlegung"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -1089,6 +1499,14 @@
" - LU decomposition"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "039a8cfb-0b4f-42e2-ab13-be9cda23fe0f",
+ "metadata": {},
+ "source": [
+ " - LU-Zerlegung"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -1112,6 +1530,14 @@
" - Cholesky (needs a Hermitian matrix)"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "b90bc471-03a2-4257-8f91-aafcf70f9bfb",
+ "metadata": {},
+ "source": [
+ " - Cholesky-Zerlegung (erfordert eine hermitesche Matrix)"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -1134,23 +1560,35 @@
]
},
{
- "attachments": {},
"cell_type": "markdown",
- "id": "dae5385d-add4-47c2-9f7b-d8787942c22c",
+ "id": "585d7aa3-5ba4-4ea1-8874-95566bcd5de8",
"metadata": {},
"source": [
- "## Exercises"
+ "Für weitere Informationen:\n",
+ "[https://docs.julialang.org/en/v1/stdlib/LinearAlgebra/](https://docs.julialang.org/en/v1/stdlib/LinearAlgebra/)"
]
},
{
"attachments": {},
"cell_type": "markdown",
- "id": "f5332b7c-c974-4949-a395-7219fcfc049f",
+ "id": "bc8a12d1-a6af-4cd0-8f22-832d8b5eee92",
"metadata": {},
"source": [
+ "## Exercises\n",
+ "\n",
" - Write a function that computes the square root of a matrix."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "9d9422fe-980b-417c-a33a-aea5050e9d3a",
+ "metadata": {},
+ "source": [
+ "## Übungen\n",
+ "\n",
+ " - Schreiben Sie eine Funktion, die die Quadratwurzel einer Matrix berechnet.\n"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -1170,6 +1608,14 @@
" - Implement a solver for linear systems that uses the [Jacobi method](https://en.wikipedia.org/wiki/Jacobi_method). Then compare the result with the standard solution using matrix inversion."
]
},
+ {
+ "cell_type": "markdown",
+ "id": "4b1c5ca6-06c7-458f-ad36-1fbf2b8da387",
+ "metadata": {},
+ "source": [
+ " - Implementieren Sie einen Solver für lineare Systeme, der die [Jacobi-Methode](https://de.wikipedia.org/wiki/Jacobi-Verfahren) verwendet. Vergleichen Sie dann das Ergebnis mit der Standardlösung unter Verwendung der Matrixinversion."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,