Struct VectorTile 

pub struct VectorTile { /* private fields */ }

The values one vector load brings, as a tile: its extents, finest first, one per axis.

// a plain row-major buffer, four wide
VectorTile::new(&[], N, 4)                                  // [(N, 4)]
// NVFP4 values: a word of 8 along K, 2 words along K, 2 columns; 32 values a load
VectorTile::new(&[(K, 8), (K, 2), (N, 2)], N, 32)           // [(K, 16), (N, 2)]

Implementations

impl VectorTile

pub fn new( stored: &[(Axis, usize)], innermost: Axis, values: usize, ) -> Result<Self, TileMisfit>

The tile a load of values values covers over a buffer stored in stored tiles, finest first (TileSpec::stored_tiles): its finest tiles, fused where one axis continues, until they hold values. Nothing stated, a run of values along innermost.

Errors

A load that would cut a stored tile, one wider than every stored tile together, or one whose axis comes back after another, which is no longer one extent per axis.

pub fn run(axis: Axis, values: usize) -> Self

A run of values along axis: how a plain buffer is loaded.

pub fn extents(&self) -> &[(Axis, usize)]

The extents, finest first.

pub fn space(&self) -> Space

The box one load covers, an axis to each extent.

pub fn values(&self) -> usize

How many values the load brings.

impl VectorTile

load.count(&space), load.start(line, &space), load.index(&coords, &space): written out by hand, since a compile-time value has no kernel-side twin for #[cube] to hang a method on.

pub fn count(&self, space: &Space) -> u32

How many loads a window spanning space holds.

pub fn start(&self, line: u32, space: &Space) -> Coords<u32>

The first value of the line-th load of a window spanning space, one coordinate per axis, the loads counted with the last axis fastest.

pub fn index(&self, coords: &Coords<u32>, space: &Space) -> CoordsDyn

Where the load starting at coords sits in a view of a window spanning space read in these loads: each coordinate divided by the load’s extent along its axis.

pub fn __expand_count_method( &self, scope: &Scope, space: &Space, ) -> NativeExpand<u32>

pub fn __expand_start_method( &self, scope: &Scope, line: NativeExpand<u32>, space: &Space, ) -> <Coords<u32> as CubeType>::ExpandType

pub fn __expand_index_method( &self, scope: &Scope, coords: &<Coords<u32> as CubeType>::ExpandType, space: &Space, ) -> <CoordsDyn as CubeType>::ExpandType

Trait Implementations

impl AsMutExpand for VectorTile

fn __expand_ref_mut_method(&mut self, _scope: &Scope) -> &mut Self

fn __expand_as_mut_method(&mut self, scope: &Scope) -> &mut T

impl AsRefExpand for VectorTile

fn __expand_ref_method(&self, _scope: &Scope) -> &Self

fn __expand_as_ref_method(&self, scope: &Scope) -> &T

impl Clone for VectorTile

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CubeDebug for VectorTile

fn set_debug_name(&self, scope: &Scope, name: &'static str)

Set the debug name of this type’s expansion. Should do nothing for types that don’t appear at runtime

impl CubeType for VectorTile

type ExpandType = VectorTile

impl Debug for VectorTile

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for VectorTile

impl ExpandTypeClone for VectorTile

fn clone_unchecked(&self) -> Self

Unchecked clone that only clones the conceptual runtime value. Should only be used in cases where each copy is used in a mutually exclusive branch (i.e. match, runtime enums). This is intentionally separated from Rust’s Clone semantics and should only be used for the conceptual expand values, never real data. Using two values in the same branch is undefined behaviour.

impl Hash for VectorTile

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoExpand for VectorTile

type Expand = VectorTile

fn into_expand(self, _scope: &Scope) -> Self

impl IntoMut for VectorTile

fn into_mut(self, _scope: &Scope) -> Self

Convert the variable into a potentially new mutable variable in scope, copying if needed.

impl PartialEq for VectorTile

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for VectorTile