{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "11c1dcf1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import sympy as sp\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd615dcf",
   "metadata": {},
   "source": [
    ">**Caracteristicas basicas de matrices**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "74203b23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Orden Matriz A: (2, 3)\n",
      "Orden Matriz B: (2, 3)\n",
      "A[0, 1]: 4\n",
      "B[1, 2]: 1.0\n",
      "[[ True  True  True]\n",
      " [ True  True  True]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[2, 4, 6], [8, 0 ,1]])\n",
    "\n",
    "B = np.array([[ -(-2), 16/4, 6],\n",
    "        [8, 0, -3/-3]])\n",
    "\n",
    "print(\"Orden Matriz A:\", np.shape(A))\n",
    "print(\"Orden Matriz B:\", np.shape(B))\n",
    "print(\"A[0, 1]:\", A[0, 1]) # Acceder al elemento en la fila 0, columna 1 de la matriz A\n",
    "print(\"B[1, 2]:\", B[1, 2]) # Acceder al elemento en la fila 1, columna 2 de la matriz B\n",
    "\n",
    "print(np.equal(A, B)) # Verificar si las matrices A y B son iguales"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6a8b6ca",
   "metadata": {},
   "source": [
    ">**Operaciones Aritmeticas**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0c031ae7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suma de A y B:\n",
      " [[ 7  1]\n",
      " [14 19]\n",
      " [ 2 14]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1, 8], [11, 4], [0, 9]])\n",
    "B = np.array([[6, -7], [3, 15], [2, 5]])\n",
    "\n",
    "escalar = 3\n",
    "\n",
    "print(\"Suma de A y B:\\n\", A + B) # Sumar las matrices A y B\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "74bbf1c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Resta de A y B:\n",
      " [[ -5  15]\n",
      " [  8 -11]\n",
      " [ -2   4]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Resta de A y B:\\n\", A - B) # Restar la matriz B de la matriz A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2a68f095",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiplicación de A por el escalar:\n",
      " [[ 3 24]\n",
      " [33 12]\n",
      " [ 0 27]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Multiplicación de A por el escalar:\\n\", escalar * A) # Multiplicar la matriz A por un escalar"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01252534",
   "metadata": {},
   "source": [
    ">**Transpuesta de una matriz**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "06ae2d08",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matriz A:\n",
      " [[ 2  0 -1]\n",
      " [ 4  6  8]]\n",
      "Matriz A transpuesta:\n",
      " [[ 2  4]\n",
      " [ 0  6]\n",
      " [-1  8]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[2, 0, -1], [4, 6, 8]])\n",
    "\n",
    "At = np.transpose(A) # Transponer la matriz A\n",
    "At = A.T # Otra forma de transponer la matriz A\n",
    "\n",
    "print (\"Matriz A:\\n\", A) # Imprimir la matriz A\n",
    "print(\"Matriz A transpuesta:\\n\", At) # Imprimir la matriz transpuesta de A"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0dc6d9a",
   "metadata": {},
   "source": [
    ">**Teoremas de la transpuesta**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8f63b2fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suma de A y B transpuesta:\n",
      " [[ 8 14]\n",
      " [10 16]\n",
      " [12 18]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "B = np.array([[7, 8, 9], [10, 11, 12]])\n",
    "\n",
    "print(\"Suma de A y B transpuesta:\\n\", (A+B).T)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eaee444d",
   "metadata": {},
   "source": [
    ">**Multiplicacion de matrices**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6973999a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Producto de A y B:\n",
      " [[ 4 40 42]\n",
      " [ 3 27 32]\n",
      " [ 8 86 83]]\n",
      "Producto de A y B usando @:\n",
      " [[ 4 40 42]\n",
      " [ 3 27 32]\n",
      " [ 8 86 83]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[2, 4], [1, 3], [5, 8]])\n",
    "B = np.array([[0, 6, -1], [1, 7, 11]])\n",
    "\n",
    "print(\"Producto de A y B:\\n\", np.dot(A, B)) # Multiplicar las matrices A y B, El operador convencional de * no sirve para multiplicar matrices en pyrhon\n",
    "\n",
    "print(\"Producto de A y B usando @:\\n\", A @ B) # Otra forma de multiplicar las matrices A y B usando el operador @\\"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d537a13b",
   "metadata": {},
   "source": [
    ">**Matriz identidad**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "787653da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "print(np.identity(3)) # Imprimir la matriz identidad de orden 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c283762",
   "metadata": {},
   "source": [
    "> **Ejercicios de teoremas**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2895e041",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I_2 @ A:\n",
      " [[ 2. -5. -9.]\n",
      " [ 4.  8.  6.]]\n",
      "A @ I_3:\n",
      " [[ 2. -5. -9.]\n",
      " [ 4.  8.  6.]]\n",
      "(3*A)@B:\n",
      " [[ -57 -219]\n",
      " [  12  174]]\n",
      "3*(A@B):\n",
      " [[ -57 -219]\n",
      " [  12  174]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[2, -5, -9], [4, 8, 6]])\n",
    "B = np.array([[1, 0], [-3, 2], [4, 7]])\n",
    "C = np.array([[0, 1], [-1, 0], [2, 3]])\n",
    "\n",
    "I_2 = np.identity(2)  \n",
    "I_3 = np.identity(3)\n",
    "print(\"I_2 @ A:\\n\", I_2 @ A)\n",
    "print(\"A @ I_3:\\n\", A @ I_3)\n",
    "print(\"(3*A)@B:\\n\", (3 * A) @ B)\n",
    "print(\"3*(A@B):\\n\", 3 * (A @ B))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "036a835e",
   "metadata": {},
   "source": [
    "> **Sistemas de ecuaciones lineales**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "bdd162f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solución del sistema de ecuaciones lineales Ax = b:\n",
      " [-12. -18.  -5.]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[2, 10, -40], [-4, -7, 41], [1, 3, -12]])\n",
    "b = np.array([-4, -31, -6])\n",
    "\n",
    "x = np.linalg.solve(A, b) # Resolver el sistema de ecuaciones lineales Ax = b\n",
    "\n",
    "print(\"Solución del sistema de ecuaciones lineales Ax = b:\\n\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3083315",
   "metadata": {},
   "source": [
    "Teorema (El conjunto generado es un subespacio vectorial): sea v1, v2 ... vk, k son vectores d eun espacio vectorial V entonces gen{ v1, v2, ..., vk} es un subespacio de V "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e0ab887e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solución del sistema de ecuaciones simbólicas:\n",
      " {a: b + 2*c, x: b + c, y: c}\n",
      "Solución del sistema de ecuaciones simbólicas:\n",
      " {x: -a/9 - b/18 + 5*z/6, y: -a/9 + 5*b/72 + 35*z/24}\n",
      "Solución del sistema de ecuaciones simbólicas:\n",
      " {b: c/3 + d/3, x: -a/40 + 7*c/120 - d/60, y: -a/170 - c/170 + 3*d/85, z: -31*a/680 - 263*c/2040 - 61*d/1020}\n",
      "Solución del sistema de ecuaciones simbólicas:\n",
      " {a: c/3 + d/3, b: -2*c/3 + 7*d/3, x: -c/41 + d/41 - 32*z/41, y: 7*c/492 + 17*d/246 - 31*z/82}\n"
     ]
    }
   ],
   "source": [
    "x, y, z, a, b, c, d = sp.symbols('x y z a b c d') # Definir las variables simbólicas x, y, z, a, b, c\n",
    "eq1 = sp.Eq(x + y, a)\n",
    "eq2 = sp.Eq(x - y, b)\n",
    "eq3 = sp.Eq(y, c)\n",
    "\n",
    "solution = sp.solve((eq1, eq2, eq3), (x, y, a, b, c)) # Resolver el sistema de ecuaciones simbólicas\n",
    "\n",
    "print(\"Solución del sistema de ecuaciones simbólicas:\\n\", solution)\n",
    "\n",
    "eq1 = sp.Eq(-5*x - 4*y + 10*z, a)\n",
    "eq2 = sp.Eq(-8*x + 8*y - 5*z, b)\n",
    "\n",
    "print(\"Solución del sistema de ecuaciones simbólicas:\\n\", sp.solve((eq1, eq2), (x, y, z, a, b))) # Resolver el sistema de ecuaciones simbólicas\n",
    "\n",
    "eq1 = sp.Eq(-20*x - 23*y - 8*z, a)\n",
    "eq2 = sp.Eq(2*x + 7*y - 2*z, b)\n",
    "eq3 = sp.Eq(8*x - 3*y - 4*z, c)\n",
    "eq4 = sp.Eq(-2*x + 24*y - 2*z, d)\n",
    "\n",
    "print(\"Solución del sistema de ecuaciones simbólicas:\\n\", sp.solve((eq1, eq2, eq3, eq4), (x, y, z, a, b, c, d))) # Resolver el sistema de ecuaciones simbólicas\n",
    "\n",
    "eq1 = sp.Eq(-9*x + 8*y - 4*z, a)\n",
    "eq2 = sp.Eq(39*x + 20*y + 38*z, b)\n",
    "eq3 = sp.Eq(-34*x + 12*y - 22*z, c)\n",
    "eq4 = sp.Eq(7*x + 12*y + 10*z, d)\n",
    "\n",
    "print(\"Solución del sistema de ecuaciones simbólicas:\\n\", sp.solve((eq1, eq2, eq3, eq4), (x, y, z, a, b, c, d))) # Resolver el sistema de ecuaciones simbólicas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e0809fc",
   "metadata": {},
   "source": [
    ">**Determinantes**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc825dac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solucion con numpy\n",
      "1.0\n",
      "-2.0\n",
      "Solucion con sympy\n",
      "1\n",
      "-2\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1, -2], [-3, 7]])\n",
    "B = np.array([[2, 0], [1, -1]])\n",
    "\n",
    "print(\"Solucion con numpy\")\n",
    "print(np.round(np.linalg.det(A), 2)) # Calcular el determinante de la matriz A\n",
    "print(np.round(np.linalg.det(B), 2)) # Calcular el determinante de la matriz B\n",
    "\n",
    "print(\"Solucion con sympy\")\n",
    "A_sym = sp.Matrix([[1, -2], [-3, 7]])\n",
    "B_sym = sp.Matrix([[2, 0], [1, -1]])\n",
    "print(A_sym.det()) # Calcular el determinante de la matriz A usando sympy\n",
    "print(B_sym.det()) # Calcular el determinante de la matriz B usando sympy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "f78d7a6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solución de A\n",
      "-8\n",
      "Solución de B\n",
      "-104\n"
     ]
    }
   ],
   "source": [
    "A = sp.Matrix([[1, 5, 2], [2, 0, 1], [1, -1, 1]])\n",
    "B = sp.Matrix([[5, -2, 4], [0, 1, 5], [1, 2, -8]])\n",
    "\n",
    "\n",
    "print(\"Solución de A\")\n",
    "print(A.det()) # Calcular el determinante de la matriz A usando sympy\n",
    "\n",
    "\n",
    "print(\"Solución de B\")\n",
    "print(B.det()) # Calcular el determinante de la matriz B usando sympy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "120d42b4",
   "metadata": {},
   "source": [
    ">**Eigenvalores**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e067f384",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PurePoly(λ**2 - 5*λ - 2, λ, domain='ZZ')\n"
     ]
    }
   ],
   "source": [
    "A = sp.Matrix([[1, 2], [3, 4]])\n",
    "\n",
    "print(A.charpoly('λ')) # Calcular el polinomio característico de la matriz A usando sympy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "ae9b370e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "valores propios: {4: 1, -1: 1}\n",
      "vectores propios: [(-1, 1, [Matrix([\n",
      "[-1/2],\n",
      "[   1]])]), (4, 1, [Matrix([\n",
      "[2],\n",
      "[1]])])]\n"
     ]
    }
   ],
   "source": [
    "A = sp.Matrix([[3, 2], [2, 0]])\n",
    "\n",
    "print(\"valores propios:\",A.eigenvals(), end=\"\\n\") # Calcular los valores propios de la matriz A usando sympy\n",
    "print(\"vectores propios:\",A.eigenvects(), end=\"\\n\") # Calcular los vectores propios de la matriz A usando sympy"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "propedeutico",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}