1.1. Julia as a calculator

1.1.1. Arithmetics

• The first thing to try in Julia is the evaluation of arithmetic expressions:

123.4 + 234.5     # This is a comment, ignored by Julia

357.9

7 / 3             # Integer division returns floating point

2.3333333333333335

7 ÷ 3             # Truncated integer division (type \div and press tab)

2

7 % 3             # Remainder

1

2^7 - 4           # All integer expression which returns an integer

124

3 * (4.2 - 9.7)   # Use parentheses to control the order of operations

-16.499999999999996

# We will later learn why the previous result is not exact

5.6e7 ^ 0.1       # Scientific notation, means 5.6⋅10⁷ (not e⁷)

5.954136718963118

1.1.2. Multiple lines in a cell

• Note that if you have many lines in a cell, the Julia notebook only displays the output of the last:

1 + 2
34 / 3

11.333333333333334

• You can suppress the output by ending the line with a semi-colon, and you can use the println function to get more control over what is shown in the output, including descriptive text:

println(1 + 2.1)
println("The result is ", -123 / 1000000)
34 / 3; # The output will not be displayed

3.1
The result is -0.000123

1.1.3. Primitive numeric data types

• The previous examples showed that Julia often automatically chooses the right data type for numbers (e.g. integers or floating point numbers)

• However, it is often useful to know what types are used, and to choose them manually

• Use the typeof function to find the type of a value:

typeof(1.23)

Float64

typeof(-745)

Int64

typeof(1e20)

Float64

1.1.3.1. Integer types

These are Julia’s so-called primitive integer types:

Type	Signed?	Number of bits	Smallest value	Largest value
Int8	✓	8	-2^7	2^7 - 1
UInt8		8	0	2^8 - 1
Int16	✓	16	-2^15	2^15 - 1
UInt16		16	0	2^16 - 1
Int32	✓	32	-2^31	2^31 - 1
UInt32		32	0	2^32 - 1
Int64	✓	64	-2^63	2^63 - 1
UInt64		64	0	2^64 - 1
Int128	✓	128	-2^127	2^127 - 1
UInt128		128	0	2^128 - 1
Bool	N/A	8	false (0)	true (1)

You can find the minimum and maximum representable values of primitive numeric types using the typemin and typemax functions:

println(typemin(Int64))
println(typemax(Int64))
println(typemin(Int128))
println(typemax(Int128))

-9223372036854775808
9223372036854775807
-170141183460469231731687303715884105728
170141183460469231731687303715884105727

By default, Julia on a 64-bit system uses Int64 for integers. This can result in overflow for large numbers. Consider for example the computation of \(1000^7\):

1000^7

3875820019684212736

which is clearly completely wrong. But this particular number can be represented by an Int128 (or floating-point types):

Int128(1000)^7

1000000000000000000000

1.1.3.2. Floating point types

These are Julia’s primitive floating-point types:

Type	Precision	Number of bits
Float16	half	16
Float32	single	32
Float64	double	64

We will learn more about the term precision later on, but for now it is enough to know that

• The default floating point type is Float64, or double precision

• Double precision represents about 16 decimal digits of a number

• The largest and smallest double precision positive numbers are about \(10^{308}\) and \(10^{-308}\)

1.1.4. Arithmetic operations and order of operations

Expression	Name	Description
+x	unary plus	the identity operation
-x	unary minus	maps values to their additive inverses
x + y	binary plus	performs addition
x - y	binary minus	performs subtraction
x * y	times	performs multiplication
x / y	divide	performs division
x ÷ y	integer divide	x / y, truncated to an integer
x \ y	inverse divide	equivalent to y / x
x ^ y	power	raises x to the yth power
x % y	remainder	equivalent to rem(x,y)

• Order of operations:

  • Parentheses

  • Power

  • Multiplication / division

  • Addition / subtraction

• Operators with the same precedence are evaluated from left to right (except exponentiation)

• For example: 360 / 2*pi evaluates to 180 * pi

• Use parentheses if you want 360 / (2*pi)