Summary
This chapter covers visualizing functions of two or three variables through contour plots and 3D surface plots to analyze level curves, gradients, and critical points.

General domain of usage
Scientific computing

Visualizing functions of two or three variables is essential for understanding their behavior. The most common methods are contour plots and 3D surface plots. **Contour plots** show **level curves** – lines where the function takes a constant value – helping you see how the function changes in different directions. **Surface plots** give a three-dimensional view, allowing you to observe peaks, valleys, and saddle points.

To interpret a contour plot, follow these steps:
1. Identify the axes, which represent the variables (such as $$x$$ and $$y$$);
2. Note the contour lines, each corresponding to a specific function value;
3. Observe the spacing between contours: closely spaced lines indicate rapid change, while widely spaced lines show gradual change;
4. Look for patterns: closed curves may indicate local maxima or minima, while lines that never close may suggest a saddle or ridge;
5. Compare with the surface plot to see how these level curves translate into rises and dips on the surface.

**Level curves** are especially useful for understanding gradients and optimization, as they highlight where the function remains constant and where it changes most rapidly.

import numpy as np
import matplotlib.pyplot as plt

# Define a sample function of two variables
def f(x, y):
    return np.sin(x) * np.cos(y)

# Create a grid of x and y values
x = np.linspace(-3 * np.pi, 3 * np.pi, 100)
y = np.linspace(-3 * np.pi, 3 * np.pi, 100)
X, Y = np.meshgrid(x, y)
Z = f(X, Y)

# Create a contour plot
plt.figure(figsize=(8, 6))
contour = plt.contour(X, Y, Z, levels=20, cmap="viridis")
plt.clabel(contour, inline=True, fontsize=8)
plt.title("Contour Plot of f(x, y) = sin(x) * cos(y)")
plt.xlabel("x")
plt.ylabel("y")
plt.show()

# Create a 3D surface plot
from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure(figsize=(10, 7))
ax = fig.add_subplot(111, projection="3d")
surf = ax.plot_surface(X, Y, Z, cmap="viridis", edgecolor="none", alpha=0.8)
ax.set_title("Surface Plot of f(x, y) = sin(x) * cos(y)")
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_zlabel("f(x, y)")
fig.colorbar(surf, shrink=0.5, aspect=5)
plt.show()

import unittest
import ast
import re
import io
import sys
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt

class TestTask(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        plt.clf()
        cls.original_show = plt.show
        plt.show = lambda *a, **k: None

        with open('user_code.py', 'r') as f:
            code = f.read()

        ns = {}
        try:
            exec(code, ns)
        except Exception:
            pass

        cls.fig = plt.gcf()
        cls.ax = plt.gca()

    @classmethod
    def tearDownClass(cls):
        plt.show = cls.original_show

    def test_contour_plot_created(self):
        _dynamic_test(
            self,
            len(self.ax.collections) > 0,
            "Contour plot is created successfully.",
            "No contour plot was created on the axes. Make sure to use plt.contour().",
        )

    def test_contour_levels(self):
        n_paths = sum([len(c.get_paths()) for c in self.ax.collections if hasattr(c, 'get_paths')])
        _dynamic_test(
            self,
            n_paths >= 8,
            "Contour levels are properly set.",
            f"Expected around 10 contour levels, but found too few. Check the 'levels' parameter.",
        )

    def test_axis_labels_and_title(self):
        xlabel = self.ax.get_xlabel()
        ylabel = self.ax.get_ylabel()
        title = self.ax.get_title()
        
        _dynamic_test(
            self,
            xlabel == "x" and ylabel == "y",
            "Axis labels 'x' and 'y' are set correctly.",
            f"Axis labels are incorrect: x='{xlabel}', y='{ylabel}'",
        )
        _dynamic_test(
            self,
            "contour plot" in title.lower(),
            "Plot title is set correctly.",
            f"Plot title is incorrect: '{title}'",
        )

    def test_contour_lines_labeled(self):
        texts = [t.get_text() for t in self.ax.texts]
        _dynamic_test(
            self,
            len(texts) > 0,
            "Contour lines are labeled successfully.",
            "No contour line labels found on the plot. Make sure to use plt.clabel().",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]
    if not assign_nodes:
        return code
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True
    return chr(10).join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()

test_main.py

Dive into the essential concepts of multivariate calculus, focusing on the tools and techniques most relevant for data science. This course builds on your linear algebra knowledge and prepares you for advanced topics in probability, statistics, and optimization.

Comprehensive exploration of multivariate calculus concepts and their applications in data science.

Visualizing Multivariate Functions

Oplossing