Basic Mathematical Functions

Overview

In this chapter you will work with the most common mathematical functions in MATLAB. You will see how these functions behave with scalars, vectors, and matrices, how to control the way MATLAB handles angles, and how to get basic numeric information such as absolute values, roots, logarithms, and summary measures like minimum and maximum.

Function calls and help

MATLAB mathematical functions are usually called with the pattern output = functionName(input). The input can be a single number, a vector, or a matrix, and the function normally acts element by element. You can always get a short description and examples for a function with help functionName or doc functionName. For instance, help sin or doc log10.

Absolute value and sign

The most basic numeric functions are those that work with number magnitude and sign. The function abs returns the magnitude of a number. For a real number this is the nonnegative distance from zero. For example:

x = [-3, 0, 4.5];
y = abs(x);         % y is [3, 0, 4.5]

You can use abs on vectors and matrices. The result has the same size as the input and each element is replaced by its absolute value.

The function sign returns the sign of each element, that is -1 for negative numbers, 0 for zeros, and 1 for positive numbers:

x = [-5, 0, 7];
s = sign(x);        % s is [-1, 0, 1]

sign is often used in algorithms where you only care about the direction of a value rather than its size.

Square roots and power functions

To compute square roots you can use sqrt. For a nonnegative real input, MATLAB returns the principal square root:

a = [0, 4, 9];
r = sqrt(a);        % r is [0, 2, 3]

You can also use more general power expressions with the .^ operator. For example, x.^0.5 is mathematically similar to sqrt(x) for nonnegative real x, and x.^3 computes cubes elementwise. The basic function power(x,y) does the same thing as x.^y.

If you pass a negative real number to sqrt, MATLAB returns a complex result. Handling complex numbers as a topic is covered separately, so here it is enough to observe that sqrt(-4) produces a result that includes the imaginary unit.

There are also specific functions for related operations. Use nthroot(x,n) to compute the real nth root of real x when that root exists, for example nthroot(8,3) returns 2.

Exponential and logarithmic functions

The natural exponential function is implemented by exp. For an input x, MATLAB computes the value of the mathematical function $e^x$, where $e` is Euler's number. For example:

x = [0, 1, 2];
y = exp(x);         % y is [1, e, e^2] numerically

Logarithms appear in many computations. MATLAB provides different logarithm functions for different bases.

The natural logarithm is given by log. It implements $\ln(x)$, the logarithm base $e$:

x = [1, exp(1), exp(2)];
y = log(x);         % y is [0, 1, 2]

For base 10 logarithms use log10, which gives $\log_{10}(x). For base 2 use log2`. These functions are useful in engineering, information theory, and when you work with data that spans several orders of magnitude:

values = [1, 10, 100, 1000];
d10 = log10(values);   % [0, 1, 2, 3]

If you need a logarithm in an arbitrary base b, you can combine functions:

x = 16;
b = 2;
log_b_x = log(x) / log(b);   % log base 2 of 16, result is 4

All basic logarithm functions require positive real inputs if you want real outputs. If you pass zero or a negative real value, you will see special values or complex results, which are discussed in more detail in other chapters.

Basic aggregate functions: min, max, sum, and product

When you have multiple values and want a single summary number, aggregate functions are useful. The most fundamental summaries are minimum, maximum, sum, and product.

To get the minimum value in a vector, use min. To get the maximum, use max:

v = [3, -1, 5, 0];
m = min(v);        % m is -1
M = max(v);        % M is 5

For matrices, min and max default to working along the first non singleton dimension, usually columns. So if A is a matrix, min(A) returns a row vector containing the minimum of each column, and max(A) returns the maximum of each column. You can also specify the dimension explicitly, for example min(A,[],2) to get the minimum of each row.

To compute the sum of elements, use sum. For a vector, sum(v) adds all elements. For a matrix, sum(A) adds each column separately. To multiply all elements together, use prod. It behaves like sum but performs multiplication instead of addition:

v = [2, 3, 4];
s = sum(v);        % s is 9
p = prod(v);       % p is 24

For matrices sum(A,2) gives a column vector of row sums, and prod(A,2) gives a column vector of row products.

Mean, median, and basic averages

When you need an average value, MATLAB provides standard statistical functions. The simplest is the arithmetic mean, computed by mean. For a vector, mean(v) returns the average of all elements. For a matrix, mean(A) computes the mean of each column, and mean(A,2) computes the mean of each row:

v = [1, 2, 3, 4];
m = mean(v);       % m is 2.5

The median, which is the middle value in a sorted list, is computed with median. This function is often more robust to outliers. For example:

x = [1, 2, 100];
m_mean   = mean(x);     % 34.3333
m_median = median(x);   % 2

For basic variability you can use std for the standard deviation and var for the variance. Both functions default to treating columns of a matrix as separate data sets.

Rounding and integer related functions

MATLAB includes functions that convert floating point numbers to integer like values in different ways. The simplest is round, which rounds to the nearest integer, with halves rounding away from zero:

x = [-2.7, -2.5, -2.4, 2.4, 2.5, 2.7];
y = round(x);    % [-3, -3, -2, 2, 3, 3]

The function floor always rounds toward negative infinity, and ceil always rounds toward positive infinity:

x = [-1.3, -0.2, 0.2, 1.3];
f = floor(x);    % [-2, -1, 0, 1]
c = ceil(x);     % [-1, 0, 1, 2]

The function fix rounds toward zero:

x = [-1.9, -1.1, 1.1, 1.9];
z = fix(x);      % [-1, -1, 1, 1]

These different rounding behaviors are useful in different situations, for example when working with indices, bins, or array sizes.

MATLAB also provides mod and rem for remainder like computations. These are covered in detail in another chapter on rounding and special values, so for now it is enough to know that mod(a,b) returns a remainder that always has the same sign as the divisor b.

Elementwise behavior with vectors and matrices

The mathematical functions in this chapter typically work elementwise for vectors and matrices. This means that for an array input, MATLAB applies the function separately to each element, and the output has the same size as the input. For example:

x = [0, 1, 2; 3, 4, 5];
y = sqrt(x);      % each entry is the square root of the corresponding entry in x
z = abs(x);       % each entry is the absolute value of x

You do not need to write loops to apply abs, sqrt, exp, log, min, max, sum, mean, or similar functions along a particular dimension. The default behavior often follows columns, and you can control the dimension by specifying it as an extra argument, such as sum(A,2) or mean(A,1).

This automatic broadcasting of functions over arrays is part of what makes MATLAB efficient and concise for numerical work.

Common combinations of basic functions

In practice, basic mathematical functions are often combined to build more complex expressions. For example, you might compute a normalized version of a vector by subtracting its mean and dividing by its standard deviation:

x = [1, 2, 3, 4, 5];
x_centered = x - mean(x);
x_scaled   = x_centered / std(x);

Or you might compute the logarithm of a sum or the square root of a product:

a = [1, 4, 9];
value = sqrt(sum(a));      % square root of the sum of elements
logsum = log10(sum(a));    % base 10 log of the sum

You can nest functions freely, as long as you keep track of the order of operations and use parentheses to make your intention clear.