329 lines
8.0 KiB
Plaintext
329 lines
8.0 KiB
Plaintext
---
|
|
engine: julia
|
|
---
|
|
|
|
```{julia}
|
|
#| error: false
|
|
#| echo: false
|
|
#| output: false
|
|
using InteractiveUtils
|
|
```
|
|
|
|
# First Contact
|
|
|
|
Dieses Kapitel soll beim 'Loslegen' helfen. Es läßt viele Details weg und die Codebeispiele sind oft eher suboptimal.
|
|
|
|
|
|
## Julia als Taschenrechner
|
|
|
|
```{julia}
|
|
#| eval: true
|
|
#| echo: false
|
|
#| output: false
|
|
|
|
using REPL, Markdown
|
|
|
|
function mhelp(s,n,m)
|
|
helptxt = Core.eval(Main, REPL.helpmode(s))
|
|
helpstr=Markdown.plaininline(helptxt)
|
|
print("...\n", join(split(helpstr,'\n')[n:m],'\n'), "\n...")
|
|
end;
|
|
|
|
function Tab(s)
|
|
l = filter(x->startswith(x,s), REPL.doc_completions(s))
|
|
println.(l[2:end])
|
|
return # return nothing, since broadcast println produces empty vector
|
|
end
|
|
|
|
▷ = |>
|
|
|
|
# IJulia.set_verbose(true)
|
|
```
|
|
|
|
Berechne $\qquad 12^{1/3} + \frac{3\sqrt{2}}{\sin(0.5)-\cos(\frac{\pi}{4})\log(3)}+ e^5$
|
|
|
|
```{julia}
|
|
12^(1/3) + 3sqrt(2) / (sin(.5) - cos(pi/4)*log(3)) + exp(5)
|
|
```
|
|
|
|
Man beachte:
|
|
|
|
- Potenzen schreibt man `a^b`.
|
|
- Die Konstante `pi` ist vordefiniert.
|
|
- `log()` ist der natürliche Logarithmus.
|
|
- Das Multiplikationszeichen `a*b` kann nach einer Zahl weggelassen werden, wenn eine Variable, Funktion oder Klammer folgt.
|
|
|
|
|
|
## Die wichtigsten Tasten: `Tab` und `?` {#sec-tab}
|
|
|
|
Man drücke beim Programmieren immer wieder die Tabulatortaste, sobald 2...3 Buchstaben eines Wortes getippt sind. Es werden dann mögliche Ergänzungen angezeigt bzw. ergänzt, wenn die Ergänzung eindeutig ist. Das spart Zeit und bildet ungemein:
|
|
|
|
```{julia}
|
|
lo = "lo" #| hide_line
|
|
lo ▷ Tab
|
|
```
|
|
|
|
```{julia}
|
|
pri = "pri" #| hide_line
|
|
pri ▷ Tab
|
|
```
|
|
|
|
Die eingebaute Julia-Hilfe `?name` zu allen Funktionen und Konstrukten ist sehr umfassend. Hier ein eher kurzes Beispiel:
|
|
|
|
```{julia}
|
|
?for
|
|
```
|
|
|
|
:::{.content-hidden unless-format="xxx"}
|
|
|
|
::: {.cell }
|
|
``` {.julia .cell-code}
|
|
?for
|
|
```
|
|
|
|
::: {.cell-output .cell-output-stdout}
|
|
```
|
|
search: for foreach foldr floor mapfoldr factorial EOFError OverflowError
|
|
|
|
for loops repeatedly evaluate a block of statements while iterating over a sequence of values.
|
|
|
|
Examples
|
|
|
|
julia> for i in [1, 4, 0]
|
|
println(i)
|
|
end
|
|
1
|
|
4
|
|
0
|
|
|
|
```
|
|
:::
|
|
:::
|
|
:::
|
|
|
|
|
|
## Variablen und Zuweisungen
|
|
|
|
Variablen entstehen durch Zuweisung *(assignment)* mit dem Zuweisungsoperator `=` . Danach können sie in weiteren Anweisungen verwendet werden.
|
|
|
|
```{julia}
|
|
x = 1 + sqrt(5)
|
|
y = x / 2
|
|
```
|
|
|
|
Im interaktiven Betrieb zeigt Julia das Ergebnis der letzten Operation an.
|
|
|
|
:::{.callout-note .titlenormal}
|
|
Zuweisungen sind keine mathematischen Gleichungen. Die Semantik des Zuweisungsoperators (Gleichheitszeichens) ist:
|
|
|
|
- berechne die rechte Seite und
|
|
- weise das Ergebnis der linken Seite zu.
|
|
|
|
Ausdrücke wie `x + y = sin(2)` sind daher unzulässig. Links darf nur ein Variablenname stehen.
|
|
:::
|
|
|
|
|
|
## Datentypen
|
|
|
|
Julia ist eine [stark typisierte](https://de.wikipedia.org/wiki/Starke_Typisierung) Sprache. Alle Objekte haben einen Typ.
|
|
So gibt es unter anderem die Basistypen
|
|
|
|
- Ganze Zahlen *(integers)*,
|
|
- Gleitkommazahlen *(floating point numbers)*,
|
|
- Zeichenketten *(strings)* und
|
|
- Wahrheitswerte *(booleans)*.
|
|
|
|
Den Typ einer Variablen kann man mit der Funktion `typeof()` ermitteln.
|
|
```{julia}
|
|
#| warning: true
|
|
#| error: true
|
|
for x ∈ (42, 12.0, 3.3e4, "Hallo!", true)
|
|
println("x = ", x, " ..... Typ: ", typeof(x))
|
|
end
|
|
```
|
|
Die Standard-Gleitkommazahl hat eine Länge von 64 Bit, entspricht also einer `double` in C/C++/Java.
|
|
|
|
Julia ist eine [dynamisch typisierte](https://de.wikipedia.org/wiki/Dynamische_Typisierung) Sprache.
|
|
Variablen haben keinen Typ. Sie sind typlose Referenzen (Zeiger) auf Objekte.
|
|
Wenn man vom „Typ einer Variablen“ spricht, meint man den Typ des Objektes, das der Variablen gerade zugewiesen ist.
|
|
|
|
```{julia}
|
|
x = sqrt(2)
|
|
|
|
println( typeof(x), " - Wert von x = $x" )
|
|
|
|
x = "Jetzt bin ich keine Gleitkommazahl mehr!"
|
|
|
|
println( typeof(x), " - Wert von x = $x" )
|
|
```
|
|
|
|
## Druckanweisungen
|
|
Die Funktion `println()` unterscheidet sich von `print()` dadurch, dass sie am Ende einen Zeilenvorschub ausgibt.
|
|
```{julia}
|
|
print(y)
|
|
print("...die Zeile geht weiter...")
|
|
print("immernoch...")
|
|
println(y)
|
|
println("Neue Zeile")
|
|
println("Neue Zeile")
|
|
```
|
|
Beide Funkionen können als Argument eine Liste von *strings* und Variablen bekommen. Man kann Variablen auch in *strings* einbetten, indem man dem Variablennamen ein Dollarzeichen voranstellt *(string interpolation)*.
|
|
|
|
```{julia}
|
|
x = 23
|
|
y = 3x + 5
|
|
zz = "Fertig!"
|
|
println("x= ", x, " ...und y= ", y, "...", zz) # 1. Variante
|
|
println("x= $x ...und y= $y...$zz") # Variante mit string interpolation
|
|
```
|
|
|
|
|
|
:::{.callout-note .titlenormal collapse=true icon=false }
|
|
## Wenn man ein Dollarzeichen drucken will...
|
|
|
|
muss man einen *backslash* voranstellen. Wenn man einen *backslash* drucken will, muss man ihn verdoppeln.
|
|
```{julia}
|
|
println("Ein Dollar: 1\$ und drei backslashs: \\\\\\ ")
|
|
```
|
|
:::
|
|
|
|
## Funktionen
|
|
Funktionsdefinitionen beginnen mit dem Schlüsselwort `function` und enden mit dem Schlüsselwort `end`. In der Regel haben sie eine oder mehrere Argumente und geben beim Aufruf ein berechnetes Objekt mit der `return`-Anweisung zurück.
|
|
```{julia}
|
|
function hypotenuse(a, b) # heute besonders umständlich
|
|
c2 = a^2 + b^2
|
|
c = sqrt(c2)
|
|
return c
|
|
end
|
|
```
|
|
Nach ihrer Definition kann die Funktion benutzt (aufgerufen) werden. Die in der Definition verwendeten Variablen `a,b,c,c2` sind lokale Variablen und stehen außerhalb der Funktionsdefinition nicht zur Verfügung.
|
|
```{julia}
|
|
#| error: true
|
|
x = 3
|
|
z = hypotenuse(x, 4)
|
|
println("z = $z")
|
|
println("c = $c")
|
|
```
|
|
|
|
Sehr einfache Funktionen können auch als Einzeiler definiert werden.
|
|
```{julia}
|
|
hypotenuse(a, b) = sqrt(a^2+b^2)
|
|
```
|
|
|
|
|
|
## Tests
|
|
Tests liefern einen Wahrheitswert zurück.
|
|
```{julia}
|
|
x = 3^2
|
|
x < 2^3
|
|
```
|
|
Neben den üblichen arithmetischen Vergleichen `==, !=, <, <= ,> ,>=`
|
|
gibt es noch viele andere Tests. Natürlich kann man das Ergebnis eines Tests auch einer Variablen zuweisen, welche dann vom Typ `Bool` ist. Die logischen Operatoren `&&`, `||` und Negation `!` können in Tests verwendet werden.
|
|
|
|
```{julia}
|
|
test1 = "Auto" in ["Fahrrad", "Auto", "Bahn"]
|
|
test2 = x == 100 || !(x <= 30 && x > 8)
|
|
test3 = startswith("Lampenschirm", "Lamp")
|
|
println("$test1 $test2 $test3")
|
|
```
|
|
|
|
## Verzweigungen
|
|
Verzweigungen (bedingte Anweisungen) haben die Form
|
|
|
|
```default
|
|
if <Test>
|
|
<Anweisung1>
|
|
<Anweisung2>
|
|
...
|
|
end
|
|
```
|
|
|
|
|
|
Ein `else`-Zweig und `elseif`-Zweige sind möglich.
|
|
```{julia}
|
|
x = sqrt(100)
|
|
|
|
if x > 20
|
|
println("Seltsam!")
|
|
else
|
|
println("OK")
|
|
y = x + 3
|
|
end
|
|
```
|
|
|
|
Einrückungen verbessern die Lesbarkeit, sind aber fakultativ. Zeilenumbrüche trennen Anweisungen. Das ist auch durch Semikolon möglich. Obiger Codeblock ist für Julia identisch zu folgender Zeile:
|
|
```{julia}
|
|
# Bitte nicht so programmieren! Sie werden es bereuen!
|
|
x=sqrt(100); if x > 20 println("Seltsam!") else println("OK"); y = x + 3 end
|
|
```
|
|
|
|
Es wird dringend empfohlen, von Anfang an den eigenen Code übersichtlich mit sauberen Einrückungen zu formatieren!
|
|
|
|
|
|
## Einfache `for`-Schleifen
|
|
|
|
zum wiederholten Abarbeiten von Anweisungen haben die Form
|
|
```default
|
|
for <Zähler> = Start:Ende
|
|
<Anweisung1>
|
|
<Anweisung2>
|
|
...
|
|
end
|
|
```
|
|
Beispiel:
|
|
|
|
```{julia}
|
|
sum = 0
|
|
for i = 1:100
|
|
sum = sum + i
|
|
end
|
|
sum
|
|
```
|
|
|
|
## Arrays
|
|
1-dimensionale Arrays (Vektoren) sind eine einfache Form von Containern. Man kann sie mit echigen Klammern anlegen
|
|
und auf die Elemente per Index zugreifen. Die Indizierung beginnt mit 1.
|
|
|
|
```{julia}
|
|
v = [12, 33.2, 17, 19, 22]
|
|
```
|
|
|
|
```{julia}
|
|
typeof(v)
|
|
```
|
|
|
|
```{julia}
|
|
v[1] = v[4] + 10
|
|
v
|
|
```
|
|
|
|
Man kann leere Vektoren anlegen und sie verlängern.
|
|
```{julia}
|
|
v = [] # leerer Vektor
|
|
push!(v, 42)
|
|
push!(v, 13)
|
|
v
|
|
```
|
|
|
|
:::{.callout-note icon="false" .titlenormal collapse="true" font-variant-ligatures="no-contextual" }
|
|
|
|
## Nachtrag: wie die Wirkung der Tab-Taste auf dieser Seite simuliert wurde...
|
|
|
|
```{julia}
|
|
using REPL
|
|
|
|
function Tab(s)
|
|
l = filter(x->startswith(x,s), REPL.doc_completions(s))
|
|
println.(l[2:end])
|
|
return # return nothing, since broadcast println produces empty vector
|
|
end
|
|
|
|
▷ = |> # https://docs.julialang.org/en/v1/manual/functions/#Function-composition-and-piping
|
|
|
|
pri = "pri";
|
|
```
|
|
|
|
```{julia}
|
|
pri ▷ Tab
|
|
```
|
|
::: |