[MUSIC]

Every programming language allows you to perform basic math like addition,

subtraction, division and multiplication.

To achieve these tasks, we use operators.

An operator is a special symbol or

phrase that you used to check, change or combine values.

Operators can be separated into three categories.

Unary operators.

These operate on a single target.

We also have binary operators, ones that operate on two targets and

ternary operators, those with three targets.

We'll start with binary operators because they're ones we're most familiar with.

We've already used an operator or two in this course.

Let's look at one that I'm sure we all know.

This is the addition operator.

It is a binary operator,

because as we defined earlier, binary operators operate on two targets.

In this case, our two targets are numbers that we add together.

The values that operators affect are called operands.

So in our case, the two numbers are called operands,

a combination of an operator with operands is called an expression.

So this line of code that we see here is an expression.

There are many binary operators most of which you are familiar with

from basic math.

The one we just saw, the addition operator, where we also have

a subtraction operator, division, multiplication and a remainder operator.

When I was in school I had to learn long division.

You remember that?

Feels like forever ago.

In long division, if you divided 10 by 3,

3 would fit into 10 three times and you would get a remainder of 1.

That is what the remainder operator does, it tells us given a number and

its divisor what is the remainder that is left over.

It is sometimes also known as the modulo operator.

While the point of this operator may seem silly, it's actually quite useful.

If we took a number and a divisor 2 and use the remainder operator.

If the remainder is 0, well, now we know that this is an even number.

Those are the main binary operators we'll look at for now, they're pretty simple.

Something that's interesting to know but not at all necessary

is that these operators we looked at are called infix operators.

An infix operator is one that goes in between two operands.

All binary operators are infix operators.

So if you're confused about the syntax when writing it out,

remember that they go in between the values they're working on.

Let's start by playing around with binary operators for a bit.

We'll add another page to our playground to talk about operators first.

So like before click on the first icon in the second set here

to open up the project navigator.

And then using the plus button below, the Add button, let's add a new page.

We're going to call this one operators.

Let's add a comment in here.

We're going to talk about binary operators first.

Okay, so let's say we have the height and width of a room in feet.

Yeah, yeah, I know not everyone lives in the US and uses feet.

Don't worry, we'll work around that.

So let's create a new constant height and we'll assign it an integer value.

So say 12 and I'll add a comment, we'll say in feet.

We also need the width for this example.

So we'll say let to create a constant, width for

the name and we'll assign another integer value.

Now remember I can also explicitly write out the type like so

and we'll add another comment in saying in feet.

Now to calculate the area of the room which is a rectangle,

we can simply multiply the height and the width.

Let's do this and assign this to a constant called area.

We'll assign this new value.

So we'll say let area equal height times width.

So this is the multiplication operator, which is the asterisk symbol.

And it's a binary operator which goes in between two operands like so.

Now the unit of measurement for this is area in square feet,

now like I said we don't all use square feet.

So let's try and convert this into square meters.

Let's add another comment here.

So we'll say one square meter equal

one square foot divided by 10.764.

Okay, so to get this area in square feet

into meters square, we can create a new constant.

We'll call this areaInMeters and

we'll simply divide the area by 10.764.

Okay, when you try this, you'll see that we get an error and

this is because of a conflict between the types.

Now I don't have an error symbol over here but

you can see in my console that there is a bunch of stuff going on.

And you can bring up your console by clicking on the second icon in this set

of three, the second set.

Okay, so what's going on here?

The height and width values are of type int since they're whole numbers.

And since we're multiplying them to get a value for

area, Swift infers that the area should also be of type int.

Now we can't simply combine two types willy-nilly.

In real life you could.

You can simply divide this area which would be 120 by 10.764.

We know what to do, but the compiler doesn't.

We cannot divide an int by a value of type double

because Swift doesn't know which type the answer should be.

Should the value be an integer value?

In which case, Swift will go ahead and round off the answer and

cut off the values after the decimal point.

Or should it be a double.

Now we can solve this for Swift by changing the values for height and width

to be double by either adding decimal points or explicitly specifying the value.

So we'll say let height double, let width double.

And now everything should resolve itself.

So pretty simple stuff as you just saw, we use the multiplication and

division operators.

But it's important to know that unlike in the real world,

you have to be careful about what types you use.

You can't simply divide an integer by a double or even multiply it.

In the next video, let's take a look at some other binary operators.