Struct Point

pub struct Point { /* private fields */ }

Point represents a specific coordinate within the multi-dimensional space defined by an Extent.

A Point can be viewed in two equivalent ways:

• Coordinates: a tuple of indices, one per dimension, retrievable with Point::coord and Point::coords.
• Rank: a single linearized index into the extent’s row-major ordering, retrievable with Point::rank.

Internally, a Point stores:

• A rank: the row-major linearized index of this point.
• An extent: the extent that defines its dimensionality and sizes.

These fields are private; use the accessor methods instead.

Examples

use ndslice::extent;

let ext = extent!(zone = 2, host = 4, gpu = 8);
let point = ext.point(vec![1, 2, 3]).unwrap();

// Coordinate-based access
assert_eq!(point.coord(0), 1);
assert_eq!(point.coord(1), 2);
assert_eq!(point.coord(2), 3);

// Rank-based access
assert_eq!(point.rank(), 1 * (4 * 8) + 2 * 8 + 3);

Implementations

impl Point

pub fn coords_iter(&self) -> CoordIter<'_>

pub fn coord(&self, i: usize) -> usize

Returns the coordinate of this Point along the given axis.

The axis index i must be less than the number of dimensions in the Extent, otherwise this function will panic. Computes only the i-th coordinate from the point’s row-major rank, avoiding materialization of the full coordinate vector.

Examples

use ndslice::extent;

let ext = extent!(x = 2, y = 3);
let point = ext.point(vec![1, 2]).unwrap();
assert_eq!(point.coord(0), 1); // x
assert_eq!(point.coord(1), 2); // y

pub fn coords(&self) -> Vec<usize>

Returns the full coordinate vector for this Point (allocates).

The vector contains one coordinate per dimension of the Extent, reconstructed from the point’s row-major rank.

Examples

use ndslice::extent;

let ext = extent!(x = 2, y = 3);
let point = ext.point(vec![1, 2]).unwrap();
assert_eq!(point.coords(), vec![1, 2]);

pub fn rank(&self) -> usize

Returns the linearized row-major rank of this Point within its Extent.

pub fn extent(&self) -> &Extent

Returns the Extent that defines the coordinate space of this Point.

pub fn len(&self) -> usize

Returns the number of dimensions in this Point’s Extent.

This corresponds to the dimensionality of the coordinate space, i.e. how many separate axes (labels) are present.

Examples

use ndslice::extent;

let ext = extent!(x = 2, y = 3, z = 4);
let point = ext.point(vec![1, 2, 3]).unwrap();
assert_eq!(point.len(), 3); // x, y, z

pub fn is_empty(&self) -> bool

Returns true if this Point lies in a 0-dimensional Extent.

A 0-D extent has no coordinate axes and exactly one valid point (the empty tuple []).

Examples

use ndslice::extent;

let ext = extent!();
let point = ext.point(vec![]).unwrap();
assert!(point.is_empty());
assert_eq!(point.len(), 0);

pub fn format_as_dict(&self) -> String

Formats the coordinates of this Point as a string suitable for display names. Returns a string in the format: “{‘label’: coord/size, ‘label’: coord/size, …}”

Examples

use ndslice::extent;

let ext = extent!(x = 2, y = 3);
let point = ext.point(vec![1, 2]).unwrap();
assert_eq!(point.format_as_dict(), "{'x': 1/2, 'y': 2/3}");

Trait Implementations

impl Clone for Point

fn clone(&self) -> Point

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Point

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Point

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Point

Formats a Point as a comma-separated list of per-axis coordinates against the point’s extent:

label=coord/size[,label=coord/size,...]

Grammar

Point    := Pair ( "," Pair )*
Pair     := Label "=" Coord "/" Size
Label    := SafeIdent | Quoted
SafeIdent:= [A-Za-z0-9_]+
Quoted   := "\"" ( [^"\\] | "\\" . )* "\""   // Rust string-literal style
Coord    := [0-9]+
Size     := [0-9]+

Quoting rules

• Labels that are not SafeIdent are rendered using Rust string-literal syntax (via labels::fmt_label), e.g. "dim/0" or "x y".
• “Safe” means ASCII alphanumeric or underscore ([A-Za-z0-9_]+). Everything else is quoted.
• Coordinates are shown in row-major order and each is paired with that axis’s size from the point’s extent.

Examples

x=1/4,y=2/5,z=3/6
"dim/0"=1/3,"dim,1"=2/5

Implementation note: label rendering is delegated to labels::fmt_label to keep quoting behavior consistent with Extent and Region.

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

Formats the value using the given formatter.

impl FromStr for Point

type Err = PointError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Point

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<'a> IntoIterator for &'a Point

fn into_iter(self) -> Self::IntoIter

Iterate over the coordinate values of a Point (without allocating).

This allows using a Point directly in a for loop:

use ndslice::extent;

let ext = extent!(x = 2, y = 3);
let point = ext.point(vec![1, 2]).unwrap();

let coords: Vec<_> = (&point).into_iter().collect();
assert_eq!(coords, vec![1, 2]);

for coord in &point {
    println!("{}", coord);
}

type Item = usize

The type of the elements being iterated over.

type IntoIter = CoordIter<'a>

Which kind of iterator are we turning this into?

impl PartialEq for Point

fn eq(&self, other: &Point) -> 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 Serialize for Point

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Point

impl StructuralPartialEq for Point