hellmund/JuliaKurs23
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity

english translation started

Browse Source
This commit is contained in:
Meik Hellmund
2026-02-22 18:22:46 +01:00
parent 19c67a3c9b
commit 9e418381ca
17 changed files with 1915 additions and 1907 deletions
Download Patch File Download Diff File Expand all files Collapse all files

270
chapters/9_functs.qmd
View File

@@ -2,7 +2,7 @@
engine: julia
---
# Funktionen und Operatoren
# Functions and Operators
```{julia}
#| error: false
@@ -18,36 +18,36 @@ Base.active_module() = myactive_module()
```
Funktionen verarbeiten ihre Argumente zu einem Ergebnis, das sie beim Aufruf zurückliefern.
Functions process their arguments to produce a result, which they return when called.
## Formen
## Forms
Funktionen können in verschiedenen Formen definiert werden:
Functions can be defined in different forms:
I. Als `function ... end`-Block
I. As a `function ... end` block
```{julia}
function hyp(x,y)
sqrt(x^2+y^2)
end
```
II. Als "Einzeiler"
II. As a "single-liner"
```{julia}
hyp(x, y) = sqrt(x^2 + y^2)
```
III. Als anonyme Funktionen
III. As anonymous functions
```{julia}
(x, y) -> sqrt(x^2 + y^2)
```
### Block-Form und `return`
### Block Form and `return`
- Mit `return` wird die Abarbeitung der Funktion beendet und zum aufrufenden Kontext zurückgekehrt.
- Ohne `return` wird der Wert des letzten Ausdrucks als Funktionswert zurückgegeben.
- With `return`, function execution is terminated and control returns to the calling context.
- Without `return`, the value of the last expression is returned as the function value.
Die beiden Definitionen
The two definitions
```julia
function xsinrecipx(x)
@@ -57,7 +57,7 @@ function xsinrecipx(x)
return x * sin(1/x)
end
```
und ohne das zweite explizite `return` in der letzten Zeile:
and without the second explicit `return` in the last line:
```julia
function xsinrecipx(x)
@@ -68,11 +68,11 @@ function xsinrecipx(x)
end
```
sind also äquivalent.
are therefore equivalent.
- Eine Funktion, die "nichts" zurückgibt (_void functions_ in der C-Welt), gibt den Wert `nothing` vom Typ `Nothing` zurück. (So wie ein Objekt vom Typ `Bool` die beiden Werte `true` und `false` haben kann, so kann ein Objekt vom Typ `Nothing` nur einen einzigen Wert, eben `nothing`, annehmen.)
- Eine leere `return`-Anweisung ist äquivalent zu `return nothing`.
- A function that returns "nothing" (_void functions_ in the C world) returns the value `nothing` of type `Nothing`. (Just as an object of type `Bool` can have two values, `true` and `false`, an object of type `Nothing` can only take a single value, namely `nothing`.)
- An empty `return` statement is equivalent to `return nothing`.
```{julia}
@@ -95,27 +95,27 @@ a
```
### Einzeiler-Form
### Single-liner Form
Die Einzeilerform ist eine ganz normale Zuweisung, bei der links eine Funktion steht.
The single-liner form is a normal assignment where a function stands on the left side.
```julia
hyp(x, y) = sqrt(x^2 + y^2)
```
Julia kennt zwei Möglichkeiten, mehrere Anweisungen zu einem Block zusammenzufassen, der an Stelle einer Einzelanweisung stehen kann:
Julia knows two ways to combine multiple statements into a block that can stand in place of a single statement:
- `begin ... end`-Block
- Eingeklammerte durch Semikolon getrennte Anweisungen.
- `begin ... end` block
- Parenthesized statements separated by semicolons.
In beiden Fällen ist der Wert des Blockes der Wert der letzten Anweisung.
In both cases, the value of the block is the value of the last statement.
Damit funktioniert auch
Thus, the following also works:
```julia
hyp(x, y) = (z = x^2; z += y^2; sqrt(z))
```
und
and
```julia
hyp(x, y) = begin
z = x^2
@@ -124,15 +124,15 @@ hyp(x, y) = begin
end
```
### Anonyme Funktionen
### Anonymous Functions
Anonyme FUnktionen kann man der Anonymität entreisen, indem man ihnen einen Namen zuweist.
Anonymous functions can be "rescued from anonymity" by assigning them a name.
```julia
hyp = (x,y) -> sqrt(x^2 + y^2)
```
Ihre eigentliche Anwendung ist aber im Aufruf einer *(higher order)* Funktion, die eine Funktion als Argument erwartet.
Their actual application is in calling a *(higher order)* function that expects a function as an argument.
Typische Anwendungen sind `map(f, collection)`, welches eine Funktion auf alle Elemente einer Kollektion anwendet. In Julia funktioniert auch `map(f(x,y), collection1, collection2)`:
Typical applications are `map(f, collection)`, which applies a function to all elements of a collection. In Julia, `map(f(x,y), collection1, collection2)` also works:
```{julia}
map( (x,y) -> sqrt(x^2 + y^2), [3, 5, 8], [4, 12, 15])
@@ -142,24 +142,24 @@ map( (x,y) -> sqrt(x^2 + y^2), [3, 5, 8], [4, 12, 15])
map( x->3x^3, 1:8 )
```
Ein weiteres Beispiel ist `filter(test, collection)`, wobei ein Test eine Funktion ist, die ein `Bool` zurückgibt.
Another example is `filter(test, collection)`, where a test is a function that returns a `Bool`.
```{julia}
filter(x -> ( x%3 == 0 && x%5 == 0), 1:100 )
```
## Argumentübergabe
## Argument Passing
- Beim Funktionsaufruf werden von den als Funktionsargumente zu übergebenden Objekten keine Kopien gemacht. Die Variablen in der Funktion verweisen auf die Originalobjekte. Julia nennt dieses Konzept _pass_by_sharing_.
- Funktionen können also ihre Argumente wirksam modifizieren, falls es sich um _mutable_ Objekte, wie z.B. `Vector`, `Array` handelt.
- Es ist eine Konvention in Julia, dass die Namen von solchen argumentmodifizierenden Funktionen mit einem Ausrufungszeichen enden. Weiterhin steht dann üblicherweise das Argument, das modifiziert wird, an erster Stelle und es ist auch der Rückgabewert der Funktion.
- When calling a function, no copies are made of the objects passed as function arguments. Variables in the function refer to the original objects. Julia calls this concept _pass_by_sharing_.
- Functions can therefore effectively modify their arguments if they are _mutable_ objects, such as `Vector` or `Array`.
- It is a convention in Julia that the names of such argument-modifying functions end with an exclamation mark. Furthermore, the argument that is modified is usually first and is also the return value of the function.
```{julia}
V = [1, 2, 3]
W = fill!(V, 17)
# '===' ist Test auf Identität
@show V W V===W; # V und W benennen dasselbe Objekt
# '===' is test for identity
@show V W V===W; # V and W refer to the same object
```
```{julia}
@@ -175,16 +175,16 @@ U = fill_first!(V, 42)
## Varianten von Funktionsargumenten
## Variants of Function Arguments
- Es gibt Positionsargumente (1. Argument, 2. Argument, ....) und _keyword_-Argumente, die beim Aufruf durch ihren Namen angesprochen werden müssen.
- Sowohl Positions- als auch _keyword_-Argumente können _default_-Werte haben. Beim Aufruf können diese Argumente weggelassen werden.
- Die Reihenfolge der Deklaration muss sein:
1. Positionsargumente ohne Defaultwert,
2. Positionsargumente mit Defaultwert,
3. --- Semikolon ---,
4. kommagetrennte Liste der Keywordargumente (mit oder ohne Defaultwert)
- Beim Aufruf können _keyword_-Argumente an beliebigen Stellen in beliebiger Reihenfolge stehen. Man kann sie wieder durch ein Semikolon von den Positionsargumenten abtrennen, muss aber nicht.
- There are positional arguments (1st argument, 2nd argument, ...) and _keyword_ arguments, which must be addressed by name when calling.
- Both positional and _keyword_ arguments can have _default_ values. These arguments can be omitted when calling.
- The order of declaration must be:
1. Positional arguments without default value,
2. Positional arguments with default value,
3. --- semicolon ---,
4. comma-separated list of keyword arguments (with or without default value)
- When calling, _keyword_ arguments can appear at any position in any order. You can separate them from positional arguments with a semicolon, but you don't have to.
```{julia}
fa(x, y=42; a) = println("x=$x, y=$y, a=$a")
@@ -194,7 +194,7 @@ fa(6, 7; a=4)
fa(a=-2, 6)
```
Eine Funktion nur mit _keyword_-Argumenten wird so deklariert:
A function with only _keyword_ arguments is declared as follows:
```{julia}
fkw(; x=10, y) = println("x=$x, y=$y")
@@ -204,9 +204,9 @@ fkw(y=2)
## Funktionen sind ganz normale Objekte
## Functions are Normal Objects
- Sie können zugewiesen werden
- They can be assigned
```{julia}
@@ -215,11 +215,11 @@ f2(2)
```
- Sie können als Argumente an Funktionen übergeben werden.
- They can be passed as arguments to functions.
```{julia}
# sehr naive numerische Integration
# very naive numerical integration
function Riemann_integrate(f, a, b; NInter=1000)
delta = (b-a)/NInter
@@ -235,7 +235,7 @@ Riemann_integrate(sin, 0, π)
```
- Sie können von Funktionen erzeugt und als Ergebnis `return`t werden.
- They can be created by functions and returned as results.
@@ -263,16 +263,16 @@ h(1)
h(2), h(10)
```
Die obige Funktion `generate_add_func()` lässt sich auch kürzer definieren. Der innere Funktionsname `addx()` ist sowieso lokal und außerhalb nicht verfügbar. Also kann man eine anonyme Funktion verwenden.
The above function `generate_add_func()` can also be defined more briefly. The inner function name `addx()` is anyway local and not available outside. So one can use an anonymous function.
```{julia}
generate_add_func(x) = y -> x + y
```
## Zusammensetzung von Funktionen: die Operatoren $\circ$ und `|>`
## Function Composition: the Operators $\circ$ and `|>`
- Die Zusammensetzung _(composition)_ von Funktionen kann auch mit dem Operator $\circ$ (`\circ + Tab`) geschrieben werden
- Function composition can also be written with the $\circ$ operator (`\circ + Tab`)
$$(f\circ g)(x) = f(g(x))$$
@@ -289,11 +289,11 @@ f(.2)
```{julia}
@show map(uppercase ∘ first, ["ein", "paar", "grüne", "Blätter"]);
@show map(uppercase ∘ first, ["one", "a", "green", "leaves"]);
```
- Es gibt auch einen Operator, mit dem Funktionen "von rechts" wirken und zusammengesetzt werden können _(piping)_
- There is also an operator with which functions can act "from the right" and be composed (_piping_)
```{julia}
@@ -306,37 +306,37 @@ f(.2)
```
- Natürlich kann man auch diese Operatoren 'broadcasten' (s. @sec-broadcast). Hier wirkt ein Vektor von Funktionen elementweise auf einen Vektor von Argumenten:
- Of course, you can also 'broadcast' these operators (see @sec-broadcast). Here a vector of functions acts element-wise on a vector of arguments:
```{julia}
["a", "list", "of", "strings"] .|> [length, uppercase, reverse, titlecase]
```
## Die `do`-Notation {#sec-do}
## The `do` Notation {#sec-do}
Eine syntaktische Besonderheit zur Definition anonymer Funktionen als Argumente anderer Funktionen ist die `do`-Notation.
A syntactic peculiarity for defining anonymous functions as arguments of other functions is the `do` notation.
Sei `higherfunc(f,a,...)` eine Funktion, deren 1. Argument eine Funktion ist.
Let `higherfunc(f,a,...)` be a function whose first argument is a function.
Dann kann man `higherfunc()` auch ohne erstes Argument aufrufen und statt dessen die Funktion in einem unmittelbar folgenden `do`-Block definieren:
Then you can also call `higherfunc()` without the first argument and instead define the function in an immediately following `do` block:
```julia
higherfunc(a, b) do x, y
Körper von f(x,y)
body of f(x,y)
end
```
Am Beispiel von `Riemann_integrate()` sieht das so aus:
Using `Riemann_integrate()` as an example, this looks like this:
```{julia}
# das ist dasselbe wie Riemann_integrate(x->x^2, 0, 2)
# this is the same as Riemann_integrate(x->x^2, 0, 2)
Riemann_integrate(0, 2) do x x^2 end
```
Der Sinn besteht natürlich in der Anwendung mit komplexeren Funktionen, wie diesem aus zwei Teilstücken zusammengesetzten Integranden:
The purpose is of course in the application with more complex functions, such as this integrand composed of two parts:
```{julia}
r = Riemann_integrate(0, π) do x
z1 = sin(x)
@@ -349,12 +349,12 @@ r = Riemann_integrate(0, π) do x
end
```
## Funktionsartige Objekte
## Function-like Objects
Durch Definition einer geeigneten Methode für einen Typ kann man beliebige Objekte *callable* machen, d.h., sie anschließend wie Funktionen aufrufen.
By defining a suitable method for a type, arbitrary objects can be made *callable*, i.e., callable like functions afterwards.
```{julia}
# struct speichert die Koeffiziente eines Polynoms 2. Grades
# struct stores the coefficients of a 2nd degree polynomial
struct Poly2Grad
a0::Float64
a1::Float64
@@ -365,13 +365,13 @@ p1 = Poly2Grad(2,5,1)
p2 = Poly2Grad(3,1,-0.4)
```
Die folgende Methode macht diese Struktur `callable`.
The following method makes this structure `callable`.
```{julia}
function (p::Poly2Grad)(x)
p.a2 * x^2 + p.a1 * x + p.a0
end
```
Jetzt kann man die Objekte, wenn gewünscht, auch wie Funktionen verwenden.
Now the objects can, if desired, also be used like functions.
```{julia}
@show p2(5) p1(-0.7) p1;
@@ -379,9 +379,9 @@ Jetzt kann man die Objekte, wenn gewünscht, auch wie Funktionen verwenden.
## Operatoren und spezielle Formen
## Operators and Special Forms
- Infix-Operatoren wie `+,*,>,∈,...` sind Funktionen.
- Infix operators like `+,*,>,∈,...` are functions.
@@ -399,7 +399,7 @@ f = +
f(3, 7)
```
- Auch Konstruktionen wie `x[i]`, `a.x`, `[x; y]` werden vom Parser zu Funktionsaufrufen umgewandelt.
- Even constructions like `x[i]`, `a.x`, `[x; y]` are converted by the parser to function calls.
:::{.narrow}
@@ -410,53 +410,53 @@ f(3, 7)
| a.x | getproperty(a, :x) |
| a.x = z | setproperty!(a, :x, z) |
| [x; y;...] | vcat(x, y, ...) |
:Spezielle Formen [(Auswahl)](https://docs.julialang.org/en/v1/manual/functions/#Operators-With-Special-Names)
:Special Forms [(selection)](https://docs.julialang.org/en/v1/manual/functions/#Operators-With-Special-Names)
:::
(Der Doppelpunkt vor einer Variablen macht diese zu einem Symbol.)
(The colon before a variable makes it into a symbol.)
:::{.callout-note}
Für diese Funktionen kann man eigene Methoden implementieren. Zum Beispiel könnten bei einem eigenen Typ das Setzen eines Feldes (`setproperty!()`) die Gültigkeit des Wertes prüfen oder weitere Aktionen veranlassen.
For these functions, one can implement one's own methods. For example, for a custom type, setting a field (`setproperty!()`) could check the validity of the value or trigger further actions.
Prinzipiell können `get/setproperty` auch Dinge tun, die gar nichts mit einem tatsächlich vorhandenen Feld der Struktur zu tun haben.
In principle, `get/setproperty` can also do things that have nothing to do with an actually existing field of the structure.
:::
## Update-Form
## Update Form
Alle arithmetischen Infix-Operatoren haben eine update-Form: Der Ausdruck
All arithmetic infix operators have an update form: The expression
```julia
x = x ⊙ y
```
kann auch geschrieben werden als
can also be written as
```julia
x ⊙= y
```
Beide Formen sind semantisch äquivalent. Insbesondere wird in beiden Formen der Variablen `x` ein auf der rechten Seite geschaffenes neues Objekt zugewiesen.
Both forms are semantically equivalent. In particular, in both forms, a new object created on the right side is assigned to the variable `x`.
Ein Speicherplatz- und Zeit-sparendes __in-place-update__ eines Arrays/Vektors/Matrix ist möglich entweder durch explizite Indizierung
Memory- and time-saving __in-place-update__ of an array/vector/matrix is possible either through explicit indexing
```julia
for i in eachindex(x)
x[i] += y[i]
end
```
oder durch die dazu semantisch äquivalente _broadcast_-Form (s. @sec-broadcast):
or through the semantically equivalent _broadcast_ form (see @sec-broadcast):
```julia
x .= x .+ y
```
## Vorrang und Assoziativität von Operatoren {#sec-vorrang}
## Operator Precedence and Associativity {#sec-vorrang}
Zu berechnende Ausdrücke
Expressions to be computed
```{julia}
-2^3+500/2/10==8 && 13 > 7 + 1 || 9 < 2
```
werden vom Parser in eine Baumstruktur überführt.
are converted by the parser into a tree structure.
```{julia}
using TreeView
@@ -464,75 +464,75 @@ walk_tree(Meta.parse("-2^3+500/2/10==8 && 13 > 7 + 1 || 9 < 2"))
```
- Die Auswertung solcher Ausdrücke wird durch
- Vorrang _(precedence)_ und
- Assoziativität geregelt.
- 'Vorrang' definiert, welche Operatoren stärker binden im Sinne von "Punktrechnung geht vor Strichrechnung".
- 'Assoziativität' bestimmt die Auswertungsreihenfolge bei gleichen oder gleichrangigen Operatoren.
- [Vollständige Dokumentation](https://docs.julialang.org/en/v1/manual/mathematical-operations/#Operator-Precedence-and-Associativity)
- The evaluation of such expressions is regulated by
- precedence and
- associativity.
- 'Precedence' defines which operators bind more strongly in the sense of "multiplication and division before addition and subtraction".
- 'Associativity' determines the evaluation order for operators of equal or same rank.
- [Complete documentation](https://docs.julialang.org/en/v1/manual/mathematical-operations/#Operator-Precedence-and-Associativity)
### Assoziativität
### Associativity
Sowohl Addition und Subtraktion als auch Multiplikation und Divison sind jeweils gleichrangig und linksassoziativ, d.h. es wird von links ausgewertet.
Both addition and subtraction as well as multiplication and division are each of equal rank and left-associative, i.e., they are evaluated from left to right.
```{julia}
200/5/2 # wird von links ausgewertet als (200/5)/2
200/5/2 # evaluated left to right as (200/5)/2
```
```{julia}
200/2*5 # wird von links ausgewertet als (200/2)*5
200/2*5 # evaluated left to right as (200/2)*5
```
Zuweisungen wie `=`, `+=`, `*=`,... sind gleichrangig und rechtsassoziativ.
Assignments like `=`, `+=`, `*=`,... are of equal rank and right-associative.
```{julia}
x = 1
y = 10
# wird von rechts ausgewertet: x += (y += (z = (a = 20)))
# evaluated right to left: x += (y += (z = (a = 20)))
x += y += z = a = 20
@show x y z a;
```
Natürlich kann man die Assoziativität in Julia auch abfragen. Die entsprechenden Funktionen werden nicht explizit aus dem `Base`-Modul exportiert, deshalb muss man den Modulnamen beim Aufruf angeben.
Of course, you can also query the associativity in Julia. The corresponding functions are not explicitly exported from the `Base` module, so the module name must be specified when calling.
```{julia}
for i in (:/, :+=, :(=), :^)
a = Base.operator_associativity(i)
println("Operation $i is $(a)-assoziative")
println("Operation $i is $(a)-associative")
end
```
Also ist der Potenzoperator rechtsassoziativ.
So the power operator is right-associative.
```{julia}
2^3^2 # rechtsassoziativ, = 2^(3^2)
2^3^2 # right-associative, = 2^(3^2)
```
### Vorrang
### Precedence
- Julia ordnet den Operatoren Vorrangstufen von 1 bis 17 zu:
- Julia assigns operator precedence levels from 1 to 17:
```{julia}
for i in (:+, :-, :*, :/, :^, :(=))
p = Base.operator_precedence(i)
println("Vorrang von $i = $p")
println("Precedence of $i = $p")
end
```
- 11 ist kleiner als 12, also geht 'Punktrechnung vor Strichrechnung'
- Der Potenz-Operator `^` hat eine höhere _precedence_.
- Zuweisungen haben die kleinste _precedence_
- 11 is less than 12, so 'multiplication and division before addition and subtraction'
- The power operator `^` has a higher _precedence_.
- Assignments have the smallest _precedence_
```{julia}
# Zuweisung hat kleinsten Vorrang, daher Auswertung als x = (3 < 4)
# assignment has smallest precedence, therefore evaluation as x = (3 < 4)
x = 3 < 4
x
@@ -540,11 +540,11 @@ x
```{julia}
(y = 3) < 4 # Klammern schlagen natürlich jeden Vorrang
(y = 3) < 4 # parentheses当然 override any precedence
y
```
Nochmal zum Beispiel vom Anfang von @sec-vorrang:
Once more to the example from the beginning of @sec-vorrang:
```{julia}
-2^3+500/2/10==8 && 13 > 7 + 1 || 9 < 2
@@ -557,43 +557,43 @@ for i ∈ (:^, :+, :/, :(==), :&&, :>, :|| )
println(Base.operator_precedence(i))
end
```
Nach diesen Vorrangregeln wird der Beispielausdruck also wie folgt ausgewertet:
According to these precedence rules, the example expression is evaluated as follows:
```{julia}
((-(2^3)+((500/2)/10)==8) && (13 > (7 + 1))) || (9 < 2)
```
(Das entspricht natürlich dem oben gezeigten *parse-tree*)
(This of course corresponds to the *parse-tree* shown above)
Es gilt also für den Vorrang:
So the precedence is:
> Potenz > Multiplikation/Division > Addition/Subtraktion > Vergleiche > logisches && > logisches || > Zuweisung
> Power > Multiplication/Division > Addition/Subtraction > Comparisons > logical && > logical || > assignment
Damit wird ein Ausdruck wie
Thus, an expression like
```julia
a = x <= y + z && x > z/2
```
sinnvoll ausgewertet als `a = ((x <= (y+z)) && (x < (z/2)))`
is sensibly evaluated as `a = ((x <= (y+z)) && (x < (z/2)))`
- Eine Besonderheit sind noch
- unäre Operatoren, also insbesondere `+` und `-` als Vorzeichen
- _juxtaposition_, also Zahlen direkt vor Variablen oder Klammern ohne `*`-Symbol
Beide haben Vorrang noch vor Multiplikation und Division.
- A special case is still
- unary operators, in particular `+` and `-` as signs
- _juxtaposition_, i.e., numbers directly before variables or parentheses without `*` symbol
Both have precedence even before multiplication and division.
:::{.callout-important}
Damit ändert sich die Bedeutung von Ausdrücken, wenn man _juxtaposition_ anwendet:
Therefore, the meaning of expressions changes when one applies _juxtaposition_:
```{julia}
1/2*π, 1/2π
```
:::
- Im Vergleich zum Potenzoperator `^` gilt (s. [https://discourse.julialang.org/t/confused-about-operator-precedence-for-2-3x/8214/7](https://discourse.julialang.org/t/confused-about-operator-precedence-for-2-3x/8214/7) ):
- Compared to the power operator `^` (see [https://discourse.julialang.org/t/confused-about-operator-precedence-for-2-3x/8214/7](https://discourse.julialang.org/t/confused-about-operator-precedence-for-2-3x/8214/7) ):
> Unary operators, including juxtaposition, bind tighter than ^ on the right but looser on the left.
Beispiele:
Examples:
```{julia}
-2^2 # -(2^2)
```
@@ -615,28 +615,26 @@ x = 5
```
- Funktionsanwendung `f(...)` hat Vorrang vor allen Operatoren
- Function application `f(...)` has precedence over all operators
```{julia}
sin(x)^2 === (sin(x))^2 # nicht sin(x^2)
sin(x)^2 === (sin(x))^2 # not sin(x^2)
```
### Zusätzliche Operatoren
### Additional Operators
Der [Julia-Parser](https://github.com/JuliaLang/julia/blob/master/src/julia-parser.scm#L13-L31) definiert für zahlreiche Unicode-Zeichen einen Vorrang auf Vorrat, so dass diese Zeichen von Paketen und selbstgeschriebenem Code als Operatoren benutzt werden können.
The [Julia parser](https://github.com/JuliaLang/julia/blob/master/src/julia-parser.scm#L13-L31) assigns precedence to numerous Unicode characters in advance, so that these characters can be used as operators by packages and self-written code.
So haben z.B.
Thus, for example,
```julia
∧ ⊗ ⊘ ⊙ ⊚ ⊛ ⊠ ⊡ ⊓ ∗ ∙ ∤ ⅋ ≀ ⊼ ⋄ ⋆ ⋇ ⋉ ⋊ ⋋ ⋌ ⋏ ⋒ ⟑ ⦸ ⦼ ⦾ ⦿ ⧶ ⧷ ⨇ ⨰ ⨱ ⨲ ⨳ ⨴ ⨵ ⨶ ⨷ ⨸ ⨻ ⨼ ⨽ ⩀ ⩃ ⩄ ⩋ ⩍ ⩎ ⩑ ⩓ ⩕ ⩘ ⩚ ⩜ ⩞ ⩟ ⩠ ⫛
```
den Vorrang 12 wie Multiplikation/Division (und sind wie diese linksassoziativ)
und z.B.
have precedence 12 like multiplication/division (and are left-associative like these)
and for example
```julia
⊕ ⊖ ⊞ ⊟ |++| ∪ ∨ ⊔ ± ∓ ∔ ∸ ≏ ⊎ ⊻ ⊽ ⋎ ⋓ ⧺ ⧻ ⨈ ⨢ ⨣ ⨤ ⨥ ⨦ ⨧ ⨨ ⨩ ⨪ ⨫ ⨬ ⨭ ⨮ ⨹ ⨺ ⩁ ⩂ ⩅ ⩊ ⩌ ⩏ ⩐ ⩒ ⩔ ⩖ ⩗
⊕ ⊖ ⊞ ⊟ |++| ∪ ∨ ⊔ ± ∓ ∔ ∸ ≏ ⊎ ⊻ ⊽ ⋎ ⋓ ⧺ ⧻ ⨈ ⨢ ⨣ ⨤ ⨥ ⨦ ⨧ ⨨ ⨩ ⨪ ⨫ ⨬ ⨭ ⨮ ⨹ ⨺ ⩁ ⩂ ⩅ ⩊ ⩌ ⩏ ⩐ ⩒ ⩔ ⩖ ⩗
```
haben den Vorrang 11 wie Addition/Subtraktion.
have precedence 11 like addition/subtraction.