Natuurlijk! Hier is een interactieve NumPy-tutorial over het onderwerp **Matrixbewerkingen**. Deze tutorial bevat uitleg, voorbeeldcode en oefenopdrachten met oplossingen. --- # NumPy Tutorial: Matrixbewerkingen ## Inhoud 1. Introductie tot matrices in NumPy 2. Matrix maken en bekijken 3. Basisbewerkingen op matrices 4. Geavanceerde matrixbewerkingen 5. Oefeningen --- ## 1. Introductie tot matrices in NumPy In NumPy worden matrices meestal gemaakt met de functie `np.array()`. Een matrix is een tweedimensionale array. ```python import numpy as np ``` --- ## 2. Matrix maken en bekijken ### Voorbeeld: Een eenvoudige matrix ```python A = np.array([[1, 2], [3, 4]]) print("Matrix A:\n", A) ``` ### Output: ``` Matrix A: [[1 2] [3 4]] ``` ### Eigenschappen bekijken - **Shape**: afmetingen van de matrix ```python print("Shape:", A.shape) ``` - **Type**: ```python print("Type:", type(A)) ``` --- ## 3. Basisbewerkingen op matrices ### 3.1 Optellen en aftrekken ```python B = np.array([[5, 6], [7, 8]]) print("Matrix B:\n", B) # Optellen C = A + B print("A + B:\n", C) # Aftrekken D = B - A print("B - A:\n", D) ``` ### 3.2 Vermenigvuldiging - **Elementgewijze vermenigvuldiging** ```python elementwise_product = A * B print("Elementgewijze vermenigvuldiging:\n", elementwise_product) ``` - **Matrixvermenigvuldiging** ```python matrix_product = np.dot(A, B) print("Matrixvermenigvuldiging:\n", matrix_product) ``` ### 3.3 Transponeren ```python A_transposed = A.T print("Transponering van A:\n", A_transposed) ``` --- ## 4. Geavanceerde matrixbewerkingen ### 4.1 Inversie van een matrix ```python A_inv = np.linalg.inv(A) print("Inverse van A:\n", A_inv) ``` ### 4.2 Determinant ```python det_A = np.linalg.det(A) print("Determinant van A:", det_A) ``` ### 4.3 Eigenwaarden en eigenvectoren ```python eigvals, eigvecs = np.linalg.eig(A) print("Eigenwaarden:\n", eigvals) print("Eigenvectoren:\n", eigvecs) ``` --- ## 5. Oefeningen ### Oefening 1: Maak een 3x3 matrix `M` met de getallen 1 tot 9. Bereken de transpose en de determinant. **Oplossing:** ```python M = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) print("Matrix M:\n", M) print("Transponering:\n", M.T) print("Determinant:", np.linalg.det(M)) ``` --- ### Oefening 2: Maak twee matrices `X` en `Y` van 2x2, voer elementgewijze vermenigvuldiging en matrixvermenigvuldiging uit. **Oplossing:** ```python X = np.array([[1, 2], [3, 4]]) Y = np.array([[5, 6], [7, 8]]) print("Elementgewijze vermenigvuldiging:\n", X * Y) print("Matrixvermenigvuldiging:\n", np.dot(X, Y)) ``` --- ### Oefening 3: Bereken de inverse van de matrix `A` uit het voorbeeld en controleer of `A * A_inv` de identiteit is. **Oplossing:** ```python A = np.array([[4, 7], [2, 6]]) A_inv = np.linalg.inv(A) identity = np.dot(A, A_inv) print("A:\n", A) print("Inverse van A:\n", A_inv) print("Product A * A_inv:\n", identity) ``` --- ## Samenvatting - Matrixbewerkingen in NumPy zijn krachtig en eenvoudig. - Je kunt matrices maken met `np.array()`. - Basisbewerkingen zoals optellen, aftrekken, en vermenigvuldigen worden direct ondersteund. - Voor geavanceerde bewerkingen zoals inverse, determinant en eigenwaarden gebruik je functies uit `np.linalg`. --- Heeft u nog verdere vragen of wilt u de tutorial uitbreiden?

Absoluut! Hier is een interactieve NumPy tutorial over matrixbewerkingen, compleet met uitleg, voorbeeldcode en oefeningen. # NumPy Tutorial: Matrixbewerkingen ## Inleiding Matrixbewerkingen vormen de kern van wetenschappelijke computing en data-analyse. NumPy biedt krachtige tools om hiermee te werken. Laten we beginnen! ### 1. Importeren en Basissetup ```python import numpy as np # Basis matrices aanmaken A = np.array([[1, 2], [3, 4]]) B = np.array([[5, 6], [7, 8]]) print("Matrix A:") print(A) print("\nMatrix B:") print(B) ``` ### 2. Elementgewijze Bewerkingen ```python # Optelling (elementgewijs) som = A + B print("A + B:") print(som) # Vermenigvuldiging (elementgewijs) product = A * B print("\nA * B (elementgewijs):") print(product) ``` ### 3. Matrixvermenigvuldiging ```python # Echte matrixvermenigvuldiging matrix_product = np.dot(A, B) # Alternatief: A @ B (Python 3.5+) print("Matrixvermenigvuldiging A · B:") print(matrix_product) ``` ### 4. Transponeren en Determinant ```python # Transponeren A_transpose = A.T print("Getransponeerde van A:") print(A_transpose) # Determinant det_A = np.linalg.det(A) print(f"\nDeterminant van A: {det_A:.2f}") ``` ### 5. Inverse Matrix ```python # Inverse matrix (indien mogelijk) try: A_inv = np.linalg.inv(A) print("Inverse van A:") print(A_inv) # Controleren: A · A⁻¹ = I identity_check = np.dot(A, A_inv) print("\nControle (A · A⁻¹):") print(identity_check.round(3)) # Afronden voor leesbaarheid except np.linalg.LinAlgError: print("Matrix is singulier, geen inverse mogelijk") ``` ### 6. Eigenwaarden en Eigenvectoren ```python # Eigenwaarden en eigenvectoren eigenwaarden, eigenvectoren = np.linalg.eig(A) print("Eigenwaarden van A:") print(eigenwaarden) print("\nEigenvectoren van A:") print(eigenvectoren) ``` ## Oefenopdrachten ### Opdracht 1: Basisbewerkingen ```python # Gegeven: C = np.array([[2, -1], [0, 3]]) D = np.array([[1, 4], [-2, 1]]) # Bereken: # 1. C + D # 2. C - D # 3. Elementgewijs product # 4. Matrixproduct C·D ``` ### Opdracht 2: Geavanceerde Bewerkingen ```python # Gegeven: E = np.array([[3, 1], [1, 2]]) # Bereken: # 1. Determinant van E # 2. Inverse van E # 3. Eigenwaarden van E # 4. E² (E · E) ``` ### Opdracht 3: Toepassing ```python # Los het stelsel op: 2x + y = 5 # x - 3y = -2 # Gebruik matrixinversie: X = A⁻¹ · B ``` ## Oplossingen ### Oplossing Opdracht 1: ```python # 1. C + D oplossing_1 = np.array([[3, 3], [-2, 4]]) # 2. C - D oplossing_2 = np.array([[1, -5], [2, 2]]) # 3. Elementgewijs product oplossing_3 = np.array([[2, -4], [0, 3]]) # 4. Matrixproduct oplossing_4 = np.array([[4, 7], [-6, 3]]) ``` ### Oplossing Opdracht 2: ```python # 1. Determinant det_E = 3*2 - 1*1 # = 5 # 2. Inverse E_inv = (1/5) * np.array([[2, -1], [-1, 3]]) # 3. Eigenwaarden eigenwaarden_E = [1, 4] # (3-λ)(2-λ) - 1 = 0 # 4. E² E_kwadraat = np.array([[10, 5], [5, 5]]) ``` ### Oplossing Opdracht 3: ```python A = np.array([[2, 1], [1, -3]]) B = np.array([5, -2]) oplossing = np.linalg.solve(A, B) # [1.857, 1.286] # Alternatief: np.dot(np.linalg.inv(A), B) ``` ## Tips voor Verder Leren: 1. Experimenteer met grotere matrices (3x3, 4x4) 2. Probeer verschillende soorten matrices (diagonaal, symmetrisch) 3. Onderzoek `np.linalg.solve()` voor lineaire stelsels 4. Bekijk speciale matrices: `np.eye()`, `np.zeros()`, `np.ones()` Veel succes met oefenen! 🚀