quatorch 0.1.0a0__tar.gz

quatorch-0.1.0a0/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: quatorch
+Version: 0.1.0a0
+Summary: Quaternion operations in pure PyTorch
+Keywords: quaternion,rotation,3d,orientation,pytorch
+Author: Lucas N. Egidio
+Author-email: Lucas N. Egidio <lucasegidio1@gmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: torch>=2.8.0
+Requires-Dist: torch ; extra == 'cpu'
+Maintainer: Lucas N. Egidio
+Maintainer-email: Lucas N. Egidio <lucasegidio1@gmail.com>
+Requires-Python: >=3.10
+Project-URL: Documentation, https://github.com/egidioln/QuaTorch/
+Project-URL: Homepage, https://github.com/egidioln/QuaTorch/
+Project-URL: Issues, https://github.com/egidioln/QuaTorch/issues
+Project-URL: Repository, https://github.com/egidioln/QuaTorch.git
+Provides-Extra: cpu
+Description-Content-Type: text/markdown
+
+
+<img src="https://raw.githubusercontent.com/egidioln/QuaTorch/refs/heads/main/docs/source/_static/logo.svg" width="400px">
+
+***Quaternions in PyTorch***
+# QuaTorch
+<!--[![Release](https://img.shields.io/github/v/release/actions/deploy-pages?label=Release&logo=github)](https://github.com/actions/deploy-pages/releases/latest) -->
+[![cov](https://raw.githubusercontent.com/egidioln/QuaTorch/refs/heads/gh-pages/badges/coverage.svg)](https://github.com/egidioln/quatorch/actions) 
+[![Tests](https://img.shields.io/github/actions/workflow/status/egidioln/QuaTorch/pytest.yml?label=Tests&logo=github)](https://github.com/egidioln/QuaTorch/actions/workflows/pytest.yml) 
+[![Docs](https://img.shields.io/github/actions/workflow/status/egidioln/QuaTorch/docs.yml?label=Docs&logo=github)](https://egidioln.github.io/QuaTorch/) 
+
+The package `quatorch` provides `Quaternion`, a `torch.Tensor` subclass that represents a [Quaternion](https://en.wikipedia.org/wiki/Quaternion). It implements common operations in following quaternion algebra such as multiplication,
+conjugation, inversion, normalization, log, exp, etc. It also supports conversion to/from rotation matrix and axis-angle representation. Convenient utilities are provided together, such as spherical linear interpolation ([slerp](https://en.wikipedia.org/wiki/Slerp)) and 3D vector rotation.
+
+## Highlights
+
+- Quaternion type: `quatorch.Quaternion` (subclass of `torch.Tensor`).
+- Element-wise and algebraic ops implemented: `+`, `-`, `*` (quaternion product and scalar mul),
+	`abs` (norm), `conjugate`, `inverse`, `normalize`, `to_rotation_matrix`, and more.
+- Utilities: `from_rotation_matrix`, `from_axis_angle`, `to_axis_angle`, `rotate_vector`, `slerp`,
+	`log`, `exp`, and `pow`.
+
+## Installation
+
+This project targets Python 3.10+ and requires PyTorch. Install via pip (recommended):
+
+```bash
+pip install quatorch
+```
+
+Or install editable/development mode:
+
+```bash
+git clone 
+cd QuaTorch
+pip install -e .
+```
+
+See `pyproject.toml` for dependency details (dev deps include `pytest`).
+
+## Quick start
+
+Basic usage examples using PyTorch tensors and `Quaternion`:
+
+```python
+import torch
+from quatorch.quaternion import Quaternion
+
+# Create a quaternion from four scalars (W, X, Y, Z)
+q = Quaternion(1.0, 0.0, 0.0, 0.0)
+
+# Or from a tensor of shape (..., 4)
+q2 = Quaternion(torch.tensor([0.9239, 0.3827, 0.0, 0.0]))  # 45° around X
+
+# Normalize
+q2 = q2.normalize()
+
+# Quaternion multiplication (rotation composition)
+q3 = q * q2
+
+# Rotate a vector
+v = torch.tensor([1.0, 0.0, 0.0])
+v_rot = q2.rotate_vector(v)
+
+# Convert to rotation matrix
+R = q2.to_rotation_matrix()
+
+# Slerp between quaternions
+t = 0.5
+q_mid = q.slerp(q2, t)
+```
+
+## API notes
+
+- Construction:
+	- `Quaternion(data: torch.Tensor)` where `data.shape[-1] == 4`.
+	- `Quaternion(w, x, y, z)` accepts scalars or tensors broadcastable to the same shape.
+
+- Shape requirements:
+	- The last dimension must be size 4 for quaternion tensors (W, X, Y, Z).
+
+- Interoperability:
+	- The class implements several `torch.*` functions via a small dispatcher so
+		many PyTorch APIs behave sensibly with `Quaternion` objects.
+
+See the source in `src/quatorch/quaternion.py` for the full implementation and more
+helper methods.
+
+## Running tests
+
+This repository includes unit tests using `pytest` under `test/unit_tests`.
+
+From the project root, run:
+
+```bash
+uv run --with=. pytest 
+```
+
+## Contributing
+
+Contributions are welcome. A few ideas:
+
+- Add more conversions and higher-level utilities (e.g., batch rotation helpers).
+- Improve numeric stability and add property-based tests.
+- Add docs and usage notebooks / examples.
+
+Please open issues or pull requests on the repository.
+
+## License
+
+MIT — see the [LICENSE.md](./LICENSE.md) for author/maintainer information.
+
+## Contact
+
+Maintainer: Lucas N. Egidio <lucasegidio1@gmail.com>
+

quatorch-0.1.0a0/README.md

@@ -0,0 +1,115 @@
+
+<img src="https://raw.githubusercontent.com/egidioln/QuaTorch/refs/heads/main/docs/source/_static/logo.svg" width="400px">
+
+***Quaternions in PyTorch***
+# QuaTorch
+<!--[![Release](https://img.shields.io/github/v/release/actions/deploy-pages?label=Release&logo=github)](https://github.com/actions/deploy-pages/releases/latest) -->
+[![cov](https://raw.githubusercontent.com/egidioln/QuaTorch/refs/heads/gh-pages/badges/coverage.svg)](https://github.com/egidioln/quatorch/actions) 
+[![Tests](https://img.shields.io/github/actions/workflow/status/egidioln/QuaTorch/pytest.yml?label=Tests&logo=github)](https://github.com/egidioln/QuaTorch/actions/workflows/pytest.yml) 
+[![Docs](https://img.shields.io/github/actions/workflow/status/egidioln/QuaTorch/docs.yml?label=Docs&logo=github)](https://egidioln.github.io/QuaTorch/) 
+
+The package `quatorch` provides `Quaternion`, a `torch.Tensor` subclass that represents a [Quaternion](https://en.wikipedia.org/wiki/Quaternion). It implements common operations in following quaternion algebra such as multiplication,
+conjugation, inversion, normalization, log, exp, etc. It also supports conversion to/from rotation matrix and axis-angle representation. Convenient utilities are provided together, such as spherical linear interpolation ([slerp](https://en.wikipedia.org/wiki/Slerp)) and 3D vector rotation.
+
+## Highlights
+
+- Quaternion type: `quatorch.Quaternion` (subclass of `torch.Tensor`).
+- Element-wise and algebraic ops implemented: `+`, `-`, `*` (quaternion product and scalar mul),
+	`abs` (norm), `conjugate`, `inverse`, `normalize`, `to_rotation_matrix`, and more.
+- Utilities: `from_rotation_matrix`, `from_axis_angle`, `to_axis_angle`, `rotate_vector`, `slerp`,
+	`log`, `exp`, and `pow`.
+
+## Installation
+
+This project targets Python 3.10+ and requires PyTorch. Install via pip (recommended):
+
+```bash
+pip install quatorch
+```
+
+Or install editable/development mode:
+
+```bash
+git clone 
+cd QuaTorch
+pip install -e .
+```
+
+See `pyproject.toml` for dependency details (dev deps include `pytest`).
+
+## Quick start
+
+Basic usage examples using PyTorch tensors and `Quaternion`:
+
+```python
+import torch
+from quatorch.quaternion import Quaternion
+
+# Create a quaternion from four scalars (W, X, Y, Z)
+q = Quaternion(1.0, 0.0, 0.0, 0.0)
+
+# Or from a tensor of shape (..., 4)
+q2 = Quaternion(torch.tensor([0.9239, 0.3827, 0.0, 0.0]))  # 45° around X
+
+# Normalize
+q2 = q2.normalize()
+
+# Quaternion multiplication (rotation composition)
+q3 = q * q2
+
+# Rotate a vector
+v = torch.tensor([1.0, 0.0, 0.0])
+v_rot = q2.rotate_vector(v)
+
+# Convert to rotation matrix
+R = q2.to_rotation_matrix()
+
+# Slerp between quaternions
+t = 0.5
+q_mid = q.slerp(q2, t)
+```
+
+## API notes
+
+- Construction:
+	- `Quaternion(data: torch.Tensor)` where `data.shape[-1] == 4`.
+	- `Quaternion(w, x, y, z)` accepts scalars or tensors broadcastable to the same shape.
+
+- Shape requirements:
+	- The last dimension must be size 4 for quaternion tensors (W, X, Y, Z).
+
+- Interoperability:
+	- The class implements several `torch.*` functions via a small dispatcher so
+		many PyTorch APIs behave sensibly with `Quaternion` objects.
+
+See the source in `src/quatorch/quaternion.py` for the full implementation and more
+helper methods.
+
+## Running tests
+
+This repository includes unit tests using `pytest` under `test/unit_tests`.
+
+From the project root, run:
+
+```bash
+uv run --with=. pytest 
+```
+
+## Contributing
+
+Contributions are welcome. A few ideas:
+
+- Add more conversions and higher-level utilities (e.g., batch rotation helpers).
+- Improve numeric stability and add property-based tests.
+- Add docs and usage notebooks / examples.
+
+Please open issues or pull requests on the repository.
+
+## License
+
+MIT — see the [LICENSE.md](./LICENSE.md) for author/maintainer information.
+
+## Contact
+
+Maintainer: Lucas N. Egidio <lucasegidio1@gmail.com>
+

quatorch-0.1.0a0/pyproject.toml

@@ -0,0 +1,82 @@
+[project]
+name = "quatorch"
+version = "0.1.0-alpha"
+description = "Quaternion operations in pure PyTorch"
+keywords = ["quaternion", "rotation", "3d", "orientation",  "pytorch"]
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+dependencies = [
+    "torch>=2.8.0",
+]
+
+authors = [
+  {name = "Lucas N. Egidio", email = "lucasegidio1@gmail.com"},
+]
+maintainers = [
+  {name = "Lucas N. Egidio", email = "lucasegidio1@gmail.com"},
+]
+
+classifiers = [
+  # TODO change to 5 - Production/Stable
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Science/Research",
+
+  # TODO verify "License :: OSI Approved :: MIT License",
+  "Topic :: Scientific/Engineering :: Mathematics",
+  "Topic :: Scientific/Engineering :: Physics",
+
+  # Specify the Python versions you support here.
+  "Programming Language :: Python :: 3",
+]
+
+
+[project.optional-dependencies]
+cpu = [
+  "torch"
+]
+
+[tool.uv.sources]
+torch = [
+  { index = "pytorch-cpu", extra = "cpu" },
+]
+
+[[tool.uv.index]]
+name = "pytorch-cpu"
+url = "https://download.pytorch.org/whl/cpu"
+explicit = true
+
+[project.urls]
+Homepage = "https://github.com/egidioln/QuaTorch/"
+Documentation = "https://github.com/egidioln/QuaTorch/"
+Repository = "https://github.com/egidioln/QuaTorch.git"
+Issues = "https://github.com/egidioln/QuaTorch/issues"
+# Changelog = "https://github.com/me/spam/blob/master/CHANGELOG.md"
+
+
+[dependency-groups]
+dev = [
+    "furo>=2025.7.19",
+    "myst-parser>=4.0.1",
+    "pytest>=8.4.2",
+    "pytest-cov>=7.0.0",
+    "ruff>=0.13.0",
+    "sphinx>=8.1.3",
+]
+
+
+[build-system]
+requires = ["uv_build >= 0.8.17, <0.9.0"]
+build-backend = "uv_build"
+
+[tool.pytest.ini_options]
+testpaths = ["test"]
+# Optional: set python_files pattern to include test files under unit_tests
+python_files = ["test_*.py"]
+addopts = "--cov=quatorch --cov-report xml:coverage.xml --cov-report html:htmlcov --cov-report json"
+
+[tool.coverage.report]
+exclude_also = [
+    'raise ValueError',
+    'raise TypeError'
+]

quatorch-0.1.0a0/src/quatorch/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.1.0"
+from .quaternion import Quaternion
+
+
+__all__ = ["Quaternion"]

quatorch-0.1.0a0/src/quatorch/quaternion.py

@@ -0,0 +1,309 @@
+import functools
+from typing import Any, overload
+
+import torch
+
+HANDLED_FUNCTIONS = {}
+
+
+def CHECK_OPERAND_SHAPE(other: Any, scalar_allowed: bool = True):
+    if torch.is_tensor(other) and other.shape[-1] not in (1, 4):
+        raise ValueError(
+            "The last dimension must be of size 4 to represent a quaternion (WXYZ) or size 1 to represent a real scalar."
+        )
+    if torch.is_tensor(other) and other.dtype in [torch.complex64, torch.complex128]:
+        raise TypeError("Cannot operate between quaternion and complex tensors.")
+    if not scalar_allowed and isinstance(other, (int, float, complex)):
+        raise TypeError("Operand must not be a scalar.")
+
+
+def implements(torch_function):
+    """Register a torch function override for ScalarTensor"""
+
+    @functools.wraps(torch_function)
+    def decorator(func):
+        HANDLED_FUNCTIONS[torch_function] = func
+        return func
+
+    return decorator
+
+
+class Quaternion(torch.Tensor):
+    r"""A `torch.Tensor` subclass representing quaternions.
+    Quaternions are represented as tensors of shape (..., 4), where the last dimension
+    corresponds to the components (W, X, Y, Z).
+    Args:
+
+        w: The real part of the quaternion.
+        x: The first imaginary part of the quaternion.
+        y: The second imaginary part of the quaternion.
+        z: The third imaginary part of the quaternion.
+    or
+        data: A tensor of shape (..., 4) representing the quaternion components
+            in the order (W, X, Y, Z).
+
+    """
+
+    def __new__(cls, *args, **kwargs):
+        if "data" in kwargs or (len(args) == 1 and isinstance(args[0], torch.Tensor)):
+            return super().__new__(cls, *args, **kwargs)
+        if len(args) == 4:
+            tensors = tuple(torch.as_tensor(arg) for arg in args)
+            try:
+                data = torch.stack(tensors, dim=-1)
+            except RuntimeError as e:
+                raise ValueError("All input tensors must have the same shape.") from e
+            return super().__new__(cls, data)
+        if all(_ in kwargs for _ in "wxyz"):
+            return super().__new__(
+                cls,
+                torch.stack(
+                    [kwargs["w"], kwargs["x"], kwargs["y"], kwargs["z"]], dim=-1
+                ),
+            )
+        raise ValueError("Invalid arguments for Quaternion initialization.")
+
+    @overload
+    def __init__(self, data: torch.Tensor, *args, **kwargs): ...
+
+    @overload
+    def __init__(
+        self,
+        w: float | torch.Tensor,
+        x: float | torch.Tensor,
+        y: float | torch.Tensor,
+        z: float | torch.Tensor,
+        **kwargs,
+    ): ...
+
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        if self.shape[-1] != 4:
+            raise ValueError(
+                "The last dimension must be of size 4 to represent a quaternion (WXYZ)."
+            )
+
+    def to_wxyz(self) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        return self.as_subclass(torch.Tensor).unbind(-1)
+
+    @classmethod
+    def __torch_function__(cls, func, types, args=(), kwargs=None):
+        if kwargs is None:
+            kwargs = {}
+        if func in HANDLED_FUNCTIONS:
+            return HANDLED_FUNCTIONS[func](*args, **kwargs)
+        return super().__torch_function__(func, types, args, kwargs)
+
+    @implements(torch.add)
+    def add(self, other):
+        CHECK_OPERAND_SHAPE(other, scalar_allowed=False)
+
+        return Quaternion(super().add(other))
+
+    @implements(torch.mul)
+    def mul(self, other):
+        CHECK_OPERAND_SHAPE(other, scalar_allowed=True)
+
+        if isinstance(other, (int, float)):
+            return Quaternion(super().mul(other))
+
+        w1, x1, y1, z1 = self.to_wxyz()
+        if other.shape[-1] == 4:
+            w2, x2, y2, z2 = Quaternion(other).to_wxyz()
+        else:  # scalar
+            w2 = other[..., 0]
+            x2 = 0
+            y2 = 0
+            z2 = 0
+
+        w = w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2
+        x = w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2
+        y = w1 * y2 - x1 * z2 + y1 * w2 + z1 * x2
+        z = w1 * z2 + x1 * y2 - y1 * x2 + z1 * w2
+
+        return Quaternion(torch.stack([w, x, y, z], dim=-1))
+
+    @implements(torch.sub)
+    def sub(self, other):
+        CHECK_OPERAND_SHAPE(other, scalar_allowed=False)
+
+        return Quaternion(super().sub(other))
+
+    @implements(torch.abs)
+    def abs(self):
+        w, x, y, z = self.to_wxyz()
+        return torch.sqrt(w**2 + x**2 + y**2 + z**2)
+
+    def __add__(self, other):
+        return self.add(other)
+
+    def __sub__(self, other):
+        return self.sub(other)
+
+    def __mul__(self, other):
+        return self.mul(other)
+
+    def __pow__(self, other):
+        return self.pow(other)
+
+    def __truediv__(self, other):
+        if isinstance(other, Quaternion):
+            return self.mul(other.inverse())
+        return self.div(other)
+
+    def conjugate(self):
+        w, x, y, z = self.to_wxyz()
+        return Quaternion(torch.stack([w, -x, -y, -z], dim=-1))
+
+    def inverse(self):
+        norm_sq = self.abs() ** 2
+        conj = self.conjugate()
+        return Quaternion(conj / norm_sq.unsqueeze(-1))
+
+    def normalize(self):
+        norm = self.abs()
+        return Quaternion(self / norm.unsqueeze(-1))
+
+    def to_rotation_matrix(self):
+        w, x, y, z = self.to_wxyz()
+        leading_dims = self.shape[:-1]
+        rotation_matrix = torch.empty(
+            *leading_dims, 3, 3, device=self.device, dtype=self.dtype
+        )
+
+        rotation_matrix[..., 0, 0] = 1 - 2 * (y**2 + z**2)
+        rotation_matrix[..., 0, 1] = 2 * (x * y - z * w)
+        rotation_matrix[..., 0, 2] = 2 * (x * z + y * w)
+
+        rotation_matrix[..., 1, 0] = 2 * (x * y + z * w)
+        rotation_matrix[..., 1, 1] = 1 - 2 * (x**2 + z**2)
+        rotation_matrix[..., 1, 2] = 2 * (y * z - x * w)
+
+        rotation_matrix[..., 2, 0] = 2 * (x * z - y * w)
+        rotation_matrix[..., 2, 1] = 2 * (y * z + x * w)
+        rotation_matrix[..., 2, 2] = 1 - 2 * (x**2 + y**2)
+
+        return rotation_matrix
+
+    @staticmethod
+    def from_rotation_matrix(R: torch.Tensor):
+        if R.shape[-2:] != (3, 3):
+            raise ValueError("Input rotation matrix must have shape (..., 3, 3)")
+        B = R.shape[:-2]
+        R = R.reshape(-1, 3, 3)
+
+        trace = R[..., 0, 0] + R[..., 1, 1] + R[..., 2, 2]
+        w = torch.sqrt(1.0 + trace) / 2.0
+        x = (R[..., 2, 1] - R[..., 1, 2]) / (4.0 * w)
+        y = (R[..., 0, 2] - R[..., 2, 0]) / (4.0 * w)
+        z = (R[..., 1, 0] - R[..., 0, 1]) / (4.0 * w)
+
+        q = torch.stack([w, x, y, z], dim=-1)
+        q = q.reshape(*B, 4)
+        return Quaternion(q)
+
+    @staticmethod
+    def from_axis_angle(axis: torch.Tensor, angle: torch.Tensor):
+        if axis.shape[-1] != 3:
+            raise ValueError("Axis must have shape (..., 3)")
+        if axis.dim() != angle.dim() + 1:
+            raise ValueError(
+                "Axis (..., 3) and angle (...) must have the same number of leading dimensions"
+            )
+        if axis.shape[:-1] != angle.shape:
+            raise ValueError("Axis and angle must have compatible shapes")
+
+        half_angle = angle / 2.0
+        sin_half_angle = torch.sin(half_angle)
+        cos_half_angle = torch.cos(half_angle)
+
+        axis = axis / torch.norm(axis, dim=-1, keepdim=True)
+
+        w = cos_half_angle
+        x = axis[..., 0] * sin_half_angle
+        y = axis[..., 1] * sin_half_angle
+        z = axis[..., 2] * sin_half_angle
+
+        q = torch.stack([w, x, y, z], dim=-1)
+        return Quaternion(q)
+
+    def to_axis_angle(self):
+        w, x, y, z = self.to_wxyz()
+        angle = 2 * torch.acos(w)
+        s = torch.sqrt(1 - w**2)
+        s = torch.where(s < 1e-8, torch.tensor(1e-8, device=s.device, dtype=s.dtype), s)
+        axis = torch.stack([x / s, y / s, z / s], dim=-1)
+        return axis, angle
+
+    def rotate_vector(self, v: torch.Tensor):
+        if v.shape[-1] != 3:
+            raise ValueError("Input vector must have shape (..., 3)")
+
+        v_quat = Quaternion(
+            torch.zeros_like(v[..., 0]), v[..., 0], v[..., 1], v[..., 2]
+        )
+
+        rotated_v_quat = self * v_quat * self.conjugate()
+        return torch.stack(
+            [rotated_v_quat[..., 1], rotated_v_quat[..., 2], rotated_v_quat[..., 3]],
+            dim=-1,
+        )
+
+    def slerp(self, other: "Quaternion", t: float | torch.Tensor):
+        CHECK_OPERAND_SHAPE(other, scalar_allowed=False)
+        if self.shape != other.shape:
+            raise ValueError("Quaternions must have the same shape for slerp.")
+        if isinstance(t, (int, float)):
+            t = torch.tensor(t, device=self.device, dtype=self.dtype)
+
+        return self * (self.inverse() * other) ** t
+
+    @implements(torch.log)
+    def log(self):
+        w, x, y, z = self.to_wxyz()
+        v_norm = torch.sqrt(x**2 + y**2 + z**2)
+        v_norm = torch.where(
+            v_norm < 1e-8,
+            torch.tensor(1e-8, device=v_norm.device, dtype=v_norm.dtype),
+            v_norm,
+        )
+        theta = torch.atan2(v_norm, w)
+        coeff = theta / v_norm
+        return Quaternion(
+            torch.stack([0.0 * w, x * coeff, y * coeff, z * coeff], dim=-1)
+        )
+
+    @implements(torch.exp)
+    def exp(self):
+        w, x, y, z = self.to_wxyz()
+        v_norm = torch.sqrt(x**2 + y**2 + z**2)
+        exp_w = torch.exp(w)
+        cos_v_norm = torch.cos(v_norm)
+        sin_v_norm = torch.sin(v_norm)
+        coeff = torch.where(
+            v_norm < 1e-8,
+            torch.tensor(1.0, device=v_norm.device, dtype=v_norm.dtype),
+            sin_v_norm / v_norm,
+        )
+        return Quaternion(
+            torch.stack(
+                [
+                    exp_w * cos_v_norm,
+                    exp_w * x * coeff,
+                    exp_w * y * coeff,
+                    exp_w * z * coeff,
+                ],
+                dim=-1,
+            )
+        )
+
+    @implements(torch.pow)
+    def pow(self, exponent: float | torch.Tensor):
+        if isinstance(exponent, (int, float)):
+            exponent = torch.tensor(exponent, device=self.device, dtype=self.dtype)
+        if exponent.dim() == 0:
+            exponent = exponent.unsqueeze(0)
+
+        log_q = self.log()
+        scaled_log_q = Quaternion(log_q * exponent)
+        return scaled_log_q.exp()