Cálculos Matriciales en NumPy

Ojala explicaran mejor el tema de multiplicacion de Matrices. Y no lo pasaran asi tan encima

En multiplicación de matrices debemos tener en cuenta que las columnas del primer Matriz( nxm) y filas de segundo Matriz( mxp) deben ser iguales , finalmente el resultado del producto de Matrices tiene la forma de P(nxp) .

#### **1. SUMA DE MATRICES** **Descripción:** La suma de matrices en Numpy permite la adición elemento a elemento de dos matrices de la misma forma. Es una operación básica en cálculos numéricos. **Ejemplos:** **Código:** A = np.array(\[\[1, 2], \[3, 4]]) B = np.array(\[\[5, 6], \[7, 8]]) sum = A + B print(A) print(B) print(sum)  **Resultado:** A: \[\[1 2]  \[3 4]] B: \[\[5 6]  \[7 8]] sum: \[\[ 6  8]  \[10 12]] *  **Explicación:** Cada elemento de A se suma al elemento correspondiente de B, resultando en la matriz sumada. #### **2. MULTIPLICACIÓN DE MATRICES** **Descripción:** La multiplicación de matrices en Numpy se puede realizar utilizando la función np.dot(). Esta calcula el producto escalar entre dos matrices o arreglos. **Ejemplos:** **Código:** A = np.array(\[\[1, 2], \[3, 4]]) B = np.array(\[\[5, 6], \[7, 8]]) product = np.dot(A, B) print(product)  **Resultado:** product: \[\[19 22]  \[43 50]] *  **Explicación:** Las filas de A se multiplican con las columnas de B utilizando la fórmula del producto escalar. #### **3. DETERMINANTE E INVERSA** **Descripción:** * **Determinante:** El determinante de una matriz cuadrada es un valor escalar calculado a partir de sus elementos. Indica si una matriz es invertible. * **Inversa:** La inversa de una matriz es una matriz que, al multiplicarse con la original, resulta en la matriz identidad. **Ejemplos:** **Código:** A = np.array(\[\[1, 2], \[3, 4]]) det\_A = np.linalg.det(A) inv\_A = np.linalg.inv(A) print(A) print(det\_A) print(inv\_A)  **Resultado:** A: \[\[1 2]  \[3 4]] det\_A: -2.0000000000000004 inv\_A: \[\[-2.   1. ]  \[ 1.5 -0.5]] *  **Explicación:** * El determinante se calcula con np.linalg.det(), mostrando que la matriz es invertible (determinante distinto de cero). * La inversa se calcula con np.linalg.inv(), resultando en una matriz que satisface A⋅A−1=IA \cdot A^{-1} = I. #### **4. ECUACIONES LINEALES** **Descripción:** La función np.linalg.solve resuelve ecuaciones lineales de la forma Ax=bAx = b, donde AA es la matriz de coeficientes y bb es el vector constante. **Ejemplos:** **Código:** A = np.array(\[\[1, 2], \[3, 4]]) b = np.array(\[9, 11]) x = np.linalg.solve(A, b) print(x)  **Resultado:** x: \[-7.  8.] *  **Explicación:** El vector solución xx satisface la ecuación Ax=bAx = b, calculado usando np.linalg.solve().

matrices, que tiempos en la carrera de ingeniería buen lápiz y papel gaste haciendo matrices.

Un ejemplo interesante es el método `np.linalg.lstsq`, que permite encontrar la solución por mínimos cuadrados de un sistema de la forma Ax=y. Esto es importante para realizar una regresión lineal simple. El primer paso es tener dos vectores de datos a los cuales queremos realizarles una regresión lineal simple. Como queremos una ecuación vectorial de la forma y=mx+c, podemos pasarlo a una forma matricial con `np.stack`. Finalmente usamos `np.linalg.lstsq` , y conseguimos una regresión lineal simple! ```python x = np.array([0,1,2,3]) y = np.array([-1,0.2,0.9,2.1]) , A = np.stack([x, np.ones(len(x))], axis=1) print(A) m, c = np.linalg.lstsq(A, y, rcond=None)[0] print(m,c) print(m*x+c) ```

Me puse a hacer pruebas y me encantó: `A = np.array([[1, 2, 3],              [4, 5, 6]])` `B = np.array([[7, 8, 9],              [10, 11, 12]])` `print("Matriz A:\n", A)print("Matriz B:\n", B)` `suma = A + Bprint("Suma de A y B:\n", suma)` `resta = A - Bprint("Resta de A y B:\n", resta)` `multiplicacion_elemento = A * Bprint("Multiplicación elemento por elemento de A y B:\n", multiplicacion_elemento)` `division = A / Bprint("División elemento por elemento de A y B:\n", division)` `multiplicacion_matrices = np.dot(A, B.T) print("Multiplicación matricial (producto punto) de A y B:\n", multiplicacion_matrices)` 

Los cálculos matriciales en NumPy son esenciales para realizar operaciones matemáticas eficientes con matrices y arreglos. Aquí te explico algunos de los conceptos clave y operaciones que puedes realizar: \### 1. \*\*Creación de Matrices\*\* \- \*\*Matriz a partir de listas anidadas:\*\* ```python import numpy as np A = np.array(\[\[1, 2], \[3, 4]]) ``` \- \*\*Matrices especiales:\*\* ```python Z = np.zeros((2, 2)) # Matriz de ceros O = np.ones((2, 2)) # Matriz de unos I = np.eye(2) # Matriz identidad ``` \### 2. \*\*Operaciones Básicas\*\* \- \*\*Suma y resta de matrices:\*\* ```python C = A + B D = A - B ``` \- \*\*Multiplicación por un escalar:\*\* ```python E = 2 \* A ``` \- \*\*Multiplicación de matrices:\*\* ```python F = np.dot(A, B) # Producto matricial ``` \### 3. \*\*Transposición de una Matriz\*\* ```python A\_T = A.T ``` \### 4. \*\*Inversa de una Matriz\*\* ```python A\_inv = np.linalg.inv(A) ``` \### 5. \*\*Determinante de una Matriz\*\* ```python det\_A = np.linalg.det(A) ``` \### 6. \*\*Solución de Sistemas de Ecuaciones Lineales\*\* \- Si tienes un sistema de ecuaciones \\( AX = B \\): ```python X = np.linalg.solve(A, B) ``` \### 7. \*\*Valores y Vectores Propios\*\* ```python eigvals, eigvecs = np.linalg.eig(A) ``` \### 8. \*\*Operaciones Elemento a Elemento\*\* \- \*\*Multiplicación elemento a elemento:\*\* ```python G = A \* B ``` \- \*\*División elemento a elemento:\*\* ```python H = A / B ``` \### 9. \*\*Reducción (Sumas, Máximos, etc.)\*\* \- \*\*Suma de todos los elementos:\*\* ```python total\_sum = np.sum(A) ``` \- \*\*Máximo de todos los elementos:\*\* ```python max\_value = np.max(A) ``` \### 10. \*\*Broadcasting\*\* NumPy permite realizar operaciones entre matrices de diferentes dimensiones de forma automática, ajustando las dimensiones según sea necesario. ```python I = A + 1 # Añade 1 a todos los elementos de A ``` Estos son solo algunos ejemplos de lo que puedes hacer con NumPy para realizar cálculos matriciales. NumPy es extremadamente eficiente y es una herramienta fundamental para cualquier análisis de datos, machine learning o cálculos científicos en Python.

```js import numpy as np A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) B = np.array([[9, 8, 7], [6, 5, 4], [3, 2, 1]]) C = np.array([[1, 2], [3, 4], [5, 6]]) D = np.array([[7, 8], [9, 10]]) E = np.array([[1, 2], [3, 4]]) print("Matriz A:") print(A) print("\nMatriz B:") print(B) suma = A + B resta = A - B print("\nSuma de A y B:") print(suma) print("\nResta de A y B:") print(resta) multiplicacion_elemento = A * B print("\nMultiplicación elemento a elemento de A y B:") print(multiplicacion_elemento) producto_punto = np.dot(C, D) print("\nProducto punto de C y D:") print(producto_punto) A_transpuesta = A.T print("\nTransposición de A:") print(A_transpuesta) E_inversa = np.linalg.inv(E) determinante_E = np.linalg.det(E) print("\nInversa de E:") print(E_inversa) print("\nDeterminante de E:") print(determinante_E) eigenvalores, eigenvectores = np.linalg.eig(E) print("\nEigenvalores de E:") print(eigenvalores) print("\nEigenvectores de E:") print(eigenvectores) A_sys = np.array([[3, 1], [1, 2]]) b = np.array([9, 8]) x = np.linalg.solve(A_sys, b) print("\nSolución del sistema de ecuaciones Ax = b:") print(x) norma_A = np.linalg.norm(A) print("\nNorma de A:") print(norma_A) ```


Este es mi ejemplo FAV 👩‍💻 `vector = np.array([1, 2, 3])` `matriz = np.array([[1, 2, 3], ` ` [4, 5, 6], ` ` [7, 8, 9]])` `print("Vector:")` `print(vector)` `print("\nMatriz:")` `print(matriz)`