Learn the basics of maths and geometry, so we can represent concepts like positions and distances between objects in our worlds.

Posted

We want to start simulating basic world which we can imagine our objects existing in. To do this, we will need to represent concepts like positioning, distance andÂ movement.

This and the following chapter underpins the minimal topics in maths that we need in order to start to model theseÂ relationships.

We'll cover some fundamental arithmetic and then move onto basic geometry. Finally, we'll see how we can apply what we've learnt to determine how far away two objects are in a 2D or 3DÂ world.

Exponentiation is the process of "raising" a number to the power of another number. We can think of it as multiplying a number by itself, multipleÂ times.

The number we start with is called the "base", and the number of times it is multiplied by itself is called the "power", or the "exponent". ForÂ example:

- $2$ to the power of $2$ is equivalent to $2 \times 2$, which is equal to $4$
- $2$ to the power of $3$ is equivalent to $2 \times 2 \times 2$, which is equal to $8$
- $3$ to the power of $2$ is equivalent to $3 \times 3$, which is equal to $9$

We generally represent this operation with a *superscript* notation, forÂ example:

- $2$ to the power of $2$ is written as $2^2$
- $2$ to the power of $3$ is written as $2^3$
- $3$ to the power of $2$ is written as $3^2$

The most common form of exponentiation we will see is raising a number to the power of $2$, for example, $5^2$.

An operation like this, where the exponent is $2$, is commonly called *squaring*. The result of such an operation is called the *square* of the baseÂ number.

For example, the *square* of $5$ is $25$, because $5^2 = 25$.

In the order of operations, exponentiation happens before multiplication, but after brackets / parentheses. ForÂ example:

- $2 \times 2^2 = 2 \times 4 = 8$
- $(2 \times 2)^2 = 4^2 = 16$

Finding the *square root* of a number is, in effect, reversing the process of squaring. For example, the square root of 25 is the number that, if squared, would result inÂ 25.

In other words, the square root of $25$ is the value of $x$ such that $x^2 = 25$. We saw, from the previous section, that an answer is $5$, because $5^2 = 25$. Therefore, the square root of $25$ is $5$

Square roots are often denoted using the *radical* sign, which looks like this: $\sqrt{25}$

Expressions of any length can appear under a radical sign. That expression should be resolved before calculating the square root. For example: $\sqrt{50 + 25 \times 2} = \sqrt{100} = 10$

You may have noted that our earlier equation, $x^2 = 25$, has multiple possibleÂ solutions:

- $5^2 = 25$
- $-5^2 = 25$

This means that both $5$ and $-5$ are solutions (or roots) to the equation $x^2 = 25$.

Most commonly, we are only looking for the *positive* root, sometimes also called the *principal* root. When using the radical notation, such as $\sqrt{25}$, the *only* solution is the positiveÂ root.

- $\sqrt{25} = 5$
- $\sqrt{25} \neq -5$

We can think of virtual worlds as **spaces**. In maths and physics, a space contains a collection of objects that obey pre-defined structure and rules. Typically, the structure and rules we want to implement mirror those we are most familiar with in the realÂ world.

That means we will be interested in things like the distance between objects, and rules that govern how objects can move around theÂ space.

The most basic object that exists within spaces are points. We can model more complex objects by creating a collection of such points - for example, a triangle could be defined by 3 points - one for each of its corners. A full 3D monster, created by an artist, could have thousands of points to define it'sÂ shape.

The most important property we care about when it comes to these points is what their current *position* is within the space. We can implement the concept of position by imagining our space as aÂ grid.

For now, we will work with a two-dimensionalÂ space:

The system we most commonly use to define positions in a space is a coordinate system. The most useful system is the Cartesian coordinateÂ system.

We can set up this system by placing an axis along each dimension. Conventionally, we call the horizontal axis the $x$ axis, and the vertical axis the $y$Â axis.

With the axes set up, we can now define each point by a collection of numbers - one for each dimension the space has. In a two-dimensional space, each point will have two values - one for its position along the $x$ axis, and one for it's positiong along $y$Â .

In the above example, Point $A$'s $x$ component is $3$, and it's $y$ component is $4$. We can write this point as $A = (3, 4)$.

In our lessons on classes and structs, we saw how we might refer to the collection of all the components required to represent a point as being a *vector*.

In C++, we modelled the idea of a vector using a struct, which then let us access each individual component using the `.`

Â operator.

For example, `A.x`

is how we would access to the `x`

component of a vector called `A`

. Outside of code, it's common to use subscript notation, such as $A_x$.

We could also describe the point as $x_A$ if we preferred. Notation in maths and physics is less strict than code - we can choose whatever format we think best communicates our thoughts. The important thing is just to beÂ consistant.

In a cartesian coordinate system, the point that all the axes intersect is referred to the *origin*. The origin has a value of 0 in every dimension, and can generally be considered the centre of theÂ space.

In the previous example, point $B$ is at the origin of our space, as $B = (0, 0)$. The origin is also sometimes denoted by the letter $O$.

When two lines intersect, they form *angles*. On diagrams, angles of interest are marked using a circular segment between two intersectingÂ lines:

Angles are commonly measured in degrees, which is denoted by number followed by the degree sign: $\degree$

The wider an angle, the more degrees itÂ has.

A complete turn is $360\degree$ and a quarter turn is $90\degree$

A $90\degree$ angle is often referred to as a right angle and, on diagrams, is commonly denoted by a squareÂ icon:

A right-angled triangle is a triangle where two of the sides are perpendicular to each other, forming a rightÂ angle.

Right-angled triangles tend to be illustrated with a square in the rightÂ angle.

The side opposite this angle is referred to as the hypotenuse, and will be the longest side of theÂ triangle.

Right angle triangles and their properties are useful to know, as many problems we encounter can be modeled as right-angledÂ triangles.

For example, we can imagine any two points in our space as forming the hypotenuse of a right angle triangle. Below, we illustrate this with point $A$ and theÂ origin.

By understanding this situation as involving a right angle triangle, we can use the properties of right angle triangles to work out the distance between our twoÂ points.

This has many uses - for example, it is the basis of determining whether or not a monster is in range of ourÂ attacks.

We can use the Pythagorean Theorem to work out thisÂ distance.

The pythagorean theorem allows us to calculate the length of a right-angled triangle's hypotenuse if we know the length of its two otherÂ sides.

For example, lets imagine we know the lengths of the two smaller sides, $a$ and $b$, and wanted to work out the length of the longest side, the hypotenuse $h$

The pythagorean theorem statsÂ that:

$h = \sqrt{a^2 + b^2}$

Let's apply it to find out how far away point $A$ is from theÂ origin:

If we wanted to know how far away point $A$ is from the origin, that is equivalent to finding the length of the highlightedÂ hypotenuse.

So, lets apply the pythagoreanÂ theorem:

$\begin{align}
h &= \sqrt{3^2 + 4^2} \\
&= \sqrt{9 + 16} \\
&= \sqrt{25} \\
&= 5
\end{align}$

So, point $A$ is $5$ units away from theÂ origin.

The pythagorean theorem is particularly useful when dealing with spaces, because we always know the length of the smaller sides of our right angleÂ triangle.

They are the values of our co-ordinates, so we can just apply the same pattern with differentÂ inputs.

Lets imagine we have the point $(6,8)$. How far away is it from theÂ origin?

$\begin{align}
h &= \sqrt{6^2 + 8^2} \\
&= \sqrt{36 + 64} \\
&= \sqrt{100} \\
&= 10
\end{align}$

Any situation where we're applying the same process, only with different numbers, might get our programmer senses tingling. This sounds a lot like a function, and we'll be creating it in the nextÂ lesson.

It is not especially useful to know how far away an object is from the origin. More often, we will want to know how far away our object is from some otherÂ object.

The technique using the pythagorean theorem applies to this situation, too. We can create a right angled triangle from any twoÂ points:

In this example, the side lengths of our right angle triangle have a length of $3$ and $7$, so we can calculate how far apart point $A$ and $B$Â are.

$\begin{align}
h &= \sqrt{5^2 + 3^2} \\
&= \sqrt{25 + 9} \\
&= \sqrt{34} \\
&\approx 5.8
\end{align}$

Whilst the selection of the $5$ and $3$ may have seemed intuitive by looking at a our diagram, we generally won't have a visual representation to workÂ from.

We also want to write code that will work with any input points, therefore, it is worth detailing how we would come to these values in a more generalÂ case.

For example, $A$ and $B$ will just be points passed to our function. We don't know their position ahead of time - we have to work it out. So how would we get the values that were, in this case, $5$ and $3$?

- We took the $x$ coordinate of point $B$ and subtracted the $x$ coordinate of point $A$. That gave us $7 - 2$
- We took the $y$ coordinate of point $B$ and subtracted the $y$ coordinate of point $A$. That gave us $4 - 1$

In other words, we did $x_\text{B} - x_\text{A}$ and $y_\text{B} - y_\text{A}$ to get the two sides of our right angledÂ triangle.

This allows us to expand the pythagorean theorem to a new formula, to calculate the distance between any two points. Lets call our points $A$ and $B$ and, for now, we'll assume we're working in a two-dimensionalÂ space:

$\sqrt{(x_\text{A} - x_\text{B})^2 + (y_\text{A} - y_\text{B})^2}$

This formula is sometimes referred to as the *distance formula*.

Something to note about this formula is that it does not matter which point you choose to be $A$ and which is $B$. The only effect this choice will have will be to determine whether the result of $x_\text{A} - x_\text{B}$ is negative orÂ positive.

However, that result is being immediately squared, so the sign will be discarded anyway. Squaring a number will give the same result whether that number is negative orÂ positive.

This is because multiplying two negative numbers together will always result in a positive number. For example, $5^2$ and $-5^2$ are both $25$.

Therefore, $(x_\text{A} - x_\text{B})^2$ will always be positive, so it doesn't matter which point is chosen to be $A$ and which is chosen to be $B$.

The examples above used two-dimensions in their examples and illustrations, but the techniques apply to three dimensional worldsÂ too.

In cartesian co-ordinate systems, the 3rd dimension is generally identified by the letter $z$, to give co-ordinates $(x, y, z)$. The origin of a three-dimensional cartesian space is $(0, 0, 0)$

The pythagorean theorem expands to three dimensions. To calculate how far a three-dimensional point $(x, y, z)$ is from the origin, we can useÂ this:

$\sqrt{x^2 + y^2 + z^2}$

Similarly, the distance formula also expands to three dimensions. To calculate the distance between point $A$ with coordinates $(x_\text{A}, y_\text{A}, z_\text{A})$ and point $B$ with coordinates $(x_\text{B}, y_\text{B}, z_\text{B})$ we can useÂ this:

$\sqrt{(x_\text{A} - x_\text{B})^2 + (y_\text{A} - y_\text{B})^2 + (z_\text{A} - z_\text{B})^2}$

Posted

This lesson is part of theÂ course:### Intro to C++ Programming

Become a software engineer with C++. Starting from the basics, we guide you step by step along the way