`unienv_interface.space.spaces.binary`¶

Implementation of a space consisting of finitely many elements.

BinarySpace ¶

BinarySpace(backend: ComputeBackend[BArrayType, BDeviceType, BDtypeType, BRNGType], shape: Sequence[int], dtype: Optional[BDtypeType] = None, device: Optional[BDeviceType] = None, metadata: Optional[Mapping[str, Any]] = None)

Bases: Space[BArrayType, BDeviceType, BDtypeType, BRNGType]

device `property` ¶

device: Optional[_SpaceBDeviceT]

metadata `property` ¶

metadata: SpaceMetadata

Read-only description of the data (see "Metadata" in the class docstring); empty if none was given.

shape `property` ¶

shape: tuple[int, ...] | None

Return the shape of the space as an immutable property.

to ¶

to(backend=None, device=None)

sample ¶

sample(rng: BRNGType) -> Tuple[BRNGType, BArrayType]

create_empty ¶

create_empty()

is_bounded ¶

is_bounded(manner='both')

contains ¶

contains(x: BArrayType) -> bool

clip ¶

clip(x: BArrayType) -> BArrayType

Return x (cast to this space's boolean dtype if needed); see Space.clip.

A binary space is only a subspace of an identical binary space, so any member of a superset is already a member: there is nothing to project. Raises ValueError if x does not have this space's shape.

get_repr ¶

get_repr(abbreviate=False, include_backend=True, include_device=True, include_dtype=True)

is_subspaceeq ¶

is_subspaceeq(other: Any) -> bool

Return whether this binary space is a non-strict subspace of other (⊆).

True iff other is a BinarySpace on the same backend with equal shape and dtype. Since a binary space contains exactly the boolean tensors of its shape, two such spaces are in a subspace relation iff they are structurally identical (modulo device).

data_to ¶

data_to(data, backend=None, device=None)

with_metadata ¶

with_metadata(metadata: Optional[Mapping[str, Any]] = None, /, *, replace: bool = False, **updates: Any) -> Space[SpaceDataT, _SpaceBDeviceT, _SpaceBDTypeT, _SpaceBDRNGT]

Return a copy of this space with updated metadata (this space is left unchanged).

metadata and updates are merged into the current metadata, or replace it entirely with replace=True (space.with_metadata(replace=True) clears it). Nested spaces are shared with this space, not copied.

is_subspace ¶

is_subspace(other: Space) -> bool

Return whether this space is a STRICT subspace of other (self ⊂ other).

Defined uniformly for all spaces as::

self.is_subspace(other)  ⟺  self.is_subspaceeq(other) and not other.is_subspaceeq(self)

I.e. self ⊆ other holds but other ⊆ self does not, so self is a PROPER (strict) subspace of other. This is the ⊂ relation versus the non-strict ⊆ provided by :meth:is_subspaceeq.

This definition is used instead of relying on __eq__ because some space classes only have identity __eq__; defining strict containment via the symmetric non-strict check works uniformly for all classes regardless of their __eq__ implementation.

For structurally-distinct-but-mutually-containing spaces (which should not occur under the strict dtype/shape policies enforced by the per-class is_subspaceeq implementations) this degrades gracefully to False: if both self.is_subspaceeq(other) and other.is_subspaceeq(self) hold, the two spaces are considered equivalent and neither is a STRICT subspace of the other.

If either side's is_subspaceeq is not implemented (the base :meth:is_subspaceeq raises NotImplementedError), the exception propagates to the caller — it is NOT swallowed into False so that callers can tell that the comparison is unsupported.

Note: controller-required-space checks should typically use :meth:is_subspaceeq (a controller's required space may exactly equal the env space, in which case the strict is_subspace would return False).

abbr_device `staticmethod` ¶

abbr_device(spaces: Iterable[Space[Any, _SpaceBDeviceT, _SpaceBDTypeT, _SpaceBDRNGT]]) -> Optional[_SpaceBDeviceT]

Return the shared device across spaces, or None if mixed/empty.

unienv_interface.space.spaces.binary¶