CPax 2026.10.0__tar.gz

cpax-2026.10.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jan Lukas Späh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cpax-2026.10.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: CPax
+Version: 2026.10.0
+Summary: CPax: A JAX-based computational physics library.
+Author: Jan Lukas Späh
+License: MIT
+Project-URL: Source, https://github.com/JaLuka98/CPax
+Project-URL: Tracker, https://github.com/JaLuka98/CPax/issues
+Keywords: physics,computational,jax,autograd,ODE,PDE
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: diffrax<0.8,>=0.7.2
+Requires-Dist: equinox>=0.13.8
+Requires-Dist: jax>=0.11
+Requires-Dist: numpy>=2.0
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: pillow>=13.0.0
+Dynamic: license-file
+
+# CPax
+
+**CPax** is an open-source, JAX-based library for computational physics.
+It separates physical **systems**, **problems**, **solvers** and
+**solutions** in reusable workflows. The current implementation supports
+continuous-time initial-value problems and classical mechanics; additional
+physical domains are planned, not yet implemented.
+
+**[Documentation](https://cpax.readthedocs.io/en/latest/)** ·
+**[Source](https://github.com/JaLuka98/CPax)** ·
+**[Issues](https://github.com/JaLuka98/CPax/issues)**
+
+## Installation
+
+Clone the repository, then run `uv sync` to create a reproducible
+development environment. CPax currently requires Python 3.12 or newer.
+
+## Quickstart
+
+```python
+import cpax
+from cpax.mechanics import NewtonianSystem, PhaseSpaceState
+
+system = NewtonianSystem(potential=lambda q: q**2 / 2, mass=1.0)
+problem = cpax.IVP(system, PhaseSpaceState(1.0, 0.0), (0.0, 10.0))
+solution = cpax.solve(problem, saveat=cpax.SaveAt.linspace(500))
+
+print(solution.ys.q)  # Position
+print(solution.ys.p)  # Canonical momentum
+```
+
+The same workflow supports the conservative Duffing oscillator, the
+built-in `cpax.dynamics.LorenzSystem`, and multibody Newtonian gravity.
+See the [examples](examples/) and documentation for complete scripts,
+plots, and the animated Sun–Earth–Mars–Jupiter–comet showcase.
+
+The default `solver="auto"` currently selects Diffrax Tsit5 for IVPs.
+It does not infer stiffness or symplectic structure. A standalone
+symplectic leapfrog integrator is preserved in `cpax.ode`.
+
+## Development
+
+CPax uses **uv**, **Ruff**, and **ty**:
+
+```shell
+uv sync
+uv run pytest
+uv run ruff check .
+uv run ruff format --check .
+uv run ty check
+uv run sphinx-build -W -b html docs/source docs/_build/html
+```
+
+Releases use calendar versions `YYYY.M.N`. The manual GitHub Actions
+release workflow supports non-publishing previews and publishing from
+`main`. See the workflow for its latest controls and validation. Publishing to PyPI\nis a separate, manually approved process described in\n[the release guide](docs/publishing.md).

cpax-2026.10.0/README.md

@@ -0,0 +1,56 @@
+# CPax
+
+**CPax** is an open-source, JAX-based library for computational physics.
+It separates physical **systems**, **problems**, **solvers** and
+**solutions** in reusable workflows. The current implementation supports
+continuous-time initial-value problems and classical mechanics; additional
+physical domains are planned, not yet implemented.
+
+**[Documentation](https://cpax.readthedocs.io/en/latest/)** ·
+**[Source](https://github.com/JaLuka98/CPax)** ·
+**[Issues](https://github.com/JaLuka98/CPax/issues)**
+
+## Installation
+
+Clone the repository, then run `uv sync` to create a reproducible
+development environment. CPax currently requires Python 3.12 or newer.
+
+## Quickstart
+
+```python
+import cpax
+from cpax.mechanics import NewtonianSystem, PhaseSpaceState
+
+system = NewtonianSystem(potential=lambda q: q**2 / 2, mass=1.0)
+problem = cpax.IVP(system, PhaseSpaceState(1.0, 0.0), (0.0, 10.0))
+solution = cpax.solve(problem, saveat=cpax.SaveAt.linspace(500))
+
+print(solution.ys.q)  # Position
+print(solution.ys.p)  # Canonical momentum
+```
+
+The same workflow supports the conservative Duffing oscillator, the
+built-in `cpax.dynamics.LorenzSystem`, and multibody Newtonian gravity.
+See the [examples](examples/) and documentation for complete scripts,
+plots, and the animated Sun–Earth–Mars–Jupiter–comet showcase.
+
+The default `solver="auto"` currently selects Diffrax Tsit5 for IVPs.
+It does not infer stiffness or symplectic structure. A standalone
+symplectic leapfrog integrator is preserved in `cpax.ode`.
+
+## Development
+
+CPax uses **uv**, **Ruff**, and **ty**:
+
+```shell
+uv sync
+uv run pytest
+uv run ruff check .
+uv run ruff format --check .
+uv run ty check
+uv run sphinx-build -W -b html docs/source docs/_build/html
+```
+
+Releases use calendar versions `YYYY.M.N`. The manual GitHub Actions
+release workflow supports non-publishing previews and publishing from
+`main`. See the workflow for its latest controls and validation. Publishing to PyPI\nis a separate, manually approved process described in\n[the release guide](docs/publishing.md).

cpax-2026.10.0/pyproject.toml

@@ -0,0 +1,109 @@
+[build-system]
+requires = ["setuptools>=65.5", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "CPax"
+version = "2026.10.0"
+description = "CPax: A JAX-based computational physics library."
+requires-python = ">=3.12"
+authors = [
+  { name = "Jan Lukas Späh"}
+]
+license = { text = "MIT" }
+readme = "README.md"
+keywords = ["physics", "computational", "jax", "autograd", "ODE", "PDE"]
+classifiers = [
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "License :: OSI Approved :: MIT License"
+]
+
+dependencies = [
+  "diffrax>=0.7.2,<0.8",
+  "equinox>=0.13.8",
+  "jax>=0.11",
+  "numpy>=2.0",
+  "matplotlib>=3.7",
+  "pillow>=13.0.0",
+]
+
+[dependency-groups]
+test = [
+  "bump-my-version",
+  "packaging>=24",
+  "pytest",
+]
+lint = [
+  "ruff==0.17.0",
+  "ty==0.0.86",
+]
+docs = [
+  "sphinx>=5.0",
+  "sphinx-rtd-theme",
+  "sphinx-autodoc-typehints",
+  "sphinx-autoapi",
+  "myst-parser",
+]
+dev = [
+  { include-group = "test" },
+  { include-group = "lint" },
+  { include-group = "docs" },
+]
+
+[project.urls]
+"Source" = "https://github.com/JaLuka98/CPax"
+"Tracker" = "https://github.com/JaLuka98/CPax/issues"
+
+
+[tool.bumpversion]
+parse = '^(?P<release>[1-9][0-9]{3}\.(?:1[0-2]|0?[1-9]))\.(?P<patch>[0-9]+)$'
+serialize = ["{release}.{patch}"]
+commit = false
+tag = false
+tag_name = "v{new_version}"
+
+[tool.bumpversion.parts.release]
+calver_format = "{YYYY}.{MM}"
+
+[[tool.bumpversion.files]]
+filename = "pyproject.toml"
+search = 'version = "{current_version}"'
+replace = 'version = "{new_version}"'
+[tool.uv]
+required-version = ">=0.13.4"
+[tool.ruff]
+target-version = "py312"
+line-length = 119
+
+[tool.ruff.lint]
+select = [
+  "E4",   # Import conventions
+  "E7",   # Statement conventions
+  "E9",   # Syntax errors
+  "F",    # Pyflakes
+  "I",    # isort
+  "UP",   # Modern Python syntax
+  "B",    # flake8-bugbear
+  "SIM",  # flake8-simplify
+  "C4",   # flake8-comprehensions
+  "PIE",  # flake8-pie
+  "RUF",  # Ruff-specific correctness checks
+  "NPY",  # NumPy correctness
+  "PERF", # Perflint
+]
+
+[tool.ruff.lint.per-file-ignores]
+"src/cpax/__init__.py" = ["F401"]
+"src/cpax/ode/__init__.py" = ["F401"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+docstring-code-format = true
+
+# Type-check the public library. Tests and examples can be added after the
+# scientific API has been fully annotated.
+[tool.ty.src]
+include = ["src"]

cpax-2026.10.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cpax-2026.10.0/src/CPax.egg-info/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: CPax
+Version: 2026.10.0
+Summary: CPax: A JAX-based computational physics library.
+Author: Jan Lukas Späh
+License: MIT
+Project-URL: Source, https://github.com/JaLuka98/CPax
+Project-URL: Tracker, https://github.com/JaLuka98/CPax/issues
+Keywords: physics,computational,jax,autograd,ODE,PDE
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: diffrax<0.8,>=0.7.2
+Requires-Dist: equinox>=0.13.8
+Requires-Dist: jax>=0.11
+Requires-Dist: numpy>=2.0
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: pillow>=13.0.0
+Dynamic: license-file
+
+# CPax
+
+**CPax** is an open-source, JAX-based library for computational physics.
+It separates physical **systems**, **problems**, **solvers** and
+**solutions** in reusable workflows. The current implementation supports
+continuous-time initial-value problems and classical mechanics; additional
+physical domains are planned, not yet implemented.
+
+**[Documentation](https://cpax.readthedocs.io/en/latest/)** ·
+**[Source](https://github.com/JaLuka98/CPax)** ·
+**[Issues](https://github.com/JaLuka98/CPax/issues)**
+
+## Installation
+
+Clone the repository, then run `uv sync` to create a reproducible
+development environment. CPax currently requires Python 3.12 or newer.
+
+## Quickstart
+
+```python
+import cpax
+from cpax.mechanics import NewtonianSystem, PhaseSpaceState
+
+system = NewtonianSystem(potential=lambda q: q**2 / 2, mass=1.0)
+problem = cpax.IVP(system, PhaseSpaceState(1.0, 0.0), (0.0, 10.0))
+solution = cpax.solve(problem, saveat=cpax.SaveAt.linspace(500))
+
+print(solution.ys.q)  # Position
+print(solution.ys.p)  # Canonical momentum
+```
+
+The same workflow supports the conservative Duffing oscillator, the
+built-in `cpax.dynamics.LorenzSystem`, and multibody Newtonian gravity.
+See the [examples](examples/) and documentation for complete scripts,
+plots, and the animated Sun–Earth–Mars–Jupiter–comet showcase.
+
+The default `solver="auto"` currently selects Diffrax Tsit5 for IVPs.
+It does not infer stiffness or symplectic structure. A standalone
+symplectic leapfrog integrator is preserved in `cpax.ode`.
+
+## Development
+
+CPax uses **uv**, **Ruff**, and **ty**:
+
+```shell
+uv sync
+uv run pytest
+uv run ruff check .
+uv run ruff format --check .
+uv run ty check
+uv run sphinx-build -W -b html docs/source docs/_build/html
+```
+
+Releases use calendar versions `YYYY.M.N`. The manual GitHub Actions
+release workflow supports non-publishing previews and publishing from
+`main`. See the workflow for its latest controls and validation. Publishing to PyPI\nis a separate, manually approved process described in\n[the release guide](docs/publishing.md).

cpax-2026.10.0/src/CPax.egg-info/SOURCES.txt

@@ -0,0 +1,43 @@
+LICENSE
+README.md
+pyproject.toml
+src/CPax.egg-info/PKG-INFO
+src/CPax.egg-info/SOURCES.txt
+src/CPax.egg-info/dependency_links.txt
+src/CPax.egg-info/requires.txt
+src/CPax.egg-info/top_level.txt
+src/cpax/__init__.py
+src/cpax/_backends/__init__.py
+src/cpax/_backends/_diffrax.py
+src/cpax/dynamics/__init__.py
+src/cpax/dynamics/_lorenz.py
+src/cpax/dynamics/_systems.py
+src/cpax/mechanics/__init__.py
+src/cpax/mechanics/_gravity.py
+src/cpax/mechanics/_hamiltonian.py
+src/cpax/mechanics/_newtonian.py
+src/cpax/mechanics/_state.py
+src/cpax/ode/__init__.py
+src/cpax/ode/integrators.py
+src/cpax/problems/__init__.py
+src/cpax/problems/_ivp.py
+src/cpax/results/__init__.py
+src/cpax/results/_solution.py
+src/cpax/solvers/__init__.py
+src/cpax/solvers/_auto.py
+src/cpax/solvers/_saveat.py
+src/cpax/solvers/_solve.py
+tests/test_dynamics.py
+tests/test_examples.py
+tests/test_gravity.py
+tests/test_leapfrog.py
+tests/test_lorenz.py
+tests/test_mechanics.py
+tests/test_mechanics_state.py
+tests/test_problems.py
+tests/test_pypi_tag.py
+tests/test_results.py
+tests/test_saveat.py
+tests/test_solve.py
+tests/test_solve_jax.py
+tests/test_versioning.py

cpax-2026.10.0/src/CPax.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cpax-2026.10.0/src/CPax.egg-info/requires.txt

@@ -0,0 +1,6 @@
+diffrax<0.8,>=0.7.2
+equinox>=0.13.8
+jax>=0.11
+numpy>=2.0
+matplotlib>=3.7
+pillow>=13.0.0

cpax-2026.10.0/src/CPax.egg-info/top_level.txt

@@ -0,0 +1 @@
+cpax

cpax-2026.10.0/src/cpax/__init__.py

@@ -0,0 +1,9 @@
+"""CPax public physics-first API."""
+
+from importlib.metadata import version as _distribution_version
+
+__version__ = _distribution_version("CPax")
+
+from . import dynamics, mechanics, ode
+from .problems import IVP
+from .solvers import SaveAt, solve

cpax-2026.10.0/src/cpax/_backends/__init__.py

@@ -0,0 +1 @@
+"""Private numerical backend adapters. Not a public CPax namespace."""

cpax-2026.10.0/src/cpax/_backends/_diffrax.py

@@ -0,0 +1,105 @@
+"""Private Diffrax adapter for continuous-time initial-value problems."""
+
+from typing import Any
+
+import diffrax
+import jax
+import jax.numpy as jnp
+import numpy as np
+from jax.core import Tracer
+
+from cpax.dynamics._systems import Time
+from cpax.problems import IVP
+from cpax.results import Solution, SolutionStatus
+
+
+def _resolve_saveat(policy: Any, t_span: tuple[Time, Time]) -> diffrax.SaveAt:
+    """Resolve a CPax sampling policy against its problem's interval."""
+    t0, t1 = t_span
+
+    if policy.kind == "final":
+        return diffrax.SaveAt(t1=True)
+
+    if policy.kind == "linspace":
+        return diffrax.SaveAt(ts=jnp.linspace(t0, t1, policy.n))
+
+    if policy.kind == "at":
+        times = policy.times
+        if times is None:
+            raise ValueError("SaveAt.at requires an array of times.")
+        # Concrete checks provide an immediate, intelligible error. Diffrax
+        # itself handles the admissibility of traced times during solving.
+        if not any(isinstance(value, Tracer) for value in (t0, t1, times)):
+            interval_start = float(np.asarray(t0))
+            interval_end = float(np.asarray(t1))
+            concrete_times = np.asarray(times)
+            if np.any(concrete_times < interval_start) or np.any(concrete_times > interval_end):
+                raise ValueError("SaveAt.at times must lie within the IVP time interval.")
+        return diffrax.SaveAt(ts=times)
+
+    raise ValueError(f"Unsupported SaveAt policy: {policy.kind!r}.")
+
+
+def solve_diffrax(
+    problem: IVP,
+    *,
+    solver: diffrax.AbstractSolver,
+    solver_selection: str,
+    saveat: Any,
+    dt0: float | jax.Array | None,
+    stepsize_controller: diffrax.AbstractStepSizeController,
+    max_steps: int,
+    throw: bool,
+) -> Solution:
+    """Translate a CPax IVP into a Diffrax solve and back into CPax."""
+
+    def vector_field(
+        t: float | jax.Array | np.ndarray,
+        state: Any,
+        args: Any,
+        /,
+    ) -> Any:
+        """Adapt Diffrax's scalar-like time input to CPax's time interface."""
+        return problem.system.vector_field(jnp.asarray(t), state, args)
+
+    t0, t1 = problem.t_span
+    backend_solution = diffrax.diffeqsolve(
+        terms=diffrax.ODETerm(vector_field),
+        solver=solver,
+        t0=t0,
+        t1=t1,
+        dt0=dt0,
+        y0=problem.y0,
+        args=problem.args,
+        saveat=_resolve_saveat(saveat, problem.t_span),
+        stepsize_controller=stepsize_controller,
+        max_steps=max_steps,
+        throw=throw,
+    )
+    # Keep the numerical status JAX-traceable: never convert the result
+    # to a Python boolean/string inside a compiled integration.
+    # Diffrax returns an Equinox EnumerationItem, not a numeric JAX array.
+    # Its comparison operator yields a JAX-compatible scalar. Preserve the
+    # original result in metadata to retain precise backend failure reasons.
+    status = jnp.where(
+        backend_solution.result == diffrax.RESULTS.successful,
+        int(SolutionStatus.SUCCESS),
+        int(SolutionStatus.FAILED),
+    )
+    return Solution(
+        ts=backend_solution.ts,
+        ys=backend_solution.ys,
+        status=status,
+        stats=dict(backend_solution.stats),
+        metadata={
+            "backend": "diffrax",
+            "solver": type(solver).__name__,
+            "solver_selection": solver_selection,
+            "stepsize_controller": type(stepsize_controller).__name__,
+            "dt0": dt0,
+            "rtol": (stepsize_controller.rtol if isinstance(stepsize_controller, diffrax.PIDController) else None),
+            "atol": (stepsize_controller.atol if isinstance(stepsize_controller, diffrax.PIDController) else None),
+            "max_steps": max_steps,
+            "backend_result": backend_solution.result,
+        },
+    )

cpax-2026.10.0/src/cpax/dynamics/__init__.py

@@ -0,0 +1,6 @@
+"""Continuous-time dynamical systems and user-defined vector fields."""
+
+from ._lorenz import LorenzSystem
+from ._systems import DynamicalSystem, VectorFieldSystem
+
+__all__ = ["DynamicalSystem", "LorenzSystem", "VectorFieldSystem"]

cpax-2026.10.0/src/cpax/dynamics/_lorenz.py

@@ -0,0 +1,43 @@
+"""The autonomous Lorenz system."""
+
+from typing import Any
+
+import jax
+import jax.numpy as jnp
+
+from ._systems import DynamicalSystem
+
+
+class LorenzSystem(DynamicalSystem):
+    """The three-dimensional Lorenz equations.
+
+    Parameters default to the classical chaotic regime. The state is a
+    floating-point array of shape (3,). Parameters are JAX arrays and may
+    be differentiated when used in a supported solver configuration.
+    """
+
+    sigma: jax.Array
+    rho: jax.Array
+    beta: jax.Array
+
+    def __init__(
+        self,
+        sigma: float | jax.Array = 10.0,
+        rho: float | jax.Array = 28.0,
+        beta: float | jax.Array = 8.0 / 3.0,
+    ) -> None:
+        for name, value in (("sigma", sigma), ("rho", rho), ("beta", beta)):
+            array = jnp.asarray(value)
+            if array.shape != () or array.dtype.kind not in "iuf":
+                raise TypeError(f"{name} must be a real numeric scalar.")
+            object.__setattr__(self, name, jnp.asarray(value, dtype=jnp.result_type(float, array)))
+
+    def vector_field(self, t: Any, state: jax.Array, args: Any = None) -> jax.Array:
+        """Return the Lorenz vector field with the shape of `state`."""
+        del t
+        if args is not None:
+            raise ValueError("LorenzSystem does not support IVP.args; set system parameters instead.")
+        if not hasattr(state, "shape") or state.shape != (3,):
+            raise ValueError("LorenzSystem requires an array state of shape (3,).")
+        x, y, z = state
+        return jnp.stack((self.sigma * (y - x), x * (self.rho - z) - y, x * y - self.beta * z))

cpax-2026.10.0/src/cpax/dynamics/_systems.py

@@ -0,0 +1,55 @@
+"""Shared continuous-time dynamical-system interfaces.
+
+These systems specify equations of motion, not numerical solution methods.
+They deliberately do not depend on physical domains or integration backends.
+"""
+
+from abc import abstractmethod
+from collections.abc import Callable
+from typing import Any
+
+import equinox as eqx
+import jax
+
+type Time = float | jax.Array
+type State = Any  # Array-valued PyTree; concrete state types are model-specific.
+type Args = Any
+
+
+class DynamicalSystem(eqx.Module):
+    """Base interface for continuous-time evolution.
+
+    Subclasses implement ``vector_field(t, state, args=None)`` and return
+    derivatives with the same PyTree structure and leaf shapes as ``state``.
+    Time is the first argument, including for autonomous systems.
+    """
+
+    @abstractmethod
+    def vector_field(
+        self,
+        t: Time,
+        state: State,
+        args: Args = None,
+    ) -> State:
+        """Evaluate the instantaneous derivative of ``state`` at ``t``."""
+        raise NotImplementedError
+
+
+class VectorFieldSystem(DynamicalSystem):
+    """Wrap a user-supplied vector field as a continuous-time system.
+
+    ``rhs`` has signature ``rhs(t, state, args)``. It may be a plain
+    Python function or a callable Equinox module with differentiable array
+    parameters. It is intentionally not marked as a static field.
+    """
+
+    rhs: Callable[[Time, State, Args], State]
+
+    def vector_field(
+        self,
+        t: Time,
+        state: State,
+        args: Args = None,
+    ) -> State:
+        """Evaluate the wrapped vector field without modifying the state."""
+        return self.rhs(t, state, args)

cpax-2026.10.0/src/cpax/mechanics/__init__.py

@@ -0,0 +1,8 @@
+"""Physics-first classical mechanics systems and potential helpers."""
+
+from ._gravity import gravitational_potential
+from ._hamiltonian import HamiltonianSystem
+from ._newtonian import NewtonianSystem
+from ._state import PhaseSpaceState
+
+__all__ = ["HamiltonianSystem", "NewtonianSystem", "PhaseSpaceState", "gravitational_potential"]