Proyecto en Python para resolver sistemas de ecuaciones lineales.
Este repositorio tiene una idea principal:
Aprender cómo una computadora puede resolver sistemas de ecuaciones usando matrices, determinantes y la Regla de Cramer.
No necesitas ser experto en programación para entender el proyecto. Tampoco necesitas saber mucha matemática avanzada. La intención es mostrar el proceso paso a paso, desde una ecuación escrita de forma normal hasta un programa que puede resolver sistemas más grandes.
Un sistema de ecuaciones lineales es un grupo de ecuaciones que comparten variables.
Por ejemplo:
2x + 3y = 8
4x - y = 2
Aquí hay dos incógnitas:
x
y
Resolver el sistema significa encontrar qué valores deben tener x y y para que ambas ecuaciones sean verdaderas al mismo tiempo.
El proyecto empieza resolviendo sistemas pequeños y luego evoluciona hasta resolver sistemas de cualquier tamaño cuadrado, como:
2 x 2
3 x 3
4 x 4
5 x 5
...
Un sistema cuadrado significa que tiene el mismo número de ecuaciones que de incógnitas.
El proyecto sigue este camino:
Ecuaciones normales
↓
Números separados
↓
Matriz de coeficientes
↓
Determinantes
↓
Regla de Cramer
↓
Resultado final
La idea no es solamente obtener la respuesta, sino entender cómo se llega a ella.
El programa no recibe la ecuación escrita así:
2x + 3y = 8
En lugar de eso, recibe solo los números:
2
3
8
Eso significa:
2x + 3y = 8
Los primeros números son los coeficientes de las variables. El último número es el resultado de la ecuación.
Por ejemplo:
4x - y = 2
Se ingresa como:
4
-1
2
Porque realmente significa:
4x + (-1)y = 2
Supongamos este sistema:
2x + 3y = 8
4x - y = 2
El programa necesita leerlo como filas de números:
[2, 3, 8]
[4, -1, 2]
Cada fila representa una ecuación.
La estructura es:
[coeficiente de x, coeficiente de y, resultado]
Para un sistema de tres variables:
2x + y - z = 8
-3x - y + 2z = -11
-2x + y + 2z = -3
Se ingresa así:
[2, 1, -1, 8]
[-3, -1, 2, -11]
[-2, 1, 2, -3]
La estructura es:
[coeficiente de x, coeficiente de y, coeficiente de z, resultado]
Una matriz es una forma ordenada de guardar números en filas y columnas.
Por ejemplo, este sistema:
2x + 3y = 8
4x - y = 2
Tiene esta matriz de coeficientes:
| 2 3 |
| 4 -1 |
Y esta columna de resultados:
| 8 |
| 2 |
El programa separa el sistema en esas dos partes:
coeficientes → números que acompañan a las variables
resultados → números después del signo igual
El proyecto usa la Regla de Cramer.
La Regla de Cramer permite resolver algunos sistemas de ecuaciones usando determinantes.
La idea básica es:
- Se construye la matriz principal del sistema.
- Se calcula su determinante principal, llamado
D. - Para cada variable, se construye una nueva matriz.
- En esa nueva matriz se reemplaza una columna por la columna de resultados.
- Se calcula el determinante de esa nueva matriz.
- La solución de cada variable se obtiene dividiendo.
Para un sistema de dos variables:
x = Dx / D
y = Dy / D
Para un sistema de tres variables:
x = Dx / D
y = Dy / D
z = Dz / D
El sistema tiene solución única cuando:
D != 0
Si D = 0, significa que el sistema no tiene una solución única usando este método.
El repositorio está dividido en tres programas principales.
systemOfTwoEquations.py
systemOfThreeEquations.py
Laplace.py
Cada archivo representa una etapa diferente de aprendizaje.
Este archivo resuelve sistemas de 2 ecuaciones con 2 incógnitas.
Ejemplo:
2x + 3y = 8
4x - y = 2
Este es el caso más pequeño donde ya se puede ver claramente cómo funciona la Regla de Cramer.
Este archivo enseña la base del proyecto:
leer datos
crear matrices
calcular determinantes
dividir determinantes
mostrar resultados
Aquí todo está pensado para dos variables:
x
y
Por eso es fácil de seguir.
Solo sirve para sistemas 2 x 2.
Si se intenta resolver un sistema de tres variables, este archivo ya no alcanza.
Este archivo resuelve sistemas de 3 ecuaciones con 3 incógnitas.
Ejemplo:
2x + y - z = 8
-3x - y + 2z = -11
-2x + y + 2z = -3
Ahora hay tres variables:
x
y
z
Por eso se calculan más determinantes:
D
Dx
Dy
Dz
Este archivo muestra que la misma idea de Cramer puede extenderse a sistemas más grandes.
Pero también muestra un problema importante:
Mientras más grande es el sistema, más difícil se vuelve escribir todas las fórmulas a mano.
Pasar de 2 x 2 a 3 x 3 ya requiere más código.
Pasar a 4 x 4 sería todavía más largo.
Pasar a 5 x 5 sería peor.
Por eso aparece el tercer archivo.
Este es el archivo principal del proyecto.
Su objetivo es resolver sistemas cuadrados de cualquier tamaño:
2 x 2
3 x 3
4 x 4
5 x 5
...
La diferencia es que este archivo ya no depende de fórmulas escritas manualmente para cada tamaño.
En lugar de eso, usa un proceso general.
El proceso de Laplace.py es este:
1. Pregunta cuántas variables tiene el sistema.
2. Pide los coeficientes y resultados de cada ecuación.
3. Separa los coeficientes de los resultados.
4. Construye la matriz principal.
5. Construye las matrices necesarias para Cramer.
6. Calcula los determinantes.
7. Calcula el valor de cada variable.
8. Muestra el resultado.
En otras palabras:
Laplace.py automatiza lo que los primeros archivos hacían manualmente.
El Teorema de Laplace se usa para calcular determinantes de matrices grandes.
La idea simple es esta:
Una matriz grande puede romperse en matrices más pequeñas.
Entonces el programa calcula el determinante de una matriz grande reduciendo el problema poco a poco.
Por ejemplo:
determinante de una matriz 4 x 4
↓
varios determinantes 3 x 3
↓
varios determinantes 2 x 2
↓
resultado final
Esto se llama recursividad.
Recursividad significa que una función se llama a sí misma para resolver un problema más pequeño.
En este proyecto, la recursividad aparece cuando se calcula un determinante.
La lógica es:
Si la matriz es 2 x 2:
usar la fórmula directa
Si la matriz es más grande:
dividirla en matrices más pequeñas
calcular sus determinantes
combinar los resultados
Por eso Laplace.py puede trabajar con matrices de diferentes tamaños.
Primera versión.
Resuelve únicamente sistemas 2 x 2.
Es útil para entender la Regla de Cramer de la forma más simple posible.
Segunda versión.
Resuelve únicamente sistemas 3 x 3.
Es útil para ver cómo la misma idea crece, pero también para notar que escribir todo a mano no escala bien.
Versión general.
Resuelve sistemas cuadrados de cualquier tamaño usando:
matrices
determinantes
Regla de Cramer
Teorema de Laplace
recursividad
Este es el archivo más importante del proyecto.
Para ejecutar el proyecto necesitas tener instalado:
- Python
- Opcionalmente Git
No se necesitan librerías externas importantes para usar el proyecto.
Con Git:
git clone https://github.com/4rcan31/SolveSystemEcuation.gitLuego entra a la carpeta:
cd SolveSystemEcuationTambién puedes descargar el repositorio como archivo .zip desde GitHub.
Para ejecutar la versión de dos ecuaciones:
python systemOfTwoEquations.pyPara ejecutar la versión de tres ecuaciones:
python systemOfThreeEquations.pyPara ejecutar la versión general:
python Laplace.pyEn algunos sistemas puede ser necesario usar:
python3 Laplace.pyEjecuta:
python Laplace.pyEl programa preguntará:
Ingrese cuantas variables tiene su sistema de ecuaciones:
Si escribes:
3
Entonces el programa entenderá que resolverás un sistema de tres variables.
Después deberás ingresar los coeficientes y el resultado de cada ecuación.
Ejemplo:
2x + y - z = 8
-3x - y + 2z = -11
-2x + y + 2z = -3
Se ingresa así:
3
2
1
-1
8
-3
-1
2
-11
-2
1
2
-3
La primera línea indica la cantidad de variables.
Luego cada grupo representa una ecuación.
Laplace.py acepta algunas palabras especiales al ejecutarse.
python Laplace.py debugMuestra información interna del programa.
Sirve para ver cosas como:
datos originales
matrices generadas
determinantes calculados
resultado final
Este modo es útil para estudiar cómo trabaja el algoritmo.
python Laplace.py randomGenera datos aleatorios en lugar de pedirlos manualmente.
Sirve para probar el programa rápidamente.
python Laplace.py timeMuestra tiempos de ejecución.
Sirve para observar cuánto tarda el programa, especialmente con sistemas grandes.
También se pueden combinar:
python Laplace.py debug random timeEl orden no es importante.
La mejor forma de entender este repositorio es seguir este camino:
1. Probar systemOfTwoEquations.py
2. Entender cómo se resuelve un sistema 2 x 2
3. Probar systemOfThreeEquations.py
4. Ver cómo crece el problema en 3 x 3
5. Probar Laplace.py
6. Entender cómo se generaliza el proceso
La idea es ver la evolución:
caso pequeño
↓
caso más grande
↓
problema de escalabilidad
↓
algoritmo general
Es el número que acompaña a una variable.
En:
5x
El coeficiente es:
5
Es el valor que queremos encontrar.
Por ejemplo:
x
y
z
Es el número que está después del signo igual.
En:
2x + 3y = 8
El término independiente es:
8
Es una tabla de números organizada en filas y columnas.
Es un valor que se calcula a partir de una matriz cuadrada.
En este proyecto se usa para saber si el sistema puede resolverse con Cramer y para calcular las soluciones.
Es un sistema donde el número de ecuaciones es igual al número de incógnitas.
Ejemplos:
2 ecuaciones y 2 incógnitas
3 ecuaciones y 3 incógnitas
4 ecuaciones y 4 incógnitas
El cálculo de determinantes por Laplace es fácil de entender, pero no es el método más eficiente para matrices grandes.
Para sistemas pequeños funciona bien.
Para sistemas grandes, el tiempo de ejecución puede crecer mucho.
El proyecto está pensado para sistemas donde hay el mismo número de ecuaciones e incógnitas.
No está diseñado para resolver directamente sistemas como:
2 ecuaciones y 3 incógnitas
4 ecuaciones y 2 incógnitas
systemOfTwoEquations.py y systemOfThreeEquations.py no buscan ser la solución final.
Existen para mostrar el camino de aprendizaje.
La versión más general es:
Laplace.py
Este proyecto ayuda a entender varias ideas importantes:
cómo representar ecuaciones con números
cómo convertir ecuaciones en matrices
cómo usar determinantes
cómo aplicar la Regla de Cramer
cómo generalizar un algoritmo
cómo usar recursividad
por qué una solución manual no siempre escala
La parte más importante no es solamente que el programa resuelva sistemas.
Lo más importante es ver cómo una idea matemática se convierte poco a poco en un algoritmo.
SolveSystemEcuation es un proyecto didáctico sobre sistemas de ecuaciones lineales.
Empieza con soluciones pequeñas y manuales:
2 x 2
3 x 3
Y termina con una solución general:
n x n
El proyecto muestra el proceso completo:
ecuación
↓
coeficientes
↓
matriz
↓
determinantes
↓
Regla de Cramer
↓
resultado
Por eso este repositorio puede leerse como un camino de aprendizaje:
primero entender el caso simple, luego ver por qué no escala, y finalmente construir una solución general.