Struct SharedScaleVec 

pub struct SharedScaleVec<const N: usize> {
    pub exact: ExactRealSetFacts,
    pub facts: VectorSharedScaleFacts<N>,
    /* private fields */
}

Owned vector coordinates certified to share one exact rational scale.

SharedScaleVec is the first owning common-scale carrier in hyperlattice. It stores ordinary Real coordinates and cached storage-free exact facts, rather than exposing rational numerators or the common denominator. That keeps scalar representation and reduction in hyperreal, while letting matrix, predicate, and triangulation code retain Yap-style object structure across API boundaries. See Yap, “Towards Exact Geometric Computation,” Computational Geometry 7.1-2 (1997).

Fields

exact: ExactRealSetFacts

Exact-rational representation facts for all owned coordinates.

facts: VectorSharedScaleFacts<N>

Cached common-scale and sparse-support fact packet.

Implementations

impl<const N: usize> SharedScaleVec<N>

pub fn from_components(components: [Real; N]) -> Option<Self>

Attempts to construct an owned shared-scale vector.

This returns None unless every coordinate is an exact rational and all reduced denominators match. The object is a semantic carrier for future common-denominator kernels; it deliberately does not expose the shared denominator.

pub fn components(&self) -> &[Real; N]

Returns the owned coordinates by reference.

pub fn into_components(self) -> [Real; N]

Consumes the object and returns the owned coordinates.

pub fn as_view(&self) -> VectorSharedScaleView<'_, N>

Returns a borrowed shared-scale view over the owned coordinates.

The view recomputes conservative masks from the retained coordinates but preserves the same scalar abstraction boundary as direct vector views.

pub const fn len(&self) -> usize

Returns the number of coordinates.

pub const fn is_empty(&self) -> bool

Returns whether this vector contains no coordinates.

pub fn facts(&self) -> VectorSharedScaleFacts<N>

Returns the cached common-scale fact packet for this owned vector.

The packet is collected once at construction and then reused by borrowed views, sparse dispatch, and exact algebra helpers. Missing facts remain only missed optimizations; topological predicates must still be decided in hyperlimit.

pub fn known_zero_count(&self) -> u32

Count coordinates known to be exactly zero.

This forwards the borrowed view’s mask-derived count without exposing the mask layout. Keeping count queries stable gives callers a cheap sparse-kernel dispatch signal while preserving the common-scale storage boundary described by Yap, “Towards Exact Geometric Computation,” Computational Geometry 7.1-2 (1997).

pub fn known_nonzero_count(&self) -> u32

Count coordinates known to be nonzero.

pub fn unknown_zero_count(&self) -> u32

Count coordinates whose zero status is unknown.

pub fn dot(&self, rhs: &Self) -> Real

Returns the dot product with another owned shared-scale vector.

The owned vectors retain their common-scale certificate across lifetimes. This method consumes that certificate through borrowed views and uses the known-exact scalar product-sum path without exposing numerators or denominators.

pub fn squared_norm(&self) -> Real

Returns the squared Euclidean norm using the retained exact certificate.

impl SharedScaleVec<2>

pub fn wedge(&self, rhs: &Self) -> Real

Returns the 2D exterior product with another owned shared-scale vector.

The result is an exact algebraic scalar expression. Topological orientation decisions remain in hyperlimit; this method only preserves and consumes the common-scale arithmetic certificate.

impl SharedScaleVec<3>

pub fn cross(&self, rhs: &Self) -> Vector3

Returns the 3D cross product with another owned shared-scale vector.

The result is an ordinary Vector3 because reduction may erase the common-scale shape in some lanes. Use Vector3::into_shared_scale if the caller wants to recover that certificate opportunistically.

Trait Implementations

impl<const N: usize> Clone for SharedScaleVec<N>

fn clone(&self) -> SharedScaleVec<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for SharedScaleVec<N>

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

Formats the value using the given formatter.

impl<const N: usize> PartialEq for SharedScaleVec<N>

fn eq(&self, other: &SharedScaleVec<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize> StructuralPartialEq for SharedScaleVec<N>