Summary  
This chapter demonstrates how to define vector functions, compute their Jacobian matrix and determinant symbolically using code, and evaluate them to account for local area or volume scaling during variable transformations.  

General domain of usage  
multivariable integral transformations

**Video: Explanation of the Jacobian matrix and its role in changing variables in integrals**

This video introduces the **Jacobian matrix**, explains how it captures the local linear transformation induced by a function from one coordinate system to another, and demonstrates its critical role in changing variables in multiple integrals. And how to compute with sympy

The **Jacobian matrix** is a fundamental concept in multivariate calculus, especially when analyzing how functions transform regions in space. Suppose you have a transformation from variables $$x, y$$ to new variables $$u, v$$ defined by two functions:

$$
u = f(x, y)\\
v = g(x, y)
$$

The **Jacobian matrix** of this transformation is the matrix of all first-order partial derivatives:

$$
J = \begin{bmatrix}
\frac{\partial u}{\partial x} & \frac{\partial u}{\partial y} \\
\frac{\partial v}{\partial x} & \frac{\partial v}{\partial y}
\end{bmatrix}
$$

The **determinant** of this matrix, called the **Jacobian determinant**, measures how areas (or volumes in higher dimensions) are scaled by the transformation at each point. When changing variables in a double integral, the absolute value of the Jacobian determinant adjusts for the stretching or shrinking caused by the transformation.

**Example:**
let's say you have the transformation:

$$
u = x + y\\
v = x - y
$$

The Jacobian matrix is:

$$
J = \begin{bmatrix}
\frac{\partial u}{\partial x} & \frac{\partial u}{\partial y} \\
\frac{\partial v}{\partial x} & \frac{\partial v}{\partial y}
\end{bmatrix}
=
\begin{bmatrix}
1 & 1 \\
1 & -1
\end{bmatrix}
$$

The Jacobian determinant is:

$$
|J| = (1)(-1) - (1)(1) = -2
$$

This means that at any point, the transformation scales areas by a factor of 2 (the sign indicates orientation).

import sympy as sp
import numpy as np

# 1. Define the symbolic variables
x, y = sp.symbols('x y')

# 2. Define our functions as a matrix
funcs = sp.Matrix([x**2 + y, x - y**2])

# 3. Compute the Jacobian symbolically (this replaces the custom jacobian_matrix function)
J_sym = funcs.jacobian([x, y])

# 4. Substitute the values x=1.0, y=2.0
J_eval = J_sym.subs({x: 1.0, y: 2.0})

# Print the results
print("Jacobian matrix at (1, 2):")
print(np.array(J_eval, dtype=float))  # Convert to a numpy array for a standard display format

print("\nJacobian determinant at (1, 2):")
print(float(J_eval.det()))

import unittest
import ast
import re
import io
import sys
import sympy as sp
import numpy as np

class TestTask(unittest.TestCase):
    def test_default_values(self):
        with open('user_code.py', 'r') as f:
            code = f.read()
            
        ns = {}
        try:
            exec(code, ns)
            J = ns.get('J')
            
            # Очікувані аналітичні значення для h(x,y)=x*sin(y), k(x,y)=y*cos(x)
            # dh/dx = sin(y)
            # dh/dy = x*cos(y)
            # dk/dx = -y*sin(x)
            # dk/dy = cos(x)
            # У точці (1.0, 0.5)
            expected = np.array([
                [np.sin(0.5), 1.0 * np.cos(0.5)],
                [-0.5 * np.sin(1.0), np.cos(1.0)]
            ], dtype=float)
            
            is_correct = isinstance(J, np.ndarray) and J.shape == (2, 2) and np.allclose(J, expected, atol=1e-5)
        except Exception:
            is_correct = False
            J = None
            
        _dynamic_test(
            self,
            is_correct,
            "Correctly computes the exact Jacobian matrix at (1.0, 0.5).",
            f"Expected the numpy array: {expected}; Got: {J}",
        )

    def test_dynamic_values(self):
        with open('user_code.py', 'r') as f:
            code = f.read()
            
        code = change_var(code, 'x_val', '2.0')
        code = change_var(code, 'y_val', '1.0')
        
        ns = {}
        try:
            exec(code, ns)
            J = ns.get('J')
            
            # У точці (2.0, 1.0)
            expected = np.array([
                [np.sin(1.0), 2.0 * np.cos(1.0)],
                [-1.0 * np.sin(2.0), np.cos(2.0)]
            ], dtype=float)
            
            is_correct = isinstance(J, np.ndarray) and J.shape == (2, 2) and np.allclose(J, expected, atol=1e-5)
        except Exception:
            is_correct = False
            
        _dynamic_test(
            self,
            is_correct,
            "Jacobian computation works dynamically for other points.",
            "Failed to evaluate dynamically. Ensure you used the variables x_val and y_val in your .subs() method.",
        )

    def test_used_sympy_jacobian(self):
        with open('user_code.py', 'r') as f:
            code = f.read()
            
        code_clean = gsub_spaces(code)
        
        used_jacobian = ".jacobian(" in code_clean
        used_subs = ".subs(" in code_clean
        
        _dynamic_test(
            self,
            used_jacobian and used_subs,
            "SymPy library functions (jacobian, subs) were utilized.",
            "Expected to find the use of SymPy's .jacobian() and .subs() methods to solve the problem analytically.",
        )

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 gsub_spaces(text):
    text = re.sub(r"\s+", "", text)
    text = text.replace("'", "")
    text = text.replace('"', "")
    return text

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.

Jacobian Matrix and Change of Variables

Oplossing