---
engine: julia
julia: 
  exeflags: ["--color=yes"]
---

```{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 not optimal. 


## 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 broadcasting println produces an empty vector
end

▷ = |>

# IJulia.set_verbose(true)
```

Compute the following: $\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 operator `*` can be omitted after a number when followed by a variable, function, or opening parenthesis.


## The most important keys: `Tab` and `?` {#sec-tab}

When programming, press the Tab key as soon as you've typed 2–3 letters of a word. Potential completions are then displayed or completed if the completion is unique. This saves time and you learn a lot about Julia.

```{julia}
lo = "lo" #| hide_line
lo ▷ Tab
```

```{julia}
pri = "pri" #| hide_line
pri ▷ Tab
```

Julia's built-in help system `?name` provides comprehensive documentation for all functions and constructs. Here is a relatively brief example:  

:::{.content-visible  unless-format="typst"}

```{julia}
?for
```
:::

:::{.content-hidden unless-format="typst"}

::: {.cell }
```{.julia .cell-code}
?for
```

::: {.cell-output .cell-output-stdout}
```
search: for nor xor foldr floor Core sort

  for

  for loops repeatedly evaluate a block of statements while iterating over a sequence of values.

  The iteration variable is always a new variable, even if a variable of the same name exists in the enclosing scope. Use outer to reuse an existing local variable for iteration.

  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 `=`. 

```{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 
where every object has a type. Among the fundamental types are:


- Integers
- Floating-point numbers
- Strings 
- 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 typed 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 adds a line break at the end; `print()` does not.
```{julia}
print(y)
print("...the line continues...")
print("still...")
println(y)
println("New line")
println("New line")
```

Both functions can accept a list of string literals 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 escape it with a *backslash*. To print a *backslash* itself, 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 a `return` statement.
```{julia}
function hypotenuse(a, b)    # a bit cumbersome
    c2 = a^2 + b^2
    c  = sqrt(c2)
    return c 
end
```
After definition, the function can be used (called). The variables `a,b,c,c2` used in the definition are local and 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  one-liners:
```{julia}
hypotenuse(a, b) = sqrt(a^2+b^2)
```


## Tests
Tests return a Boolean value (`true` or `false`). 
```{julia}
x = 3^2
x < 2^3
```
In addition to the usual arithmetic comparisons `==, !=, <, <=, >, >=` 
there are many other tests. 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")
```


## Conditional Statements

A simple `if` statement has the form
```default
if <test> 
    <statement1> 
    <statement2>
    ...
end
``` 

There can be one or more `elseif` blocks and an optional final `else` block.
```{julia}
x = sqrt(100)

if x > 20
    println("Strange!")
else
    println("OK")
    y = x + 3
end    
```

Indentation enhances readability but is optional. Line breaks separate statements, as do semicolons. The code above is equivalent to the following single 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    
```



## Simple `for` loops

`for` loops for repeating the 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
One-dimensional arrays (vectors) are a simple container type. They can be created with square brackets
and accessed by index, with indexing starting 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" }

## Appendix: 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
```
:::