---
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 `pi` is predefined.
- `log()` is the natural logarithm.
- The multiplication sign `a*b` can be omitted after a number if 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 short 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 `=` . Afterward, 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 operation.

:::{.callout-note .titlenormal}
Assignments are not mathematical equations. The semantics of the assignment operator (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 length 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 one speaks of the "type of a variable", one means 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 object with the `return` statement on calling.
```{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. This can also be done with semicolons. The above code block is identical to the following line for 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 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.
```{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
```
:::