Enum Addressing 

pub enum Addressing {
    Nothing,
    ARunOf {
        elements: usize,
        lane_run: Option<usize>,
    },
}

What a manifest says about addressing the artifact it describes.

Derived, never declared. Manifest’s field set is normative and carries no addressing field; it gains none here, because a field would be a second source for what the tier, the block and the bound already fix (R10) as well as a change to every artifact’s identity.

Those three are the manifest’s fields that describe the code. The two that describe the artifact’s bytes — codes_sha256 and codebook_sha256 — are not read, and that absence is the whole of CS-10: two artifacts of one tier, one block and one bound address alike however far apart their code bytes are, so a traversal chosen from this cannot have probed either one.

It says nothing about whether a table over the code space exists. That is crate::Enumerable’s question, it is answered by the type at the tabulated traversal’s boundary rather than by a token, and a composing tier — crate::Packed, crate::Offset, crate::Transcode — reports its own tier while inheriting its inner codec’s enumeration. What is stated here is the block: how many elements one code names, and how far a lane carries their partial sums.

Variants

Nothing

No code of this artifact indexes a decode.

Either the manifest names no element per code at all, or the tier is one of the two with nothing between a code and an element: TierId::Identity, whose codes are the alphabet, so its code space is as wide as the element type; and TierId::Runs, whose code widths are the data, so there is no p-th block for anything to be built per. Those are the two tiers ARCHITECTURE.md names as admitting no table; neither implements crate::Enumerable, and no composition of them can, because a composing tier reports its own token and its own enumeration.

Reading the tier for this is not a dispatch on the answer: two codecs with different tiers and equal decodes still write byte-identical output (CK-05), and the table and the stream are held to the same bytes either way (CD-13). What it decides is which factorizations exist.

ARunOf

A code names elements consecutive elements of one row, so a table indexed by the code space can carry their partial sum against an activation block of the same length.

Fields

elements: usize

Consecutive elements of a row one code names.

One is well formed and is what every scalar tier declares. It is the block over which a table sums nothing — one code, one product — which is why tabulation_pays refuses it on op count and routes the arena tier back to the dense traversal.

lane_run: Option<usize>

Partial sums of one such run that a narrow lane word holds exactly.

A product of two alphabet elements has magnitude at most bound^2, and a run of elements of them at most elements * bound^2, so a lane holding NARROW_CAP holds this many runs and no more.

None when no run fits one at all: a bound wide enough that a single block already exceeds the lane, and in particular the u128::MAX a float codebook declares through Whole, which is not a magnitude. The reduction is then carried in the exact accumulator — where a family with no narrow register was always going to carry it.

Implementations

impl Addressing

pub const fn of(tier: TierId, block: usize, bound: u128) -> Self

The addressing a tier, a block and a bound declare. The whole of the derivation, and its only entry point.

pub const fn addresses_an_element(self) -> bool

Does one code name an element at all?

pub const fn addresses_a_run(self) -> bool

Does one code name a run, so that a table entry is a partial sum of more than one product?

This is the term the tabulated traversal’s break-even turns on, and it is false at MAX_BLOCK == 1 for the reason stated on elements above: a table of one product per entry repays no build at any width.

Trait Implementations

impl Clone for Addressing

fn clone(&self) -> Addressing

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Addressing

impl Debug for Addressing

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

Formats the value using the given formatter.

impl Eq for Addressing

impl PartialEq for Addressing

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Addressing