332 lines
7.6 KiB
Plaintext
332 lines
7.6 KiB
Plaintext
---
|
||
engine: julia
|
||
---
|
||
|
||
```{julia}
|
||
#| error: false
|
||
#| echo: false
|
||
#| output: false
|
||
using InteractiveUtils
|
||
```
|
||
|
||
# First Contact
|
||
|
||
This chapter helps you get started. It omits many details, and the code examples are often rather suboptimal.
|
||
|
||
|
||
## Julia as a Calculator
|
||
|
||
```{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)
|
||
dc = map(x->x.name, REPL.doc_completions(s))
|
||
l = filter(x->startswith(x,s), dc)
|
||
println.(l)
|
||
return # return nothing, since broadcast println produces empty vector
|
||
end
|
||
|
||
▶ = |>
|
||
|
||
# IJulia.set_verbose(true)
|
||
```
|
||
|
||
Compute: $\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)
|
||
```
|
||
|
||
Note that:
|
||
|
||
- Powers are written as `a^b`.
|
||
- The constant `π` is predefined.
|
||
- `log()` is the natural logarithm.
|
||
- The multiplication sign `a*b` can be omitted after a number if it is followed by a variable, function, or parenthesis.
|
||
|
||
|
||
## The most important keys: `Tab` and `?` {#sec-tab}
|
||
|
||
When programming, repeatedly press the Tab key as soon as 2–3 letters of a word have been typed. Potential completions are then displayed or completed if the completion is unique. This saves time and is extremely helpful.
|
||
|
||
```{julia}
|
||
lo = "lo" #| hide_line
|
||
lo ▷ Tab
|
||
```
|
||
|
||
```{julia}
|
||
pri = "pri" #| hide_line
|
||
pri ▷ Tab
|
||
```
|
||
|
||
The built-in Julia help `?name` for all functions and constructs is very comprehensive. Here is a rather brief example:
|
||
|
||
```{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
|
||
|
||
```
|
||
:::
|
||
:::
|
||
:::
|
||
|
||
|
||
## Variables and Assignments
|
||
|
||
Variables are created through assignment with the assignment operator `=`. Afterwards, they can be used in further statements.
|
||
|
||
```{julia}
|
||
x = 1 + sqrt(5)
|
||
y = x / 2
|
||
```
|
||
|
||
In interactive mode, Julia displays the result of the last statement.
|
||
|
||
:::{.callout-note .titlenormal}
|
||
Assignments are not mathematical equations. The semantics of the assignment operator (the equals sign) is:
|
||
|
||
- Compute the right side and
|
||
- Assign the result to the left side.
|
||
|
||
Expressions like `x + y = sin(2)` are therefore invalid. Only a variable name may appear on the left side.
|
||
:::
|
||
|
||
|
||
## Data types
|
||
|
||
Julia is a [strongly typed](https://en.wikipedia.org/wiki/Strong_and_weak_typing) language. All objects have a type.
|
||
Among other things, there are the basic types
|
||
|
||
- Integers,
|
||
- Floating-point numbers,
|
||
- Strings and
|
||
- Booleans.
|
||
|
||
The type of a variable can be determined using the `typeof()` function.
|
||
```{julia}
|
||
#| warning: true
|
||
#| error: true
|
||
for x ∈ (42, 12.0, 3.3e4, "Hello!", true)
|
||
println("x = ", x, " ..... Type: ", typeof(x))
|
||
end
|
||
```
|
||
The standard floating-point number has a size of 64 bits, which corresponds to a `double` in C/C++/Java.
|
||
|
||
Julia is a [dynamically typed](https://en.wikipedia.org/wiki/Dynamic_typing) language.
|
||
Variables have no type; they are typeless references (pointers) to objects.
|
||
When people speak of the "type of a variable", they mean the type of the object currently assigned to the variable.
|
||
|
||
```{julia}
|
||
x = sqrt(2)
|
||
|
||
println( typeof(x), " - Value of x = $x" )
|
||
|
||
x = "Now I'm no longer a floating-point number!"
|
||
|
||
println( typeof(x), " - Value of x = $x" )
|
||
```
|
||
|
||
## Print statements
|
||
The `println()` function differs from `print()` in that it outputs a line break at the end.
|
||
```{julia}
|
||
print(y)
|
||
print("...the line continues...")
|
||
print("still...")
|
||
println(y)
|
||
println("New line")
|
||
println("New line")
|
||
```
|
||
Both functions can accept a list of *strings* and variables as arguments. Variables can also be embedded in *strings* by prefixing the variable name with a dollar sign *(string interpolation)*.
|
||
|
||
```{julia}
|
||
x = 23
|
||
y = 3x + 5
|
||
zz = "Done!"
|
||
println("x= ", x, " ...and y= ", y, "...", zz) # 1. variant
|
||
println("x= $x ...and y= $y...$zz") # variant with string interpolation
|
||
```
|
||
|
||
|
||
:::{.callout-note .titlenormal collapse=true icon=false }
|
||
## If you want to print a dollar sign...
|
||
|
||
you must prepend a *backslash*. If you want to print a *backslash*, you must double it.
|
||
```{julia}
|
||
println("One dollar: 1\$ and three backslashes: \\\\\\ ")
|
||
```
|
||
:::
|
||
|
||
## Functions
|
||
Function definitions begin with the keyword `function` and end with the keyword `end`. Typically, they have one or more arguments and return a computed result via the `return` statement.
|
||
```{julia}
|
||
function hypotenuse(a, b) # particularly cumbersome today
|
||
c2 = a^2 + b^2
|
||
c = sqrt(c2)
|
||
return c
|
||
end
|
||
```
|
||
After their definition, the function can be used (called). The variables `a,b,c,c2` used in the definition are local variables and are not available outside the function definition.
|
||
```{julia}
|
||
#| error: true
|
||
x = 3
|
||
z = hypotenuse(x, 4)
|
||
println("z = $z")
|
||
println("c = $c")
|
||
```
|
||
|
||
Very simple functions can also be defined as single-line functions.
|
||
```{julia}
|
||
hypotenuse(a, b) = sqrt(a^2+b^2)
|
||
```
|
||
|
||
|
||
## Tests
|
||
Tests return a Boolean value.
|
||
```{julia}
|
||
x = 3^2
|
||
x < 2^3
|
||
```
|
||
In addition to the usual arithmetic comparisons `==, !=, <, <= ,> ,>=`
|
||
there are many other tests. Of course, the result of a test can also be assigned to a variable, which is then of type `Bool`. The logical operators `&&`, `||` and negation `!` can be used in tests.
|
||
|
||
```{julia}
|
||
test1 = "Car" in ["Bicycle", "Car", "Train"]
|
||
test2 = x == 100 || !(x <= 30 && x > 8)
|
||
test3 = startswith("lampshade", "Lamp")
|
||
println("$test1 $test2 $test3")
|
||
```
|
||
|
||
|
||
## Branches
|
||
Branches (conditional statements) have the form
|
||
|
||
```default
|
||
if <test>
|
||
<statement1>
|
||
<statement2>
|
||
...
|
||
end
|
||
```
|
||
|
||
An `else` branch and `elseif` branches are possible.
|
||
```{julia}
|
||
x = sqrt(100)
|
||
|
||
if x > 20
|
||
println("Strange!")
|
||
else
|
||
println("OK")
|
||
y = x + 3
|
||
end
|
||
```
|
||
|
||
Indentation improves readability but is optional. Line breaks separate statements, and this can also be done with semicolons. The above code block is identical to the following line in Julia:
|
||
```{julia}
|
||
# Please don't program like this! You will regret it!
|
||
x=sqrt(100); if x > 20 println("Strange!") else println("OK"); y = x + 3 end
|
||
```
|
||
|
||
It is strongly recommended to format your own code from the beginning with clear indentation!
|
||
|
||
|
||
## Simple `for` loops
|
||
|
||
`for` loops for repeated execution of statements have the form
|
||
```default
|
||
for <counter> = start:end
|
||
<statement1>
|
||
<statement2>
|
||
...
|
||
end
|
||
```
|
||
Example:
|
||
|
||
```{julia}
|
||
sum = 0
|
||
for i = 1:100
|
||
sum = sum + i
|
||
end
|
||
sum
|
||
```
|
||
|
||
|
||
## Arrays
|
||
1-dimensional arrays (vectors) are a simple form of containers. They can be created with square brackets
|
||
and accessed by index. Indexing starts at 1.
|
||
|
||
```{julia}
|
||
v = [12, 33.2, 17, 19, 22]
|
||
```
|
||
|
||
```{julia}
|
||
typeof(v)
|
||
```
|
||
|
||
```{julia}
|
||
v[1] = v[4] + 10
|
||
v
|
||
```
|
||
|
||
Empty vectors can be created and extended with `push!()`.
|
||
```{julia}
|
||
v = [] # empty vector
|
||
push!(v, 42)
|
||
push!(v, 13)
|
||
v
|
||
```
|
||
|
||
|
||
:::{.callout-note icon="false" .titlenormal collapse="true" font-variant-ligatures="no-contextual" }
|
||
|
||
## Postscript: how the effect of the Tab key was simulated on this page
|
||
|
||
```{julia}
|
||
using REPL
|
||
function Tab(s)
|
||
dc = map(x->x.name, REPL.doc_completions(s))
|
||
l = filter(x->startswith(x,s), dc)
|
||
println.(l)
|
||
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
|
||
```
|
||
::: |