FastQuat 0.2__tar.gz

fastquat-0.2/.github/workflows/ci.yml

@@ -0,0 +1,55 @@
+name: CI
+
+on:
+  push:
+    branches:
+    - main
+  pull_request:
+    branches:
+    - main
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+
+  pre-commit:
+    name: Run pre-commit hooks
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install pre-commit
+    - name: Run pre-commit
+      run: pre-commit run --all-files --show-diff-on-failure --color=always
+
+  test:
+    name: Run tests on Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.10', '3.11', '3.12', '3.13']
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install . --group dev
+
+      - name: Run tests
+        run: pytest -v

fastquat-0.2/.github/workflows/release.yml

@@ -0,0 +1,54 @@
+name: Release to PyPI
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  publish:
+    name: Publish package to PyPI
+    runs-on: ubuntu-latest
+    environment: release
+
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # Full history for dynamic versioning
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+        with:
+          enable-cache: true
+
+      - name: Debug Git tags and versioning
+        run: |
+          echo "Git tags:"
+          git tag -l
+          echo "Current tag:"
+          git describe --tags --exact-match HEAD || echo "No exact tag match"
+          echo "Version info:"
+          git describe --tags --always
+
+      - name: Clean uv cache for dynamic versioning
+        run: uv cache clean
+
+      - name: Build package
+        run: uv build
+
+      - name: Verify build artifacts
+        run: |
+          ls -la dist/
+          echo "Built artifacts:"
+          find dist/ -name "*.whl" -o -name "*.tar.gz" | head -10
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

fastquat-0.2/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+dist/
+build/
+/.venv/
+/.idea/
+
+*.py[cod]
+.ipynb_checkpoints/
+.DS_Store

fastquat-0.2/.pre-commit-config.yaml

@@ -0,0 +1,35 @@
+repos:
+- repo: https://github.com/hadialqattan/pycln
+  rev: "v2.5.0"
+  hooks:
+  - id: pycln
+    args:
+    - --all
+
+- repo: https://github.com/astral-sh/ruff-pre-commit
+  rev: "v0.11.8"
+  hooks:
+    - id: ruff
+      name: ruff linting
+    - id: ruff-format
+      name: ruff formatting
+
+- repo: https://github.com/pre-commit/pre-commit-hooks
+  rev: 'v5.0.0'
+  hooks:
+  - id: trailing-whitespace
+  - id: end-of-file-fixer
+  - id: check-merge-conflict
+
+- repo: https://github.com/pre-commit/mirrors-mypy
+  rev: 'v1.15.0'
+  hooks:
+  - id: mypy
+    additional_dependencies:
+    - jax
+    args:
+    - --strict
+    - --show-error-codes
+    - --enable-error-code=ignore-without-code
+    - --allow-untyped-calls
+    files: ^fastquat/

fastquat-0.2/.readthedocs.yaml

@@ -0,0 +1,42 @@
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version, and other tools you might need
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.10"
+    # You can also specify other tool versions:
+    # nodejs: "19"
+    # rust: "1.64"
+    # golang: "1.19"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+  builder: html
+  configuration: docs/source/conf.py
+  fail_on_warning: false
+
+# Optionally build your docs in additional formats such as PDF and ePub
+formats:
+  - pdf
+  - epub
+
+# Optional but recommended, declare the Python requirements required
+# to build your documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+python:
+  install:
+    - requirements: docs/requirements.txt
+    - method: pip
+      path: .
+      extra_requirements:
+        - dev
+
+# Set the version of Python and other tools you might need
+submodules:
+  include: all
+  recursive: true

fastquat-0.2/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: FastQuat
+Version: 0.2
+Summary: High-performance quaternions with JAX support
+Author-email: Pierre Chanial <chanial@apc.in2p3.fr>
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: jax[cuda12]>=0.4.0
+Requires-Dist: jaxlib>=0.4.0
+Description-Content-Type: text/markdown
+
+# FastQuat - High-Performance Quaternions with JAX
+
+[![PyPI version](https://img.shields.io/pypi/v/fastquat)](https://pypi.org/project/fastquat/)
+[![Python versions](https://img.shields.io/pypi/pyversions/fastquat)](https://pypi.org/project/fastquat/)
+[![Tests](https://github.com/CMBSciPol/fastquat/actions/workflows/tests.yml/badge.svg)](https://github.com/CMBSciPol/fastquat/actions)
+
+FastQuat provides optimized quaternion operations with full JAX compatibility, featuring:
+
+- 🚀 **Hardware-accelerated** computations (CPU/GPU/TPU)
+- 🔄 **Automatic differentiation** support
+- 🧩 **Seamless integration** with JAX transformations (`jit`, `grad`, `vmap`)
+- 📦 **Efficient storage** using interleaved memory layout
+
+## Installation
+
+```bash
+pip install fastquat
+```
+
+## Quick Start
+
+```python
+import jax.numpy as jnp
+from fastquat import Quaternion
+
+# Create quaternions
+q1 = Quaternion.ones()  # Identity quaternion
+q2 = Quaternion(0.7071, 0.7071, 0.0, 0.0)  # 90° rotation around x-axis
+
+# Quaternion operations
+q3 = q1 * q2  # Multiplication
+q_inv = q1.inverse()  # Inverse
+q_norm = q1.normalize()  # Normalization
+
+# Rotate vectors
+vector = jnp.array([1.0, 0.0, 0.0])
+rotated = q2.rotate_vector(vector)
+
+# Spherical interpolation (SLERP)
+interpolated = q1.slerp(q2, t=0.5)  # Halfway between q1 and q2
+```
+
+## Features
+
+### Core Operations
+- **Quaternion arithmetic**: Addition, multiplication, conjugation, inverse
+- **Normalization**: Efficient unit quaternion computation
+- **Conversion**: To/from rotation matrices, Euler angles
+- **Vector rotation**: Direct vector transformation
+
+### Advanced Interpolation
+- **SLERP (Spherical Linear Interpolation)**: Smooth rotation interpolation
+  - Automatically handles shortest path selection
+  - Numerically stable for close quaternions
+  - Supports batched operations and array-valued parameters
+
+### JAX Integration
+- **JIT compilation**: Compile quaternion operations for maximum performance
+- **Automatic differentiation**: Compute gradients through quaternion operations
+- **Vectorization**: Process batches of quaternions efficiently
+- **Device support**: Run on CPU, GPU, or TPU
+
+## Performance
+
+FastQuat is optimized for high-performance computing:
+- Memory-efficient interleaved storage
+- SIMD-optimized operations on supported hardware
+- Zero-copy integration with JAX arrays
+- Minimal Python overhead through JIT compilation
+
+## Examples
+
+### Basic Usage
+```python
+import jax
+import jax.numpy as jnp
+from fastquat import Quaternion
+
+# Create random quaternions
+key = jax.random.PRNGKey(42)
+q_batch = Quaternion.random(key, shape=(1000,))
+
+# JIT-compiled batch operations
+@jax.jit
+def batch_rotate(quaternions, vectors):
+    return quaternions.rotate_vector(vectors)
+
+vectors = jax.random.normal(key, (1000, 3))
+rotated_batch = batch_rotate(q_batch, vectors)
+```
+
+### SLERP Animation
+```python
+# Smooth rotation interpolation
+q_start = Quaternion.ones()
+q_end = Quaternion.from_rotation_matrix(rotation_matrix)
+
+# Generate smooth interpolation
+t_values = jnp.linspace(0, 1, 100)
+interpolated_rotations = q_start.slerp(q_end, t_values)
+
+# Apply to object vertices for smooth animation
+animated_vertices = interpolated_rotations.rotate_vector(object_vertices)
+```
+
+## Documentation
+
+Full documentation is available at [fastquat.readthedocs.io](https://fastquat.readthedocs.io)
+
+## Contributing
+
+Contributions are welcome! Please see our [development guide](https://fastquat.readthedocs.io/en/latest/development.html) for details.
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details.

fastquat-0.2/README.md

@@ -0,0 +1,116 @@
+# FastQuat - High-Performance Quaternions with JAX
+
+[![PyPI version](https://img.shields.io/pypi/v/fastquat)](https://pypi.org/project/fastquat/)
+[![Python versions](https://img.shields.io/pypi/pyversions/fastquat)](https://pypi.org/project/fastquat/)
+[![Tests](https://github.com/CMBSciPol/fastquat/actions/workflows/tests.yml/badge.svg)](https://github.com/CMBSciPol/fastquat/actions)
+
+FastQuat provides optimized quaternion operations with full JAX compatibility, featuring:
+
+- 🚀 **Hardware-accelerated** computations (CPU/GPU/TPU)
+- 🔄 **Automatic differentiation** support
+- 🧩 **Seamless integration** with JAX transformations (`jit`, `grad`, `vmap`)
+- 📦 **Efficient storage** using interleaved memory layout
+
+## Installation
+
+```bash
+pip install fastquat
+```
+
+## Quick Start
+
+```python
+import jax.numpy as jnp
+from fastquat import Quaternion
+
+# Create quaternions
+q1 = Quaternion.ones()  # Identity quaternion
+q2 = Quaternion(0.7071, 0.7071, 0.0, 0.0)  # 90° rotation around x-axis
+
+# Quaternion operations
+q3 = q1 * q2  # Multiplication
+q_inv = q1.inverse()  # Inverse
+q_norm = q1.normalize()  # Normalization
+
+# Rotate vectors
+vector = jnp.array([1.0, 0.0, 0.0])
+rotated = q2.rotate_vector(vector)
+
+# Spherical interpolation (SLERP)
+interpolated = q1.slerp(q2, t=0.5)  # Halfway between q1 and q2
+```
+
+## Features
+
+### Core Operations
+- **Quaternion arithmetic**: Addition, multiplication, conjugation, inverse
+- **Normalization**: Efficient unit quaternion computation
+- **Conversion**: To/from rotation matrices, Euler angles
+- **Vector rotation**: Direct vector transformation
+
+### Advanced Interpolation
+- **SLERP (Spherical Linear Interpolation)**: Smooth rotation interpolation
+  - Automatically handles shortest path selection
+  - Numerically stable for close quaternions
+  - Supports batched operations and array-valued parameters
+
+### JAX Integration
+- **JIT compilation**: Compile quaternion operations for maximum performance
+- **Automatic differentiation**: Compute gradients through quaternion operations
+- **Vectorization**: Process batches of quaternions efficiently
+- **Device support**: Run on CPU, GPU, or TPU
+
+## Performance
+
+FastQuat is optimized for high-performance computing:
+- Memory-efficient interleaved storage
+- SIMD-optimized operations on supported hardware
+- Zero-copy integration with JAX arrays
+- Minimal Python overhead through JIT compilation
+
+## Examples
+
+### Basic Usage
+```python
+import jax
+import jax.numpy as jnp
+from fastquat import Quaternion
+
+# Create random quaternions
+key = jax.random.PRNGKey(42)
+q_batch = Quaternion.random(key, shape=(1000,))
+
+# JIT-compiled batch operations
+@jax.jit
+def batch_rotate(quaternions, vectors):
+    return quaternions.rotate_vector(vectors)
+
+vectors = jax.random.normal(key, (1000, 3))
+rotated_batch = batch_rotate(q_batch, vectors)
+```
+
+### SLERP Animation
+```python
+# Smooth rotation interpolation
+q_start = Quaternion.ones()
+q_end = Quaternion.from_rotation_matrix(rotation_matrix)
+
+# Generate smooth interpolation
+t_values = jnp.linspace(0, 1, 100)
+interpolated_rotations = q_start.slerp(q_end, t_values)
+
+# Apply to object vertices for smooth animation
+animated_vertices = interpolated_rotations.rotate_vector(object_vertices)
+```
+
+## Documentation
+
+Full documentation is available at [fastquat.readthedocs.io](https://fastquat.readthedocs.io)
+
+## Contributing
+
+Contributions are welcome! Please see our [development guide](https://fastquat.readthedocs.io/en/latest/development.html) for details.
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details.

fastquat-0.2/docs/.gitignore

@@ -0,0 +1 @@
+/build

fastquat-0.2/docs/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD  ?= sphinx-build
+SOURCEDIR    = source
+BUILDDIR     = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

fastquat-0.2/docs/requirements.txt

@@ -0,0 +1,17 @@
+# Documentation dependencies for FastQuat
+# This file ensures compatibility with Read the Docs and other documentation platforms
+# that don't yet fully support PEP 735 dependency groups
+
+# Core dependencies
+jax[cuda12]>=0.4.0
+jaxlib>=0.4.0
+
+# Documentation-specific dependencies
+sphinx>=7.0.0
+sphinx-rtd-theme>=1.3.0
+myst-parser>=2.0.0
+nbsphinx>=0.9.0
+jupyter>=1.0.0
+matplotlib>=3.7.0
+numpy>=1.24.0
+pillow>=9.0.0

fastquat-0.2/docs/source/api/generated/fastquat.Quaternion.rst

@@ -0,0 +1,62 @@
+fastquat.Quaternion
+===================
+
+.. currentmodule:: fastquat
+
+.. autoclass:: Quaternion
+
+
+   .. automethod:: __init__
+
+
+   .. rubric:: Methods
+
+   .. autosummary::
+
+      ~Quaternion.__init__
+      ~Quaternion.block_until_ready
+      ~Quaternion.conj
+      ~Quaternion.conjugate
+      ~Quaternion.devices
+      ~Quaternion.exp
+      ~Quaternion.flatten
+      ~Quaternion.from_array
+      ~Quaternion.from_rotation_matrix
+      ~Quaternion.from_scalar_vector
+      ~Quaternion.full
+      ~Quaternion.log
+      ~Quaternion.norm
+      ~Quaternion.normalize
+      ~Quaternion.ones
+      ~Quaternion.random
+      ~Quaternion.ravel
+      ~Quaternion.reshape
+      ~Quaternion.rotate_vector
+      ~Quaternion.slerp
+      ~Quaternion.squeeze
+      ~Quaternion.to_components
+      ~Quaternion.to_rotation_matrix
+      ~Quaternion.tree_flatten
+      ~Quaternion.tree_unflatten
+      ~Quaternion.zeros
+
+
+
+
+
+   .. rubric:: Attributes
+
+   .. autosummary::
+
+      ~Quaternion.device
+      ~Quaternion.dtype
+      ~Quaternion.itemsize
+      ~Quaternion.nbytes
+      ~Quaternion.ndim
+      ~Quaternion.shape
+      ~Quaternion.size
+      ~Quaternion.vector
+      ~Quaternion.w
+      ~Quaternion.x
+      ~Quaternion.y
+      ~Quaternion.z

fastquat-0.2/docs/source/api/index.rst

@@ -0,0 +1,21 @@
+API Reference
+=============
+
+This section contains the complete API documentation for FastQuat.
+
+.. toctree::
+   :maxdepth: 2
+
+   quaternion
+
+Core Classes
+------------
+
+.. autosummary::
+   :toctree: generated
+
+   fastquat.Quaternion
+
+The :class:`fastquat.Quaternion` class is the main interface for quaternion operations
+in FastQuat. It provides all essential quaternion arithmetic, conversions, and
+specialized operations like SLERP interpolation.

fastquat-0.2/docs/source/api/quaternion.rst

@@ -0,0 +1,61 @@
+Quaternion Class
+================
+
+.. automodule:: fastquat.quaternion
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+The :class:`Quaternion` class provides a comprehensive interface for quaternion operations
+optimized for JAX. All methods are compatible with JAX transformations including JIT
+compilation, automatic differentiation, and vectorization.
+
+Constructor Methods
+-------------------
+
+.. automethod:: fastquat.Quaternion.__init__
+.. automethod:: fastquat.Quaternion.from_array
+.. automethod:: fastquat.Quaternion.from_scalar_vector
+.. automethod:: fastquat.Quaternion.from_rotation_matrix
+.. automethod:: fastquat.Quaternion.zeros
+.. automethod:: fastquat.Quaternion.ones
+.. automethod:: fastquat.Quaternion.full
+.. automethod:: fastquat.Quaternion.random
+
+Properties
+----------
+
+.. autoattribute:: fastquat.Quaternion.w
+.. autoattribute:: fastquat.Quaternion.x
+.. autoattribute:: fastquat.Quaternion.y
+.. autoattribute:: fastquat.Quaternion.z
+.. autoattribute:: fastquat.Quaternion.vector
+.. autoattribute:: fastquat.Quaternion.shape
+.. autoattribute:: fastquat.Quaternion.dtype
+
+Core Operations
+---------------
+
+.. automethod:: fastquat.Quaternion.norm
+.. automethod:: fastquat.Quaternion.normalize
+.. automethod:: fastquat.Quaternion.inverse
+.. automethod:: fastquat.Quaternion.conjugate
+.. automethod:: fastquat.Quaternion.conj
+
+Rotation Operations
+-------------------
+
+.. automethod:: fastquat.Quaternion.to_rotation_matrix
+.. automethod:: fastquat.Quaternion.rotate_vector
+
+Interpolation
+-------------
+
+.. automethod:: fastquat.Quaternion.slerp
+
+Advanced Operations
+-------------------
+
+.. automethod:: fastquat.Quaternion.log
+.. automethod:: fastquat.Quaternion.exp
+.. automethod:: fastquat.Quaternion.__pow__