semvec/pypi-packages huggingface dataset:
PF23019UNO 1.1
Librería para resolver sistemas lineales y no lineales
Requires Python: >=3.6

# PF23019UNO-Libreria de Métodos Numéricos

Esta librería implementa métodos numéricos para resolver sistemas de ecuaciones lineales y no lineales.

## Instalación
```bash
pip install PF23019UNO

## Métodos Implementados

### Sistemas Lineales
- Eliminación de Gauss
- Gauss-Jordan
- Regla de Crammer
- Descomposición LU
- Método de Jacobi
- Método de Gauss-Seidel

### Sistemas No Lineales
- Método de Bisección



## Ejemplo de Uso
# Resolver un sistema de ecuaciones lineales
import numpy as np
from PF23019UNO import eliminacion_gauss  # o el método que desees usar

if __name__ == "__main__":
    print("Problema de ejemplo:")
    A = [
        [3, 1, -1],
        [2, 4, 1],
        [-1, 2, 5]
    ]
    b = [4, 1, 1]

    A = np.array(A, dtype=float)
    b = np.array(b, dtype=float)

    print(f"Matriz A:\n{A}\n")
    print(f"Vector b:\n{b}\n")

    solucion = eliminacion_gauss(A, b)
    print(f"\nSolución final (Gauss): {solucion}\n")

##Encontrar la raíz de una función no lineal con bisección
from PF23019UNO import biseccion

if __name__ == "__main__":
    f = lambda x: x**2 - 4  # Raíz en x = 2 y x = -2
    a = 0
    b = 5

    try:
        raiz = biseccion(f, a, b)
        print(f"La raíz aproximada es: {raiz:.8f}")
    except ValueError as e:
        print(f"Error: {e}")

### Documentación de Funciones
eliminacion_gauss(A, b)
Resuelve un sistema 𝐴𝑥=𝑏
Ax=b usando eliminación hacia adelante y sustitución hacia atrás.

gauss_jordan(A, b)
Convierte la matriz aumentada en forma reducida para obtener directamente la solución.

crammer(A, b)
Aplica la regla de Cramer utilizando determinantes para resolver el sistema.

descomposicion_LU(A, b)
Utiliza descomposición LU (requiere implementación con SciPy o personalizada).

jacobi(A, b, x0=None, tol=1e-10, max_iter=1000)
Método iterativo para encontrar una solución aproximada.

gauss_seidel(A, b, x0=None, tol=1e-10, max_iter=1000)
Versión optimizada del método de Jacobi que usa los valores actualizados en cada paso.

biseccion(f, a, b, tol=1e-10, max_iter=1000)
Encuentra una raíz de la función f en el intervalo [a,b] usando el método de bisección.

## Autor
Josue David Parada Flores-PF23019 - Métodos Numéricos
GabrielDiazCalculadoraAlgebraicaMatricial 0.1.0
Una librería para resolver sistemas de ecuaciones lineales y no lineales
Requires Python: >=3.6

# LibreriaPythonSistemasEcuaciones

## Descripción 📄
Librería Python con implementaciones de métodos numéricos para resolver sistemas de ecuaciones lineales de la forma **Ax = b**. Incluye tanto métodos directos como iterativos con diferentes características de rendimiento y precisión.

## Instalación ⚙️
```bash
pip install numpy
```

## Métodos Implementados 🛠️
🔹 Métodos Directos
1. Gauss-Jordan
`gauss_jordan(A, b, tol=1e-12)`
    Características: Implementación con pivoteo parcial

    Ventajas: Proporciona directamente la matriz identidad

    Complejidad: O(n³)

2. Eliminación Gaussiana
`gaussian_elimination(A, b)`
    Características: Versión clásica con pivoteo parcial

    Ventajas: Más eficiente que Gauss-Jordan para sistemas simples


3. Regla de Cramer
`cramer(A, b)`
    Características: Solución mediante determinantes

    Limitaciones: Costo computacional alto (O(n!)) para n > 3


4. Descomposición LU
`lu_decomposition(A, b, tol=1e-12)`

    Características: Implementación con pivoteo parcial

    Ventajas: Ideal para múltiples sistemas con misma matriz



🔹 Métodos Iterativos
1. Jacobi
`jacobi(A, b, tol=1e-10, max_iter=1000)`

    Características: Método iterativo simple

    Convergencia: Condicional (depende de la matriz)


2. Gauss-Seidel
`guass_seidel(A, b, tol=1e-10, max_iter=1000)`

    Características: Variante más rápida de Jacobi

    Ventajas: Convergencia más rápida que Jacobi


## Ejemplo de Uso 🚀

```
import numpy as np
from soluciones import gauss_jordan, lu_decomposition

# Sistema de ejemplo
A = np.array([[4, 3], [6, 3]])
b = np.array([10, 12])

# Resolver con Gauss-Jordan
x_gj = gauss_jordan(A.copy(), b.copy())

# Resolver con LU
x_lu = lu_decomposition(A.copy(), b.copy())
```

## Pruebas 🧪

El archivo test.py contiene pruebas unitarias para validar todos los métodos:

`python test.py`

### Recomendaciones de Uso 💡

| Escenario                         | Metodo recomendado         |
| :---                              |    :----:                  |
| Sistemas pequeños (n < 100)       | LU o Gauss-Jordan          |
| Matrices dispersas grandes        | Jacobi/Gauss-Seidel        |
| Múltiples sistemas misma matriz   | Descomposición LU          |
| Máxima precisión                  | Gauss-Jordan con pivoteo   |