JuliaKurs23/nb/5_TricksHelp.ipynb
2023-05-12 20:12:56 +02:00

563 lines
14 KiB
Plaintext

{
"cells": [
{
"cell_type": "markdown",
"id": "2ffe347c",
"metadata": {},
"source": [
"# Julia Dokumentation\n",
"\n",
"[https://docs.julialang.org/](https://docs.julialang.org/) die offizielle Dokumentation\n",
"\n",
"Einige Seiten mit Übersichten:\n",
"\n",
" - [https://docs.julialang.org/en/v1/base/punctuation/](https://docs.julialang.org/en/v1/base/punctuation/) Verzeichnis der Symbole\n",
" - [https://docs.julialang.org/en/v1/manual/unicode-input/](https://docs.julialang.org/en/v1/manual/unicode-input/) Verzeichnis spezieller Unicode-Symbole und deren Eingabe in Julia via Tab-Vervollständigung\n",
" - [https://docs.julialang.org/en/v1/manual/mathematical-operations/#Rounding-functions](https://docs.julialang.org/en/v1/manual/mathematical-operations/#Rounding-functions) Liste mathematischer Funktionen \n",
"\n",
"---------\n",
"\n",
"\n",
"\n",
"# Hilfe und praktische Tipps\n",
"\n",
"----\n",
"\n",
"\n",
"## Julia REPL (Read - Eval - Print - Loop)\n",
"\n",
"Start von Julia in einem Terminal:\n",
"```\n",
"julia>\n",
"```\n",
"\n",
"| Kommando | Wirkung |\n",
"| :----------------------------| :------------------------ |\n",
"| `exit()` oder `Ctrl-d` | exit Julia |\n",
"| `Ctrl-c` | interrupt |\n",
"| `Ctrl-l` | clear screen |\n",
"| Kommando mit `;` beenden | Ausgabe unterdrückt |\n",
"| `include(\"filename.jl\")` | Datei mit Julia-Code einlesen und ausführen |\n",
"\n",
"\n",
"-----\n",
"\n",
"Der REPL hat verschiedene Modi: \n",
"\n",
"| Modus | Prompt | Modus starten | Modus verlassen |\n",
"| :- | :- | :- | :- |\n",
"|||||\n",
"| default| `julia>` | | |\n",
"|||||\n",
"| Package manager | `pkg>` | `]` | `backspace` |\n",
"|||||\n",
"| Help | `help?>` | `?`| `backspace `|\n",
"|||||\n",
"|Shell | `shell>` | `;` | `backspace`|\n",
"|||||\n",
"\n",
"--------\n",
"\n",
"\n",
"## Jupyter notebooks (IJulia)\n",
"\n",
"Die Modi sind als Einzeiler in einer eigenen Input-Zelle nutzbar: \n",
"\n",
"(i) ein Kommando des Paket-Managers:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d6c200e5",
"metadata": {},
"outputs": [],
"source": [
"] status "
]
},
{
"cell_type": "markdown",
"id": "9caf3630",
"metadata": {},
"source": [
"(ii) eine Help-Abfrage:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c923aa16",
"metadata": {},
"outputs": [],
"source": [
"?sin"
]
},
{
"cell_type": "markdown",
"id": "bfc75d15",
"metadata": {},
"source": [
"(iii) Ein Shell-Kommando:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3617aff8",
"metadata": {},
"outputs": [],
"source": [
";ls .."
]
},
{
"cell_type": "markdown",
"id": "bdce3ab2",
"metadata": {},
"source": [
"## Der Paket-Manager\n",
"\n",
"- Über 7000 Pakete, siehe [https://julialang.org/packages/](https://julialang.org/packages/)\n",
"- Bevor sie mit `using Module` verwendet werden können, müssen sie heruntergeladen und installiert werden.\n",
"- Dazu dient der `package manager`\n",
"- 2 Betriebsarten: \n",
" - als normale Julia-Anweisungen, die auch in einer `.jl`-Programmdatei stehen können:\n",
" ```\n",
" using Pkg\n",
" Pkg.add(\"TollesPaket\")\n",
" ```\n",
" - im speziellen pkg-Modus des Julia-REPLs:\n",
" ```\n",
" ] add TollesPaket\n",
" ```\n",
"----- \n",
"\n",
"### Einige Funktionen\n",
"\n",
"| Funktion | `pkg` - Mode | Erklärung |\n",
"|:------------------------|:----------------------|:----------------------------------------------------------|\n",
"| `Pkg.add(\"MyPack\")` | `pkg> add MyPack` | add `MyPack.jl` to current environment |\n",
"| `Pkg.rm(\"MyPack\")` | `pkg> remove MyPack` | remove `MyPack.jl` from current environment |\n",
"| `Pkg.update()` | `pkg> update` | update packages in current environment |\n",
"| `Pkg.activate(\"mydir\")` | `pkg> activate mydir` | activate directory as current environment |\n",
"| `Pkg.status()` | `pkg> status` | list packages |\n",
"\n",
"\n",
"### Installierte Pakete und Environments \n",
"\n",
"- Julia und der Paketmanager verwalten \n",
" 1. eine Liste der mit dem Kommando `Pkg.add()` bzw. `]add` explizit installierten Pakete mit genauer Versionsbezeichnung in einer Datei `Project.toml` und \n",
" 2. eine Liste aller dabei auch als implizite Abhängigkeiten installierten Pakete in der Datei `Manifest.toml`. \n",
"- Das Verzeichnis, in dem diese Dateien stehen, ist das `environment` und wird mit `Pkg.status()` bzw. `]status` angezeigt. \n",
"- Im Normalfall sieht das so aus: \n",
"```\n",
"(@v1.7) pkg> status\n",
" Status `~/.julia/environments/v1.7/Project.toml`\n",
" [1dea7af3] OrdinaryDiffEq v6.7.1\n",
" [91a5bcdd] Plots v1.27.1\n",
" [438e738f] PyCall v1.93.1\n",
"```\n",
"- Man kann für verschiedene Projekte eigene `environments` benutzen. Dazu kann man entweder Julia mit \n",
"```\n",
"julia --project=path/to/myproject\n",
"```\n",
"starten oder in Julia das environment mit `Pkg.activate(\"path/to/myproject\")` aktivieren. Dann werden `Project.toml, Manifest.toml` dort angelegt und verwaltet. (Die Installation der Paketdateien erfolgt weiterhin irgendwo unter `$HOME/.julia`) \n",
"\n",
"\n",
"### Zum Installieren von Paketen auf unserem Jupyter-Server `misun103`:\n",
"- Es gibt ein zentrales Repository, in dem alle von mir erwähnten Pakete bereits installiert sind. \n",
"- Dort haben Sie keine Schreibrechte.\n",
"- Sie können aber zusätzliche Pakete in Ihrem `Home` installieren. Dazu ist als erster Befehl nötig, das aktuelle Verzeichnis zu aktivieren: \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "103bd8a1",
"metadata": {},
"outputs": [],
"source": [
"] activate ."
]
},
{
"cell_type": "markdown",
"id": "077e93f2",
"metadata": {},
"source": [
"(Man beachte den Punkt!)\n",
"\n",
"----\n",
"\n",
"Danach können Sie mit `add` im Pkg-Modus auch Pakete installieren:\n",
"\n",
"```\n",
"] add TollesPaket\n",
"```\n",
"\n",
"\n",
"Achtung! Das kann dauern! Viele Pakete haben komplexe Abhängigkeiten und lösen die Installation von weiteren Paketen aus. Viele Pakete werden beim Installieren vorkompiliert. Im REPL sieht man den Installationsfortschritt, im Jupyter-Notebook nicht.\n",
"\n",
"\n",
"## Eingebaute Hilfe und Informationen\n",
"Mit `?` und der `Tab`-Taste kommt man oft weiter. \n",
"\n",
"\n",
"\n",
"### weitere Hilfe: `@which`, `fieldnames()`, `methods()`, `names()`, `pwd()`\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4f099673",
"metadata": {},
"outputs": [],
"source": [
"# Die Zuordnung zu einem Modul zeigt @which an:\n",
"\n",
"@which(sqrt)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "44276c0d",
"metadata": {},
"outputs": [],
"source": [
"# Die Komponenten einer struct oder eines anderen zusammengesetzten Typs:\n",
"\n",
"fieldnames(Rational)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a200a34f",
"metadata": {},
"outputs": [],
"source": [
"fieldnames(Complex)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d99bfda9",
"metadata": {},
"outputs": [],
"source": [
"# alle Methoden einer Funktion\n",
"\n",
"methods(sqrt)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b3e6f127",
"metadata": {},
"outputs": [],
"source": [
"# alle Methoden einer Funktion bei bestimmten Argumenttypen. Die Argumenttypen müssen als Tupel angegeben werden\n",
"\n",
"methods(sqrt, (Number,)) # Komma nötig für 1-elementiges Tupel "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e74572ad",
"metadata": {},
"outputs": [],
"source": [
"# für einen Typ gibt methods() alle Konstruktoren aus\n",
"\n",
"methods(Int64)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e4de6078",
"metadata": {},
"outputs": [],
"source": [
"# names(Module) gibt alle von einem Modul exportierte Namen aus. \n",
"# genau wie auch\n",
"#\n",
"# ?Module \n",
"#\n",
"# funktioniert es erst, wenn das Modul mit 'using Module' geladen ist.\n",
"# Oft ist es besser, wenn die using-Anweisung in einer eigenen Zelle steht.\n",
"\n",
"using Plots"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f1df8377",
"metadata": {},
"outputs": [],
"source": [
"names(Plots)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3654fab2",
"metadata": {},
"outputs": [],
"source": [
"# Julia kürzt den interaktiven Output. \n",
"# ein explizites print() zeigt alles:\n",
"\n",
"print(names(Plots))"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "dc9ca3b6",
"metadata": {},
"outputs": [],
"source": [
"# eine andere Möglichkeit der Ausgabe mit Überlänge in Jupyter\n",
"\n",
"show(stdout, MIME(\"text/plain\"), names(Plots))"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9fa0f216",
"metadata": {},
"outputs": [],
"source": [
"# pwd() \"print working directory\" zeigt, in welchem Verzeichnis Julia gerade operiert. \n",
"#\n",
"# Wichtig für die Ein/Ausgabe mit Dateien, z.B. include()\n",
"\n",
"pwd()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "99c19918",
"metadata": {},
"outputs": [],
"source": [
"include(\"Jupyter.jl\") # Datei mit Julia-Code einlesen und abarbeiten"
]
},
{
"cell_type": "markdown",
"id": "1464d951",
"metadata": {},
"source": [
"## Informationen zu Typen\n",
"\n",
"### `subtypes()`, `supertypes()`, `typemax()`, `typemin()`, `fieldnames()`, `Base.return_types()`, `dump()`\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1358c363",
"metadata": {},
"outputs": [],
"source": [
"subtypes(Real) # die letzten zwei sind durch das 'using Plots' dazugekommen"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e35fb7da",
"metadata": {},
"outputs": [],
"source": [
"supertypes(Real)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "53be4687",
"metadata": {},
"outputs": [],
"source": [
"typemax(Int64), typemin(Int64), fieldnames(Complex)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3a9ed940",
"metadata": {},
"outputs": [],
"source": [
"Base.return_types(sqrt, (Float64,))"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "207af4bd",
"metadata": {},
"outputs": [],
"source": [
"Base.return_types(sqrt, (Complex{Int64},))"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "66b42304",
"metadata": {},
"outputs": [],
"source": [
"# dump() zeigt alle Teile eines zusammengesetzten Objekts\n",
"\n",
"x = 3//4 + 75im\n",
"dump(x)"
]
},
{
"cell_type": "markdown",
"id": "9c6edfea",
"metadata": {},
"source": [
"## Der Julia JIT _(just in time)_ Compiler\n",
"\n",
"Julia baut auf die Werkzeuge des _LLVM Compiler Infrastructure Projects_ auf.\n",
"\n",
"\n",
"Stages of Compilation \n",
"\n",
"| stage & result | introspection command |\n",
"| :--- | :--- |\n",
"|Parse ==> Abstract Syntax Tree (AST) | `Meta.parse()` |\n",
"| Lowering: transform AST ==> Static Single Assignment (SSA) form | `@code_lowered`|\n",
"| Type Inference | `@code_warntype`, `@code_typed` |\n",
"| Generate LLVM intermediate representation | `@code_llvm`|\n",
"| Generate native machine code | `@code_native` |\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4d433ab8",
"metadata": {},
"outputs": [],
"source": [
"function f(x,y)\n",
" z = x^2 + log(y)\n",
" return 2z\n",
"end"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "de444d8a",
"metadata": {},
"outputs": [],
"source": [
"p = Meta.parse( \"function f(x,y); z=x^2+log(y); return 2x; end \")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1ddf17aa",
"metadata": {},
"outputs": [],
"source": [
"using TreeView"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "70d267d7",
"metadata": {},
"outputs": [],
"source": [
"walk_tree(p)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b19b64ec",
"metadata": {},
"outputs": [],
"source": [
"@code_lowered f(2,4)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "57eb03f9",
"metadata": {},
"outputs": [],
"source": [
"@code_warntype f(2,4)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cf273a25",
"metadata": {},
"outputs": [],
"source": [
"@code_typed f(2,4)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "28779f6b",
"metadata": {},
"outputs": [],
"source": [
"@code_llvm f(2,4)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "02711d1f",
"metadata": {},
"outputs": [],
"source": [
"@code_native f(2,4)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Julia 1.8.5",
"language": "julia",
"name": "julia-1.8"
},
"language_info": {
"file_extension": ".jl",
"mimetype": "application/julia",
"name": "julia",
"version": "1.8.5"
}
},
"nbformat": 4,
"nbformat_minor": 5
}