Math and programming go hand in hand, especially in game development. We'll cover the core concepts throughout this chapter, starting from the basics and moving on to concepts that allow us to implement things like virtual cameras and physics systems.

In this first lesson, we're starting with the fundamentals - exponents and square roots. We'll explore how these work in C++, look at different ways to implement them, and start thinking about performance considerations. This sets the stage for the more complex math concepts we'll tackle as we move forward.

Exponents

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$ .

Order Of Operations

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$

The `cmath` Header and `std::pow()`

To access the standard library's math utilities, we need to include <cmath>:

1#include <cmath>

After including cmath or math.h, the pow function is now available within the std namespace:

main.cpp

1#include <iostream>
2#include <cmath>
3
4int main(int argc, char** argv) {
5  std::cout << "2 to the power of 3 is "
6    << std::pow(2, 3);
7  return 0;
8}

12 to the power of 3 is 8

Small Exponents

When we need to raise something to a small power, we don't need a helper function. For example, to raise a to the power of 2, it's often preferred to implement that as a * a rather than std::pow(a, 2).

Using `SDL_pow()` and `SDL_powf()`

When we're using SDL, alternatives to std::pow() are available in the form of SDL_pow(), which accepts and returns double values, and SDL_powf(), which accepts and returns float values:

main.cpp

1#include <iostream>
2#include <SDL3/SDL.h>
3#include <SDL3/SDL_main.h>
4
5int main(int argc, char** argv) {
6  std::cout << "2 to the power of 3 is "
7    << SDL_pow(2, 3);
8  std::cout << "\n3 to the power of 4 is "
9    << SDL_powf(3, 4);
10  return 0;
11}

12 to the power of 3 is 8
23 to the power of 4 is 81

Square Root

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$

Using `std::sqrt()`

To calculate square roots in our programs, the standard library includes the std::sqrt() function within <cmath>:

main.cpp

1#include <cmath>
2#include <iostream>
3
4int main(int argc, char** argv) {
5  std::cout << "The square root of 25 is "
6    << std::sqrt(25);
7  return 0;
8}

1The square root of 25 is 5

Using `SDL_sqrt()` and `SDL_sqrtf()`

Programming a computer to calculate the square root of an input variable is not as easy as it seems. Many different algorithms can be used, each with its advantages and disadvantages. SDL provides optimized implementations that favor speed over maximum precision.

The standard library's std::sqrt() function has the advantage of being highly accurate but may be slower than approximation methods. This is rarely the trade-off we want when working with graphics, particularly when we may be doing thousands of these calculations per frame.

Typically, we prefer a faster implementation that gets an approximate answer. When we're using SDL, we can use the SDL_sqrt() function, which returns and accepts double values, or SDL_sqrtf(), which returns and accepts float values:

main.cpp

1#include <SDL3/SDL.h>
2#include <SDL3/SDL_main.h>
3#include <iostream>
4
5int main(int argc, char** argv) {
6  std::cout << "The square root of 25 is "
7    << SDL_sqrt(25.0);
8  std::cout << "\nThe square root of 36 is "
9    << SDL_sqrtf(36.0f);
10  return 0;
11}

1The square root of 25 is 5
2The square root of 36 is 6

Multiple Roots

You may have noted that equations like $x^2 = 25$ have multiple possible solutions:

$5^2 = 5 \times 5 = 25$
$(-5)^2 = -5 \times -5 = 25$

This means that both $5$ and $-5$ are solutions (or roots) to the equation $x^2 = 25$ . Such solutions are commonly denoted using the $\pm$ symbol. For example, if $x^2 = 25$ , then $x = \pm 5$ .

However, it is commonly the case that we are only looking for the positive root, sometimes also called the principal root. The radical notation, such as $\sqrt{25}$ , indicates we only want the positive root. As such, the only solution to $\sqrt{25}$ is $5$ .

Square Roots of Negative Numbers

What if we wanted to get the square root of -25? There's no real number that can be multiplied by itself to result in -25, or any other negative number.

Because of this, when we're using square root functions, we typically want to make sure that the thing we're trying to calculate the square root of is positive. If our program ever finds itself needing to get the square root of a negative number, it's likely we made a mistake in our logic somewhere.

Summary

This lesson has introduced you to implementing mathematical operations that are fundamental to game development and graphics programming.

We've covered exponentiation and square roots, exploring both the standard library implementations and the optimized SDL versions. Key takeaways:

Exponentiation involves a base number raised to a power (exponent).
The notation $a^b$ represents $a$ raised to the power of $b$ .
C++'s standard library provides std::pow() for calculating powers.
SDL's SDL_pow() and SDL_powf() functions offer performance-focused alternatives for graphics code.
Square roots are calculated with std::sqrt() in the standard library and SDL_sqrt()/SDL_sqrtf() in SDL.
SDL's math functions typically prioritize speed over maximum precision.
For simple operations like squaring, direct multiplication (e.g., x * x) is often preferred.
Be cautious with square roots of negative numbers.

Exponents and `cmath`

Exponents

Order Of Operations

The `cmath` Header and `std::pow()`

main.cpp

Small Exponents

Using `SDL_pow()` and `SDL_powf()`

main.cpp

Square Root

Using `std::sqrt()`

main.cpp

Using `SDL_sqrt()` and `SDL_sqrtf()`

main.cpp

Multiple Roots

Square Roots of Negative Numbers

Summary

Spaces, Vectors and Coordinates

Game Development with SDL3

Exponents and cmath

Exponents

Order Of Operations

The cmath Header and std::pow()

main.cpp

Small Exponents

Using SDL_pow() and SDL_powf()

main.cpp

Square Root

Using std::sqrt()

main.cpp

Using SDL_sqrt() and SDL_sqrtf()

main.cpp

Multiple Roots

Square Roots of Negative Numbers

Summary

Spaces, Vectors and Coordinates

Exponents and `cmath`

The `cmath` Header and `std::pow()`

Using `SDL_pow()` and `SDL_powf()`

Using `std::sqrt()`

Using `SDL_sqrt()` and `SDL_sqrtf()`