# Basic Arithmetic

In this blog, let us see about basic arithmetic in Julia. The notebook for this blog is available here https://gitlab.com/data-science-with-julia/code/-/blob/master/artthmetic.ipynb.

First start a notebook, so first let’s do addition. Type this in a cell:

```
1 + 2
```

and execute it. As you can see `+`

sign adds two numbers and outputs the result as shown:

```
3
```

Try an other example:

```
41 + 1
```

Output:

```
42
```

Now let’s try multiplication:

```
6 * 7
```

The `*`

sign multiplies numbers at its left and right side and outputs the result as shown:

```
42
```

Now let’s try subtraction which is accomplished by `-`

sign. In the example below we are taking away 8 from 50:

```
50 - 8
```

Output:

```
42
```

Now division is done by `/`

, so this is what you get when you divide 375 by 21:

```
375 / 21
```

Output:

```
17.857142857142858
```

Now \(x^y\) in Julia can be written as `x ^ y`

, so the below example finds out 28 raised to the power of 12:

```
28 ^ 12
```

Output:

```
232218265089212416
```

For curiosity reason we will see what will happen when we add -2 and 45:

```
-2 + 45
```

Output:

```
43
```

There is a operator called mod `%`

which gives us the reminder. Lets see what’s the reminder when 21 is divided by 4:

```
21 % 4
```

Output:

```
1
```

We have seen how to get reminder, now let’s see how to get quotient of a division operation. For that we use `÷`

operator which does integer division. So look at the example below:

```
21 ÷ 4
```

Output

```
5
```

To type in `÷`

in the notebook, type `\div`

in a cell and press `Tab`

.

It’s not that one can enter only 1 statement in Jupyter lab’s cell and press `Shift + Enter`

to execute it, you can enter multiple statements by using `Enter`

key at the end of statement, then you can press `Shift + Enter`

to execute it.

In the example below, we convert 90 degree Celsius to Fahrenheit.

```
celcius = 90
fahrenheit = (9 / 5)celcius + 32
```

Output:

```
194.0
```

In the above example, first we assign value `90`

to variable named `celcius`

using this statement `celcius = 90`

. Next we compute Fahrenheit as follows `fahrenheit = (9 / 5)celcius + 32`

. Look how we can give `(9 / 5)celcius`

, Julia can find out you are trying to multiply \(9 \over 5\) with `celcius`

, it’s very much like writing an equation. Then `32`

is added to it here `(9 / 5)celcius + 32`

.

For the sake of experimentation try out this statement `fahrenheit = (9 / 5) * (celcius + 32)`

. Did you get the right answer? What went wrong?

Now try out the example below:

```
celcius = 90
fahrenheit = (9 / 5) celcius + 32
```

Output:

```
syntax: extra token "celcius" after end of expression
Stacktrace:
[1] top-level scope at In[14]:2
[2] include_string(::Function, ::Module, ::String, ::String) at ./loading.jl:1091
[3] execute_code(::String, ::String) at /home/karthikeyan/.julia/packages/IJulia/a1SNk/src/execute_request.jl:27
[4] execute_request(::ZMQ.Socket, ::IJulia.Msg) at /home/karthikeyan/.julia/packages/IJulia/a1SNk/src/execute_request.jl:86
[5] #invokelatest#1 at ./essentials.jl:710 [inlined]
[6] invokelatest at ./essentials.jl:709 [inlined]
[7] eventloop(::ZMQ.Socket) at /home/karthikeyan/.julia/packages/IJulia/a1SNk/src/eventloop.jl:8
[8] (::IJulia.var"#15#18")() at ./task.jl:356
```

Note how quickly Julia could get confused by just leaving a space between `(9/5)`

and `celcius`

, wheras you human can see its a obvious thing.

Now try this example out:

```
celcius = 90
fahrenheit = (9 / 5) * celcius + 32
```

Output:

```
194.0
```

There is a difference between how Scientists write equations and programmers program it. For example for a scientist writing `F = (9/5)C + 32`

is a good enough Julia program, but as a programmer one would absolutely hate it. A programmer would like the program to be self documenting. Hence he would like `fahrenheit = (9 / 5) * celcius + 32`

. He would like to mention `celcius`

is multiplied by `(9 / 5)`

explicitly using the `*`

operator.

For a scientist `(9/5)`

is good enough, but for a programmer its blasphemy. Programmers like to the program to be more readable. I think I need to write a blog about the way of code: Scientists Vs Programmers. `(9 / 5)`

is more readable than `(9/5)`

programmer would say.

Now consider the example below. When ever you wrap something in brackets, it get’s executed first, so in the below operation `90`

is added with `32`

in `(celcius + 32)`

giving `122`

, then this `122`

is multiplied with \(9 \over 5\) in `(9 / 5) * (celcius + 32)`

:

```
celcius = 90
farenheit = (9 / 5) * (celcius + 32)
```

Output:

```
219.6
```

You can use only round brackets `(`

and this `)`

in math iperations in Julia, curly and other brackets are strict no:

```
celcius = 90
fahrenheit = {9 / 5} * celcius + 32
```

Output:

```
syntax: { } vector syntax is discontinued around In[17]:2
Stacktrace:
[1] top-level scope at In[17]:2
[2] include_string(::Function, ::Module, ::String, ::String) at ./loading.jl:1091
[3] execute_code(::String, ::String) at /home/karthikeyan/.julia/packages/IJulia/a1SNk/src/execute_request.jl:27
[4] execute_request(::ZMQ.Socket, ::IJulia.Msg) at /home/karthikeyan/.julia/packages/IJulia/a1SNk/src/execute_request.jl:86
[5] #invokelatest#1 at ./essentials.jl:710 [inlined]
[6] invokelatest at ./essentials.jl:709 [inlined]
[7] eventloop(::ZMQ.Socket) at /home/karthikeyan/.julia/packages/IJulia/a1SNk/src/eventloop.jl:8
[8] (::IJulia.var"#15#18")() at ./task.jl:356
```

Here I am trying to use square brackets:

```
celcius = 90
fahrenheit = [9/5] * celcius + 32
```

Output:

```
MethodError: no method matching +(::Array{Float64,1}, ::Int64)
For element-wise addition, use broadcasting with dot syntax: array .+ scalar
Closest candidates are:
+(::Any, ::Any, !Matched::Any, !Matched::Any...) at operators.jl:538
+(!Matched::Missing, ::Number) at missing.jl:115
+(!Matched::Base.CoreLogging.LogLevel, ::Integer) at logging.jl:116
...
Stacktrace:
[1] top-level scope at In[18]:2
[2] include_string(::Function, ::Module, ::String, ::String) at ./loading.jl:1091
[3] execute_code(::String, ::String) at /home/karthikeyan/.julia/packages/IJulia/a1SNk/src/execute_request.jl:27
[4] execute_request(::ZMQ.Socket, ::IJulia.Msg) at /home/karthikeyan/.julia/packages/IJulia/a1SNk/src/execute_request.jl:86
[5] #invokelatest#1 at ./essentials.jl:710 [inlined]
[6] invokelatest at ./essentials.jl:709 [inlined]
[7] eventloop(::ZMQ.Socket) at /home/karthikeyan/.julia/packages/IJulia/a1SNk/src/eventloop.jl:8
[8] (::IJulia.var"#15#18")() at ./task.jl:356
```

One good thing about Julia is you can assign values to variables and construct algebric equations as follows:

```
x = 4
y = 7
3x + 4y + 27
```

Output:

```
67
```

Try breaking the above example and make it throw errors so that you would learn.

Let’s assign `12`

to `z`

as shown:

```
z = 12
```

Output:

```
12
```

Below example is the compact way of writing `z = z + 4`

, that is you are adding `4`

with `z`

, making it `16`

and assigning it to `z`

again.

**Example 1:**

```
z += 4
z
```

Output:

```
16
```

Imagine what would a mathematician think if you present an equation \(z = z+4\) :D Programmer and the way maths and science people think are very different, but data science is marriage of huge amounts of data with computer processing which run algorithms based on scientific observation and mathematics.

Since I am lazy, explain to your self what’s happening in the examples below:

**Example 2:**

```
z -= 3
z
```

Output:

```
13
```

**Example 3:**

```
z *= 17
z
```

Output:

```
221
```

**Example 4:**

```
z %= 5
```

Output:

```
1
```

**Example 5:**

```
z = 12
z ^= 2
z
```

Output:

```
144
```