Summary  
This chapter demonstrates how to numerically approximate the gradient of a multivariable function and compute its directional derivative by normalizing a given direction vector and taking the dot product with the gradient.  

General domain of usage  
Scientific computing

**Directional Derivatives and the Gradient: An Overview**

This video introduces the concept of **directional derivatives**, explains how they measure the rate of change of a multivariable function in any chosen direction, and shows how the **gradient vector** relates to the computation and interpretation of directional derivatives.

The **directional derivative** of a function describes how the function changes as you move from a point in a specific direction. For a function $$f(x, y)$$, the directional derivative at a point $$(x_0, y_0)$$ in the direction of a unit vector $$u = (a, b)$$ is given by:

$$
D_uf(x_0, y_0) = ∇f(x_0, y_0) · u = f_x(x_0, y_0)a + f_y(x_0, y_0)b
$$

Here, $$∇f(x_0, y_0)$$ is the **gradient vector** at $$(x_0, y_0)$$, $$f_x$$ and $$f_y$$ are the **partial derivatives**, and $$·$$ denotes the **dot product**. 

**Example:**

Suppose $$f(x, y) = x^2 + y^2$$ and you want the directional derivative at $$(1, 2)$$ in the direction of vector $$v = (3, 4)$$. First, normalize $$v$$ to get the unit vector $$u = (3/5, 4/5)$$. The gradient at $$(1, 2)$$ is $$(2x, 2y) = (2, 4)$$. The directional derivative is:

$$
D_uf(1, 2) = (2, 4) · (3/5, 4/5) = 2*(3/5) + 4*(4/5) = (6/5) + (16/5) = 22/5
$$

This value tells you how fast the function increases if you move from $$(1, 2)$$ in the direction $$(3, 4)$$.

import numpy as np

def gradient(f, x, h=1e-6):
    n = len(x)
    grad = np.zeros(n)
    for i in range(n):
        x_forward = np.array(x)
        x_backward = np.array(x)
        x_forward[i] += h
        x_backward[i] -= h
        grad[i] = (f(*x_forward) - f(*x_backward)) / (2 * h)
    return grad

def directional_derivative(f, x0, direction):
    direction = np.array(direction)
    unit_direction = direction / np.linalg.norm(direction)
    grad = gradient(f, x0)
    return np.dot(grad, unit_direction)

# Example usage:
# f(x, y) = x^2 + y^2
f = lambda x, y: x**2 + y**2
point = [1, 2]
direction = [3, 4]
result = directional_derivative(f, point, direction)
print(f"Directional derivative at {point} in direction {direction}: {result:.2f}")

Which statement best describes the directional derivative of a function at a point in a given direction?

Gain a solid understanding of the mathematical foundations that power machine learning, data science, and engineering. Master vectors, matrices, linear transformations, and multivariate calculus – from dot products and eigenvalues to gradients, Jacobians, and multiple integrals – building the intuition and skills needed to tackle real-world computational problems.

Build the core skills of linear algebra – from vector operations and dot products to matrix multiplication and solving linear systems – forming the backbone of modern data science and engineering.

Explore the deeper structure of linear algebra. Master inverse matrices, determinants, rank, and the powerful concept of eigenvalues and eigenvectors, with visual intuition to tie it all together.



Extend your calculus toolkit to higher dimensions. Learn to work with functions of several variables, visualize their behavior, and compute partial derivatives, gradients, and directional derivatives.

Discover how calculus and linear algebra intertwine. Apply the multivariate chain rule, work with Jacobians, expand functions using Taylor series, and evaluate multiple integrals with confidence.