Apply a **scaling transformation** and a **90° rotation** to a 2D vector using Python and matrix multiplication. Visualize the result with arrows and coordinate labels from the origin.

You're working with a vector:

$$
\vec{v} = \begin{bmatrix}2 \\ 3\end{bmatrix}
$$

You will:
1. Apply a scaling matrix:

   $$
   S = \begin{bmatrix}2 & 0 \\ 0 & 0.5\end{bmatrix}
   $$	 

2. Apply a rotation matrix:

   $$
   R = \begin{bmatrix}2 \\ 3\end{bmatrix}
   $$	 

3.	Combine them as:

$$
R \cdot (S \cdot \vec{v})
$$
	 
This simulates what happens when a vector is first scaled and then rotated.

import unittest
import numpy as np
import user_code  # ÐºÐ¾Ð´ ÑÑÑÐ´ÐµÐ½ÑÐ°

def _dynamic(tc, ok, ok_msg, fail_msg):
    tc._testMethodName = ok_msg if ok else fail_msg
    (tc.assertTrue if ok else tc.fail)(tc._testMethodName)

RTOL = 1e-7
ATOL = 1e-7

class TestCombinedTransformations(unittest.TestCase):

    def test_base_objects(self):
        reasons = []

        v = getattr(user_code, "v", None)
        S = getattr(user_code, "S", None)
        R = getattr(user_code, "R", None)

        # ÐÐµÑÐµÐ²ÑÑÐºÐ° Ð½Ð°ÑÐ²Ð½Ð¾ÑÑÑ ÑÐ° ÑÐ¾ÑÐ¼
        if not (isinstance(v, np.ndarray) and v.shape == (2,1)):
            reasons.append(f"v must be a (2,1) array; got {None if v is None else v.shape}")
        if not (isinstance(S, np.ndarray) and S.shape == (2,2)):
            reasons.append(f"S must be a (2,2) array; got {None if S is None else S.shape}")
        if not (isinstance(R, np.ndarray) and R.shape == (2,2)):
            reasons.append(f"R must be a (2,2) array; got {None if R is None else R.shape}")

        # ÐÑÑÐºÑÐ²Ð°Ð½Ñ Ð·Ð½Ð°ÑÐµÐ½Ð½Ñ Ð·Ð° ÑÐ¼Ð¾Ð²Ð¾Ñ
        v_exp = np.array([[2.0],[3.0]])
        S_exp = np.array([[2.0, 0.0],
                          [0.0, 0.5]])
        # ÐÐ»Ñ R Ð¾ÑÑÐºÑÑÐ¼Ð¾ 90Â° CCW: [[0,-1],[1,0]] Ð· Ð¼Ð¾Ð¶Ð»Ð¸Ð²Ð¾Ñ Ð¿Ð¾ÑÐ¸Ð±ÐºÐ¾Ñ
        R_exp = np.array([[0.0, -1.0],
                          [1.0,  0.0]])

        if isinstance(v, np.ndarray) and v.shape == (2,1) and not np.allclose(v, v_exp, rtol=RTOL, atol=ATOL):
            reasons.append(f"v values incorrect; expected {v_exp.ravel().tolist()}, got {v.ravel().tolist()}")
        if isinstance(S, np.ndarray) and S.shape == (2,2) and not np.allclose(S, S_exp, rtol=RTOL, atol=ATOL):
            reasons.append(f"S values incorrect; expected {S_exp.tolist()}, got {S.tolist()}")
        if isinstance(R, np.ndarray) and R.shape == (2,2) and not np.allclose(R, R_exp, rtol=1e-6, atol=1e-6):
            reasons.append(f"R should be 90Â° CCW rotation; expected approx {R_exp.tolist()}, got {R.tolist()}")

        _dynamic(self,
                 len(reasons) == 0,
                 "PASS: base objects (v, S, R) are correct",
                 "FAIL: " + " | ".join(reasons) if reasons else "FAIL")

    def test_scaled_vector(self):
        reasons = []

        v = getattr(user_code, "v", None)
        S = getattr(user_code, "S", None)
        scaled_v = getattr(user_code, "scaled_v", None)

        if not (isinstance(scaled_v, np.ndarray) and scaled_v.shape == (2,1)):
            reasons.append(f"scaled_v must be a (2,1) array; got {None if scaled_v is None else scaled_v.shape}")
        else:
            exp_scaled = S @ v
            if not np.allclose(scaled_v, exp_scaled, rtol=RTOL, atol=ATOL):
                reasons.append(f"scaled_v != S @ v; expected {exp_scaled.ravel().tolist()}, got {scaled_v.ravel().tolist()}")

        _dynamic(self,
                 len(reasons) == 0,
                 "PASS: scaled_v equals S @ v",
                 "FAIL: " + " | ".join(reasons) if reasons else "FAIL")

    def test_rotated_vector(self):
        reasons = []

        R = getattr(user_code, "R", None)
        scaled_v = getattr(user_code, "scaled_v", None)
        rotated_v = getattr(user_code, "rotated_v", None)

        if not (isinstance(rotated_v, np.ndarray) and rotated_v.shape == (2,1)):
            reasons.append(f"rotated_v must be a (2,1) array; got {None if rotated_v is None else rotated_v.shape}")
        else:
            exp_rot = R @ scaled_v
            if not np.allclose(rotated_v, exp_rot, rtol=1e-6, atol=1e-6):
                reasons.append(f"rotated_v != R @ scaled_v; expected {exp_rot.ravel().tolist()}, got {rotated_v.ravel().tolist()}")

            # ÐÐ¾Ð´Ð°ÑÐºÐ¾Ð²Ð¸Ð¹ ÑÐ¸ÑÐ»Ð¾Ð²Ð¸Ð¹ ÑÐµÐº Ð¾ÑÑÐºÑÐ²Ð°Ð½Ð¸Ñ ÐºÐ¾Ð¾ÑÐ´Ð¸Ð½Ð°Ñ (-1.5, 4)
            exp_num = np.array([[-1.5],[4.0]])
            if not np.allclose(rotated_v, exp_num, rtol=1e-6, atol=1e-6):
                reasons.append(f"rotated_v should be approximately [-1.5, 4]; got {rotated_v.ravel().tolist()}")

        _dynamic(self,
                 len(reasons) == 0,
                 "PASS: rotated_v equals R @ scaled_v and matches expected coords",
                 "FAIL: " + " | ".join(reasons) if reasons else "FAIL")


test_code.py

Master the mathematical foundations essential for data science. Explore core concepts in functions, calculus, linear algebra, probability, and dimensionality reduction. Build both theoretical understanding and practical coding experience to strengthen your ability to analyze data, model complex systems, and apply advanced techniques in machine learning.

Explore the foundation of mathematical functions. Learn different types of algebraic and transcendental functions, their properties, and how to implement them in Python to solve real-world problems.

Master the concepts of sets and series, from basic operations to practical applications. Gain hands-on experience implementing set operations and working with arithmetic and geometric series in Python.

Develop a solid understanding of limits, derivatives, integrals, and partial derivatives. Connect theory to practice by implementing these concepts in Python and applying them to optimization through gradient descent.

Build strong knowledge of vectors, matrices, and transformations. Learn decomposition methods and eigenvalue analysis, while reinforcing concepts with Python coding challenges and practical data science applications.

Dive into probability theory and statistics. Study conditional probability, Bayes' theorem, and statistical measures. Implement key concepts in Python, simulate distributions, and strengthen your skills through challenges and quizzes.

Challenge: Combined Transformations of a Vector

Solução

Awesome!

Challenge: Combined Transformations of a Vector

Solução

Awesome!