semvec/pypi-packages huggingface dataset:
skym 0.1.0
Python package exposing Skim functionality for fuzzy match over an iterable of strings.
Requires Python: >=3.8

# skym

A Python package exposing fuzzy text matching based on the Rust creates `skim` and `fuzzy-matcher`.

## Benchmarking

This project includes a comprehensive benchmarking suite built with [Criterion.rs](https://github.com/bheisler/criterion.rs).

### Running Benchmarks

We use `just` as a task runner to simplify benchmark operations. Here are the common benchmarking commands:

### Basic Benchmarking

```bash
# Run all benchmarks
just bench

# Open the benchmark report in your browser
just bench-report
```

#### Comparing Implementations

When making optimizations, you can compare performance between different implementations:

```bash
# Run benchmarks and save as a baseline named "original"
just bench-save original

# Make your code changes, then run and compare with the baseline
just bench-compare original

# Generate a comparison table between two sets of results
just bench-table original new
```

### Managing Benchmark Results

```bash
# Clean all benchmark results
just bench-clean
```

### Understanding Benchmark Results

After running benchmarks, Criterion generates comprehensive reports in `target/criterion/`. The most useful files are:

1. **HTML Report**: Open `target/criterion/report/index.html` in your browser for a visual representation of benchmark results including:
   - Line graphs showing performance over time
   - Violin plots showing distribution of execution times
   - Detailed statistical analysis

2. **JSON Data**: Raw benchmark data is stored in JSON format under `target/criterion/<benchmark_name>/` for each benchmark:
   - `estimates.json`: Contains summary statistics (mean, median, etc.)
   - `sample.json`: Contains raw sample timing data
   - `baseline_estimates.json`: Available when comparing with a baseline
JM21008UNO 0.1.0
Librería para resolver sistemas de ecuaciones lineales y no lineales.
Requires Python: >=3.6

# JM21008UNO
        
        JM21008UNO es una librerÃ­a de Python diseÃ±ada para resolver sistemas de ecuaciones lineales y no lineales utilizando varios mÃ©todos numÃ©ricos. Esta librerÃ­a incluye implementaciones de los mÃ©todos de eliminaciÃ³n de Gauss, Gauss-Jordan, Cramer, descomposiciÃ³n LU y Jacobi, proporcionando una herramienta versÃ¡til para el campo de las matemÃ¡ticas y la ingenierÃ­a.
        
        ## MÃ©todos Disponibles
        
        - **EliminaciÃ³n de Gauss**: Resuelve sistemas de ecuaciones lineales mediante la eliminaciÃ³n de variables.
        - **Gauss-Jordan**: ExtensiÃ³n del mÃ©todo de Gauss que reduce la matriz a su forma escalonada reducida.
        - **Cramer**: Utiliza determinantes para resolver sistemas de ecuaciones lineales.
        - **DescomposiciÃ³n LU**: Descompone una matriz en dos matrices, L (triangular inferior) y U (triangular superior), para facilitar la resoluciÃ³n del sistema.
        - **Jacobi**: MÃ©todo iterativo que encuentra la soluciÃ³n de sistemas de ecuaciones lineales.
        
        ## InstalaciÃ³n
        
        Para instalar la librerÃ­a, puedes usar `pip`:
        
        ```
        pip install JM21008UNO
        ```
        
        ## Ejemplo de Uso
        
        ```python
        from jm21008uno.gauss import resolver_gauss
        from jm21008uno.gauss_jordan import resolver_gauss_jordan
        from jm21008uno.cramer import resolver_cramer
        from jm21008uno.lu_decomposition import resolver_lu
        from jm21008uno.jacobi import resolver_jacobi
        
        # Definir una matriz de coeficientes y un vector de tÃ©rminos independientes
        A = [[2, 1, -1], [3, 3, 9], [3, 4, 2]]
        b = [8, 0, 3]
        
        # Resolver usando el mÃ©todo de eliminaciÃ³n de Gauss
        solucion_gauss = resolver_gauss(A, b)
        
        # Resolver usando el mÃ©todo de Gauss-Jordan
        solucion_gauss_jordan = resolver_gauss_jordan(A, b)
        
        # Resolver usando el mÃ©todo de Cramer
        solucion_cramer = resolver_cramer(A, b)
        
        # Resolver usando descomposiciÃ³n LU
        solucion_lu = resolver_lu(A, b)
        
        # Resolver usando el mÃ©todo de Jacobi
        solucion_jacobi = resolver_jacobi(A, b)
        ```
        
        ## Licencia
        
        Este proyecto estÃ¡ bajo la Licencia MIT. Consulta el archivo LICENSE para mÃ¡s detalles.