spacecore 0.2.0__tar.gz → 0.3.0__tar.gz

{spacecore-0.2.0 → spacecore-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spacecore
-Version: 0.2.0
+Version: 0.3.0
 Summary: Backend-agnostic vector spaces and linear operators.
 Author: Pavlo Pelikh
 License-Expression: Apache-2.0
@@ -56,7 +56,7 @@ import numpy as np
 
 # Define a space, a linear operator, and solve Ax = b
 ctx = sc.Context(sc.NumpyOps(), dtype=np.float64)
-X = sc.VectorSpace((100,), ctx)
+X = sc.DenseCoordinateSpace((100,), ctx)
 A = sc.DenseLinOp(np.random.randn(100, 100) @ np.random.randn(100, 100).T + np.eye(100), X, X, ctx)
 b = ctx.asarray(np.random.randn(100))
 
@@ -116,10 +116,10 @@ result = sc.lanczos_smallest(A, initial_vector, max_iter=50)
 print(f"E_0 = {result.eigenvalue}, converged={result.converged}")
 ```
 
-**3. Custom Hilbert spaces with non-Euclidean geometry.** Subclass `VectorSpace`, override `inner`, and every solver respects your geometry:
+**3. Custom Hilbert spaces with non-Euclidean geometry.** Subclass `DenseCoordinateSpace`, override `inner`, and every solver respects your geometry:
 
 ```python
-class WeightedL2(sc.VectorSpace):
+class WeightedL2(sc.DenseCoordinateSpace):
     def __init__(self, shape, weights, ctx=None):
         super().__init__(shape, ctx)
         self.weights = self.ctx.asarray(weights)
@@ -140,7 +140,7 @@ This is the basis for RKHS spaces, truncated Fock spaces (quantum many-body), fu
 import spacecore as sc
 
 ctx = sc.Context(sc.NumpyOps(), dtype=np.float64)
-X = sc.VectorSpace((1000,), ctx)
+X = sc.DenseCoordinateSpace((1000,), ctx)
 A = sc.DenseLinOp(make_spd_matrix(), X, X, ctx)
 b = ctx.asarray(rhs)
 
@@ -203,7 +203,7 @@ This operator works on NumPy, JAX, and PyTorch backends without modification.
 
 ## Features at a glance
 
-**Spaces.** `VectorSpace`, `HermitianSpace`, `ProductSpace`, `BatchSpace`. All easy to subclass for custom geometry.
+**Spaces.** `DenseCoordinateSpace`, `DenseVectorSpace`, `ElementwiseJordanSpace`, `EuclideanElementwiseJordanSpace`, `HermitianSpace`, `ProductSpace`, and `StackedSpace`. Generic dense spaces can use custom inner products; `DenseVectorSpace` has no Jordan capability by default; real Euclidean elementwise spaces get the Euclidean-Jordan capability.
 
 **Linear operators.** `DenseLinOp`, `SparseLinOp`, `DiagonalLinOp`, `MatrixFreeLinOp`, plus operator algebra (`A @ B`, `A + B`, `2 * A`, `A.H`, `IdentityLinOp`, `ZeroLinOp`).
 
@@ -215,7 +215,7 @@ This operator works on NumPy, JAX, and PyTorch backends without modification.
 
 ## Project status
 
-**v0.2 alpha.** API may still change in minor ways. Core abstractions are stable. Suitable for research code; not yet recommended for production deployment.
+**v0.3 alpha.** API may still change in minor ways. Core abstractions are stable. Suitable for research code; not yet recommended for production deployment.
 
 The library is being developed in the open and is looking for early users and feedback. If you try it on your problem, please open an issue with what worked and what didn't — that's the single most valuable contribution right now.
 

{spacecore-0.2.0 → spacecore-0.3.0}/README.md

@@ -15,7 +15,7 @@ import numpy as np
 
 # Define a space, a linear operator, and solve Ax = b
 ctx = sc.Context(sc.NumpyOps(), dtype=np.float64)
-X = sc.VectorSpace((100,), ctx)
+X = sc.DenseCoordinateSpace((100,), ctx)
 A = sc.DenseLinOp(np.random.randn(100, 100) @ np.random.randn(100, 100).T + np.eye(100), X, X, ctx)
 b = ctx.asarray(np.random.randn(100))
 
@@ -75,10 +75,10 @@ result = sc.lanczos_smallest(A, initial_vector, max_iter=50)
 print(f"E_0 = {result.eigenvalue}, converged={result.converged}")
 ```
 
-**3. Custom Hilbert spaces with non-Euclidean geometry.** Subclass `VectorSpace`, override `inner`, and every solver respects your geometry:
+**3. Custom Hilbert spaces with non-Euclidean geometry.** Subclass `DenseCoordinateSpace`, override `inner`, and every solver respects your geometry:
 
 ```python
-class WeightedL2(sc.VectorSpace):
+class WeightedL2(sc.DenseCoordinateSpace):
     def __init__(self, shape, weights, ctx=None):
         super().__init__(shape, ctx)
         self.weights = self.ctx.asarray(weights)
@@ -99,7 +99,7 @@ This is the basis for RKHS spaces, truncated Fock spaces (quantum many-body), fu
 import spacecore as sc
 
 ctx = sc.Context(sc.NumpyOps(), dtype=np.float64)
-X = sc.VectorSpace((1000,), ctx)
+X = sc.DenseCoordinateSpace((1000,), ctx)
 A = sc.DenseLinOp(make_spd_matrix(), X, X, ctx)
 b = ctx.asarray(rhs)
 
@@ -162,7 +162,7 @@ This operator works on NumPy, JAX, and PyTorch backends without modification.
 
 ## Features at a glance
 
-**Spaces.** `VectorSpace`, `HermitianSpace`, `ProductSpace`, `BatchSpace`. All easy to subclass for custom geometry.
+**Spaces.** `DenseCoordinateSpace`, `DenseVectorSpace`, `ElementwiseJordanSpace`, `EuclideanElementwiseJordanSpace`, `HermitianSpace`, `ProductSpace`, and `StackedSpace`. Generic dense spaces can use custom inner products; `DenseVectorSpace` has no Jordan capability by default; real Euclidean elementwise spaces get the Euclidean-Jordan capability.
 
 **Linear operators.** `DenseLinOp`, `SparseLinOp`, `DiagonalLinOp`, `MatrixFreeLinOp`, plus operator algebra (`A @ B`, `A + B`, `2 * A`, `A.H`, `IdentityLinOp`, `ZeroLinOp`).
 
@@ -174,7 +174,7 @@ This operator works on NumPy, JAX, and PyTorch backends without modification.
 
 ## Project status
 
-**v0.2 alpha.** API may still change in minor ways. Core abstractions are stable. Suitable for research code; not yet recommended for production deployment.
+**v0.3 alpha.** API may still change in minor ways. Core abstractions are stable. Suitable for research code; not yet recommended for production deployment.
 
 The library is being developed in the open and is looking for early users and feedback. If you try it on your problem, please open an issue with what worked and what didn't — that's the single most valuable contribution right now.
 

{spacecore-0.2.0 → spacecore-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spacecore"
-version = "0.2.0"
+dynamic = ["version"]
 description = "Backend-agnostic vector spaces and linear operators."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -68,6 +68,9 @@ dev = [
 [tool.setuptools]
 include-package-data = true
 
+[tool.setuptools.dynamic]
+version = {attr = "spacecore._version.__version__"}
+
 [tool.setuptools.packages.find]
 where = ["."]
 include = ["spacecore*"]

{spacecore-0.2.0 → spacecore-0.3.0}/spacecore/__init__.py

@@ -1,14 +1,12 @@
 """Backend-agnostic vector spaces, linear operators, and solvers."""
 
-from importlib.metadata import version as _version
+from ._version import __version__
 
+from .backend import Context, BackendOps, NumpyOps, jax_pytree_class
 try:
-    __version__ = _version("spacecore")
-except Exception:
-    __version__ = "0.0.0+unknown"
-
-
-from .backend import Context, BackendOps, JaxOps, NumpyOps, jax_pytree_class
+    from .backend import JaxOps as JaxOps
+except ImportError:
+    pass
 try:
     from .backend import CuPyOps as CuPyOps
 except ImportError:
@@ -58,18 +56,34 @@ from .linalg import (
     power_iteration,
 )
 from .space import (
-    BatchSpace,
     BackendCheck,
     DTypeCheck,
     HermitianCheck,
     ProductComponentCheck,
+    CoordinateSpace,
+    DenseCoordinateSpace,
+    DenseVectorSpace,
+    ElementwiseJordanSpace,
+    EuclideanElementwiseJordanSpace,
+    EuclideanJordanAlgebraSpace,
+    InnerProductSpace,
+    JordanAlgebraSpace,
     ProductSpace,
+    ProductSpectralDecomposition,
+    ProductStructure,
     ProductStructureCheck,
+    PytreeStructure,
+    StackedSpace,
     ShapeCheck,
+    InnerProduct,
+    EuclideanInnerProduct,
+    WeightedInnerProduct,
     Space,
+    StarSpace,
     SpaceCheck,
     SpaceValidationError,
     SquareMatrixCheck,
+    TupleStructure,
     VectorSpace,
     HermitianSpace,
 )
@@ -81,12 +95,11 @@ from ._contextual import (
     set_context, get_context,
     resolve_context_priority,
     register_ops,
-    set_resolution_policy, set_dtype_resolution_policy,
-    get_resolution_policy, get_dtype_resolution_policy,
     normalize_ops, normalize_context,
 )
 
 __all__ = [
+    "__version__",
     "Context",
 
     "BackendOps",
@@ -137,10 +150,26 @@ __all__ = [
     "ProductComponentCheck",
     "ProductStructureCheck",
     "ShapeCheck",
-    "BatchSpace",
+    "InnerProduct",
+    "EuclideanInnerProduct",
+    "WeightedInnerProduct",
     "VectorSpace",
     "HermitianSpace",
     "ProductSpace",
+    "ProductStructure",
+    "TupleStructure",
+    "PytreeStructure",
+    "StackedSpace",
+    "CoordinateSpace",
+    "InnerProductSpace",
+    "StarSpace",
+    "JordanAlgebraSpace",
+    "EuclideanJordanAlgebraSpace",
+    "DenseCoordinateSpace",
+    "DenseVectorSpace",
+    "ElementwiseJordanSpace",
+    "EuclideanElementwiseJordanSpace",
+    "ProductSpectralDecomposition",
     "Space",
     "SpaceCheck",
     "SpaceValidationError",
@@ -156,10 +185,6 @@ __all__ = [
     "get_context",
     "resolve_context_priority",
     "register_ops",
-    "set_resolution_policy",
-    "set_dtype_resolution_policy",
-    "get_resolution_policy",
-    "get_dtype_resolution_policy",
     "normalize_ops",
     "normalize_context",
 ]

spacecore-0.3.0/spacecore/_batching.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .space.checks import _run_checks
+
+
+def _check_batched(space: Any, xs: Any) -> None:
+    """Raise if ``xs`` does not have ``space.shape`` as trailing dimensions."""
+    _run_checks(space, xs, allow_leading=True)
+
+
+def _batched_inner(space: Any, xs: Any, ys: Any) -> Any:
+    """Return ``space.inner(xs[i], ys[i])`` for a leading-axis batch."""
+    xs_flat = space.flatten_batch(xs)
+    ys_dual = ys if space.is_euclidean else space.riesz(ys)
+    ys_flat = space.flatten_batch(ys_dual)
+    return space.ops.sum(space.ops.conj(xs_flat) * ys_flat, axis=1)

{spacecore-0.2.0 → spacecore-0.3.0}/spacecore/_checks.py

@@ -29,6 +29,8 @@ def checked_method(
     out_space: str | None = None,
     arg_pos: int | None = None,
     arg_positions: int | tuple[int, ...] | None = None,
+    in_batched: bool = False,
+    out_batched: bool = False,
 ) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
     """
     Build a decorator that validates method inputs and outputs against spaces.
@@ -48,6 +50,10 @@ def checked_method(
     arg_positions : int, tuple of int, or None, optional
         Zero-based positions in ``*args`` of input values that should be checked
         against ``in_space``. Defaults to ``(0,)``.
+    in_batched : bool, optional
+        Validate inputs as leading-axis batches instead of single elements.
+    out_batched : bool, optional
+        Validate outputs as leading-axis batches instead of single elements.
 
     Returns
     -------
@@ -64,12 +70,23 @@ def checked_method(
             if self._enable_checks and in_space is not None:
                 check_target = _space_target(self, in_space)
                 for pos in positions:
-                    check_target._check_member(args[pos])
+                    if in_batched:
+                        from ._batching import _check_batched
+
+                        _check_batched(check_target, args[pos])
+                    else:
+                        check_target._check_member(args[pos])
 
             y = method(self, *args, **kwargs)
 
             if self._enable_checks and out_space is not None:
-                _space_target(self, out_space)._check_member(y)
+                check_target = _space_target(self, out_space)
+                if out_batched:
+                    from ._batching import _check_batched
+
+                    _check_batched(check_target, y)
+                else:
+                    check_target._check_member(y)
 
             return y
 

{spacecore-0.2.0 → spacecore-0.3.0}/spacecore/_contextual/__init__.py

@@ -1,45 +1,31 @@
 from ._bound import ContextBound as ContextBound
-from ._manager import (
+from ._state import (
     enforce_convert_policy as enforce_convert_policy,
     get_context as get_context,
-    get_dtype_resolution_policy as get_dtype_resolution_policy,
-    get_resolution_policy as get_resolution_policy,
     normalize_context as normalize_context,
     normalize_ops as normalize_ops,
     register_ops as register_ops,
     resolve_context_priority as resolve_context_priority,
     set_context as set_context,
-    set_dtype_resolution_policy as set_dtype_resolution_policy,
-    set_resolution_policy as set_resolution_policy,
 )
 from ._policies import (
     ContextConflictError as ContextConflictError,
-    ContextConversionError as ContextConversionError,
     ContextError as ContextError,
     ContextInferenceError as ContextInferenceError,
-    ContextPolicy as ContextPolicy,
-    DtypePreservePolicy as DtypePreservePolicy,
     UnknownBackendError as UnknownBackendError,
 )
 
 __all__ = [
     "ContextBound",
     "ContextConflictError",
-    "ContextConversionError",
     "ContextError",
     "ContextInferenceError",
-    "ContextPolicy",
-    "DtypePreservePolicy",
     "UnknownBackendError",
     "enforce_convert_policy",
     "get_context",
-    "get_dtype_resolution_policy",
-    "get_resolution_policy",
     "normalize_context",
     "normalize_ops",
     "register_ops",
     "resolve_context_priority",
     "set_context",
-    "set_dtype_resolution_policy",
-    "set_resolution_policy",
 ]

spacecore-0.3.0/spacecore/_contextual/_bound.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from abc import ABC
+from typing import TYPE_CHECKING, Self
+
+from ..types import DType
+from ._state import enforce_convert_policy, normalize_context
+
+if TYPE_CHECKING:
+    from ..backend import BackendFamily, BackendOps, Context
+
+
+def _same_math_context(left: Context, right: Context) -> bool:
+    """Return whether contexts match for algebra, ignoring validation checks."""
+    return left.ops == right.ops and left.dtype == right.dtype
+
+
+class ContextBound(ABC):
+    """
+    Base class for objects bound to a SpaceCore execution context.
+
+    Parameters
+    ----------
+    ctx : Context, str, or None, optional
+        Context specification used to resolve backend operations, dtype, and
+        validation policy.
+    """
+
+    def __init__(self, ctx: Context | str | None = None):
+        ctx = normalize_context(ctx)
+        self._ctx = ctx
+
+    @property
+    def ops(self) -> BackendOps:
+        """Return backend operations associated with this object's context."""
+        return self.ctx.ops
+
+    @property
+    def dtype(self) -> DType:
+        """Return the default dtype associated with this object's context."""
+        return self.ctx.dtype
+
+    @property
+    def ctx(self) -> Context:
+        """Return the execution context bound to this object."""
+        return self._ctx
+
+    def _convert(self, new_ctx: Context) -> Self:
+        """Rebuild this object in ``new_ctx``."""
+        raise NotImplementedError()
+
+    def convert(self, new_ctx: Context | BackendFamily | str | None = None) -> Self:
+        """Return this object represented in ``new_ctx``."""
+        _, new_ctx = enforce_convert_policy(self, new_ctx)
+        if self.ctx == new_ctx:
+            return self
+        return self._convert(new_ctx)

spacecore-0.3.0/spacecore/_contextual/_policies.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+class ContextError(RuntimeError):
+    pass
+
+
+class ContextInferenceError(ContextError):
+    pass
+
+
+class ContextConflictError(ContextError):
+    pass
+
+
+class UnknownBackendError(ContextError):
+    pass