semvec/pypi-packages huggingface dataset:
pylinalg 0.6.8
Linear algebra utilities for Python
Requires Python: >=3.9
Keywords: graphics, 3d, linear algebra

# pylinalg

[![CI](https://github.com/pygfx/pylinalg/actions/workflows/ci.yml/badge.svg)](https://github.com/pygfx/pylinalg/actions/workflows/ci.yml)
[![Documentation Status
](https://readthedocs.org/projects/pylinalg/badge/?version=latest)
](https://pylinalg.readthedocs.io/en/latest/?badge=latest)
[![PyPI version ](https://badge.fury.io/py/pylinalg.svg)
](https://badge.fury.io/py/pylinalg)

Linear algebra utilities for Python.

<p align="center">
[<a href="https://pylinalg.readthedocs.io/en/latest/reference.html">API Reference</a>]
</p>

## Installation

```bash
pip install pylinalg
```

### Development Install
To get a working dev install of pylinalg you can use the following steps:

```bash
# Click the Fork button on GitHub and navigate to your fork
git clone <address_of_your_fork>
cd pylinalg
# if you use a venv, create and activate it
pip install -e ".[dev,docs,examples]"
pytest tests
```
litequery 0.8.2
A handy way to interact with an SQLite database from Python
Requires Python: >=3.12

# Litequery

Litequery is a minimalist library for interacting with SQLite in Python. It lets
you define your queries once and call them as methods. No ORM bloat, just raw
SQL power, with the flexibility to operate in both asynchronous and synchronous
modes.

## Why Litequery?

- **Simplicity**: Define SQL queries in `.sql` files. No complex ORM layers.
- **Async first**: Built for modern async Python, but also supports synchronous
  operations for traditional use cases.
- **Flexible**: Supports different SQL operations seamlessly.

## Installation

```
pip install litequery
```

## Getting Started

### Define Your Queries

Create a `queries.sql` file. Name your queries using comments and write them in
pure SQL.

```sql
-- name: get_all_users
SELECT * FROM users;

-- name: get_user_by_id^
SELECT * FROM users WHERE id = :id;

-- name: get_last_user_id$
SELECT MAX(id) FROM users;

-- name: insert_user<!
INSERT INTO users (name, email) VALUES (:name, :email);

-- name: delete_all_users!
DELETE FROM users;
```

### Using Your Queries

Define your database and queries, and then call them as methods. Choose async or
sync setup based on your needs. It's as straightforward as it sounds.

```python
import litequery
import asyncio


async def main():
    lq = litequery.setup("database.db", "queries.sql", use_async=True)
    await lq.connect()

    user_id = await lq.insert_user(name="Alice", email="alice@example.com")
    print(user_id)

    users = await lq.get_all_users()
    print(users)

    user = await lq.get_user_by_id(id=user_id)
    print(user)

    rows_count = await lq.delete_all_users()

    await lq.disconnect()


asyncio.run(main())
```

### Transaction Support

Litequery also supports transactions in both async and sync contexts, allowing
you to execute multiple queries atomicaly.

```python
import litequery
import asyncio


async def main():
    lq = litequery.setup("database.db", "queries.sql")
    await lq.connect()

    try:
        async with lq.transaction():
            await lq.insert_user(name="Charlie", email="charlie@example.com")
            raise Exception("Force rollback")
            await lq.insert_user(name="Eve", email="eve@example.com")
    except Exception:
        print("Transaction failed")

    users = await lq.get_all_users()
    print(users)

    await lq.disconnect()


asyncio.run(main())

```

## Wrapping Up

Litequery is all about simplicity and efficiency. Why wrestle with bloated ORMs
when you can have raw SQL power? If you think there's a better way or have
suggestions, let's hear them. Happy querying!
pyxll-pycharm 0.2.2
Adds PyCharm debugging support to PyXLL.

# PyXLL-PyCharm

PyCharm debugging support for PyXLL.

Requires:

- PyXLL >= 5.0.0
- PyCharm Professional

To install this package use:

    pip install pyxll-pycharm

Once installed a "PyCharm Debug" button will be added to the PyXLL ribbon tab in Excel, so
long as you have PyXLL 5 or above already installed.

To debug your Python code running in Excel with PyXLL

1. Create a new Run Configuration in PyCharm using the "Python Debug Server" template. 
2. Install the "pydev-pycharm" package using the exact version specified in your new Run Configuration.
3. Change the port in your Run Configuration to 5000.
4. Run the new Run Configuration using the green "Debug" button in PyCharm.
5. Connect Excel to PyCharm using the "PyCharm Debug" button in Excel.

To configure add the following to your pyxll.cfg file (default values shown):

    [PYCHARM]
    port = 5000
    suspend = 0
    stdout_to_server = 1
    stderr_to_server = 1
    disable_ribbon = 0

For more information about installing and using PyXLL see https://www.pyxll.com.

Copyright (c) 2020 PyXLL Ltd
pyslise 3.2.2
Python bindings for the C++ version of Matslise

# Pyslise 

Pyslise [1] is a collection of algorithms to solve one (and two, in development) dimensional time-independent Schrödinger equations. These algorithms are based upon constant perturbation methods to efficiently solve these eigenvalue problems.

The code (and name) is based on Matslise [2]. This is a feature-rich MATLAB library for solving the one dimensional time independent Schrödinger equation.

To solve the two dimensional problem an algorithm is developed on the basis of a method proposed by Ixaru [3].

This implementation is developed in C++ with a focus on efficiency. This code is precompiled and packaged in wheels for 64 bit Linux, Windows, and Mac.


## Documentation

Full documentation can be found on 
[matslise.ugent.be](https://matslise.ugent.be/). This document contains some examples of how to use this library.

On the same page an interactive version is available.

## Examples

One dimensional problems can be tackled with:
```python
from pyslise import Pyslise
from math import pi, cos

problem = Pyslise(lambda x: 2*cos(2*x), 0, pi, tolerance=1e-6)
problem.eigenvaluesByIndex(0, 10, (0, 1), (0, 1))
```

Also two dimensional problems are possible:
```python
from pyslise import Pyslise2D

def V(x, y):
    return (1 + x**2) * (1 + y**2)

problem = Pyslise2D(V, -5.5,5.5, -5.5,5.5, tolerance=1e-6)
problem.eigenvalues(0,13)
```

## Bibliography
* **[1]** Baeyens, Toon, and Marnix Van Daele. “The Fast and Accurate Computation of Eigenvalues and Eigenfunctions of Time-Independent One-Dimensional Schrödinger Equations.” Computer Physics Communications, August 26, 2020, 107568. https://doi.org/10.1016/j.cpc.2020.107568.
* **[2]** Ledoux, Veerle, and Marnix Van Daele. “MATSLISE 2.0 : A Matlab Toolbox for Sturm-Liouville Computations.” ACM TRANSACTIONS ON MATHEMATICAL SOFTWARE 42, no. 4 (2016): 18.
* **[3]** Ixaru, L. Gr. “New Numerical Method for the Eigenvalue Problem of the 2D Schrödinger Equation.” Computer Physics Communications 181 (October 1, 2010): 1738–42. https://doi.org/10.1016/j.cpc.2010.06.031.