Arithmetic Operations (AQA GCSE Computer Science): Revision Notes

Arithmetic operations

What are arithmetic operations?

Arithmetic operations are the basic mathematical calculations that computers can perform on numbers in your programmes. Think of them as the mathematical tools that allow your programme to do calculations, just like you would with a calculator. These operations form the foundation of most computer programmes, from simple calculators to complex games and applications.

When you write a programme, you'll use special symbols called operators to tell the computer what mathematical operation you want it to perform. Each operator has a specific job and follows particular rules about how it works.

Basic arithmetic operators

Let's start with the four arithmetic operators you're probably already familiar from maths class:

Addition (+) combines two numbers together. For example, if you want to add the values stored in variables b and c, you would write something like a ← b + c. This tells the computer to take the value in b, add the value in c to it, and store the result in variable a.

Subtraction (-) takes one number away from another. The operation x ← y - 1 would take the value stored in y, subtract 1 from it, and put the result into variable x. Remember that the order matters here - you're subtracting the second value from the first.

Multiplication (*) multiplies two numbers together. Most programming languages use the asterisk (*) symbol instead of the × symbol you might be used to from maths. So score ← score * 10 would multiply the current value of score by 10.

Division (/) divides one number by another. The operation value ← num1 / num2 divides the first number by the second. However, division can be tricky in programming because there are actually two different types!

Special division operators

Programming languages have two special types of division that you need to understand:

MOD (Modulus) is a special operator that gives you the remainder when you divide one number by another. For example, if you calculate $5 \text{ MOD } 2$, you get 1 because when you divide 5 by 2, you get 2 with a remainder of 1. This operator is incredibly useful for checking if numbers are even or odd, or for creating repeating patterns in your programmes.

DIV (Integer Division) gives you only the whole number part of a division, completely ignoring any remainder. So $5 \text{ DIV } 2$ would give you 2, because 5 divided by 2 is 2.5, but we only want the whole number part (2).

These special division operators are particularly helpful when you need to work with whole numbers only, or when you want to find patterns in data.

Understanding operator precedence

When your programme encounters a mathematical expression with multiple operations, it needs to know which operation to do first. This is where operator precedence comes in - it's like the order of operations you learned in maths.

The rule to remember is BIDMAS:

• Brackets (do anything in brackets first)
• Indices (powers and roots)
• Division and Multiplication (from left to right)
• Addition and Subtraction (from left to right)

Practical uses of MOD

The MOD operator deserves special attention because it's so useful in programming. Here are some common ways you'll use it:

Checking if a number is even or odd: Any number MOD 2 will give you 0 if the number is even, or 1 if it's odd. This is because even numbers divide perfectly by 2 (no remainder), while odd numbers always leave a remainder of 1.

Creating cycles: If you want something to repeat every few steps, MOD is perfect. For example, in a game where you want an enemy to change direction every 4 moves, you could use the move counter MOD 4.

Checking multiples: To see if one number is an exact multiple of another, use MOD. If the result is 0, then it's an exact multiple.

Introduction to relational operations

While arithmetic operations perform calculations, relational operations (also called comparison operations) compare values and give you a simple True or False answer. These are essential for making decisions in your programmes.

Equal to (=) checks if two values are exactly the same. For example, $7 = 7$ is True, but $8 = 2$ is False. In some programming languages like Python, you might see this written as == instead.

Not equal to (≠) checks if two values are different. So $7 ≠ 9$ is True (because 7 and 9 are different), but $3 ≠ (1+2)$ is False (because both sides equal 3). Different programming languages might write this as <> or !=.

Less than (<) checks if the first value is smaller than the second. For example, $4 < 7$ is True, but $4 < 4$ is False (because 4 is not less than itself - they're equal).

These comparison operations are the building blocks for creating programmes that can make decisions and respond differently based on the data they're working with.