Struct Slice 

pub struct Slice {
    pub start: isize,
    pub end: Option<isize>,
    pub step: isize,
}

A slice specification for a single tensor dimension.

This struct represents a range with an optional step, used for advanced indexing operations on tensors. It is typically created using the s! macro rather than constructed directly.

Fields

• start - The starting index (inclusive). Negative values count from the end.
• end - The ending index (exclusive). None means to the end of the dimension.
• step - The stride between elements. Must be non-zero.

Index Interpretation

• Positive indices: Count from the beginning (0-based)
• Negative indices: Count from the end (-1 is the last element)
• Bounds checking: Indices are clamped to valid ranges

Step Behavior

• Positive step: Traverse forward through the range
• Negative step: Traverse backward through the range
• Step size: Determines how many elements to skip

Examples

While you typically use the s! macro, you can also construct slices directly:

use burn_tensor::Slice;

// Equivalent to s![2..8]
let slice1 = Slice::new(2, Some(8), 1);

// Equivalent to s![0..10;2]
let slice2 = Slice::new(0, Some(10), 2);

// Equivalent to s![..;-1] (reverse)
let slice3 = Slice::new(0, None, -1);

See also the s! macro for the preferred way to create slices.

Fields

start: isize

Slice start index.

end: Option<isize>

Slice end index (exclusive).

step: isize

Step between elements (default: 1).

Implementations

impl Slice

pub const fn new(start: isize, end: Option<isize>, step: isize) -> Self

Creates a new slice with start, end, and step

pub const fn full() -> Self

Creates a slice that represents the full range.

pub fn index(idx: isize) -> Self

Creates a slice that represents a single index

pub fn with_step(start: isize, end: Option<isize>, step: isize) -> Self

Creates a slice with a custom step

pub fn from_range_stepped<R: Into<Slice>>(range: R, step: isize) -> Self

Creates a slice from a range with a specified step

pub fn step(&self) -> isize

Returns the step of the slice

pub fn range(&self, size: usize) -> Range<usize>

Returns the range for this slice given a dimension size

pub fn to_range(&self, size: usize) -> Range<usize>

Convert this slice to a range for a dimension of the given size.

Arguments

• size - The size of the dimension to slice.

Returns

A Range<usize> representing the slice bounds.

pub fn to_range_and_step(&self, size: usize) -> (Range<usize>, isize)

Converts the slice into a range and step tuple

pub fn is_reversed(&self) -> bool

Returns true if the step is negative

pub fn output_size(&self, dim_size: usize) -> usize

Calculates the output size for this slice operation

Trait Implementations

impl Clone for Slice

fn clone(&self) -> Slice

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Slice

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

Formats the value using the given formatter.

impl Default for Slice

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Slice

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I: AsIndex> From<Range<I>> for Slice

fn from(r: Range<I>) -> Self

Converts to this type from the input type.

impl<I: AsIndex> From<RangeFrom<I>> for Slice

fn from(r: RangeFrom<I>) -> Self

Converts to this type from the input type.

impl From<RangeFull> for Slice

fn from(_: RangeFull) -> Self

Converts to this type from the input type.

impl<I: AsIndex + Copy> From<RangeInclusive<I>> for Slice

fn from(r: RangeInclusive<I>) -> Self

Converts to this type from the input type.

impl<I: AsIndex> From<RangeTo<I>> for Slice

fn from(r: RangeTo<I>) -> Self

Converts to this type from the input type.

impl<I: AsIndex> From<RangeToInclusive<I>> for Slice

fn from(r: RangeToInclusive<I>) -> Self

Converts to this type from the input type.

impl From<i32> for Slice

fn from(i: i32) -> Self

Converts to this type from the input type.

impl From<isize> for Slice

fn from(i: isize) -> Self

Converts to this type from the input type.

impl From<usize> for Slice

fn from(i: usize) -> Self

Converts to this type from the input type.

impl Hash for Slice

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 PartialEq for Slice

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Slice

impl Eq for Slice

impl StructuralPartialEq for Slice