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) -> Slice

Creates a new slice with start, end, and step

pub const fn full() -> Slice

Creates a slice that represents the full range.

pub fn index(idx: isize) -> Slice

Creates a slice that represents a single index

pub fn into_vec(self) -> Vec<isize>

Converts the slice to a vector.

pub fn bound_to(self, size: usize) -> Slice

Clips the slice to a maximum size.

Example

assert_eq!(
    Slice::new(0, None, 1).bound_to(10),
    Slice::new(0, Some(10), 1));
assert_eq!(
    Slice::new(0, Some(5), 1).bound_to(10),
    Slice::new(0, Some(5), 1));
assert_eq!(
    Slice::new(0, None, -1).bound_to(10),
    Slice::new(0, Some(-11), -1));
assert_eq!(
    Slice::new(0, Some(-5), -1).bound_to(10),
    Slice::new(0, Some(-5), -1));

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

Creates a slice with a custom step

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

where R: Into<Slice>,

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<(), Error>

Formats the value using the given formatter.

impl Default for Slice

fn default() -> Slice

Returns the “default value” for a type.

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

fn deserialize<__D>( __deserializer: __D, ) -> Result<Slice, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Slice

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

Formats the value using the given formatter.

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

where I: AsIndex,

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

Converts to this type from the input type.

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

where I: AsIndex,

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

Converts to this type from the input type.

impl From<RangeFull> for Slice

fn from(_: RangeFull) -> Slice

Converts to this type from the input type.

impl<I> From<RangeInclusive<I>> for Slice

where I: AsIndex + Copy,

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

Converts to this type from the input type.

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

where I: AsIndex,

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

Converts to this type from the input type.

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

where I: AsIndex,

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

Converts to this type from the input type.

impl From<i32> for Slice

fn from(i: i32) -> Slice

Converts to this type from the input type.

impl From<i64> for Slice

fn from(i: i64) -> Slice

Converts to this type from the input type.

impl From<isize> for Slice

fn from(i: isize) -> Slice

Converts to this type from the input type.

impl From<usize> for Slice

fn from(i: usize) -> Slice

Converts to this type from the input type.

impl FromStr for Slice

type Err = ExpressionError

The associated error which can be returned from parsing.

fn from_str(source: &str) -> Result<Slice, <Slice as FromStr>::Err>

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

impl Hash for Slice

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

where __H: Hasher,

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

Note: Unbounded Slices produce infinite iterators.

type Item = isize

The type of the elements being iterated over.

type IntoIter = SliceIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Slice as IntoIterator>::IntoIter

Creates an iterator from a value.

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 as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Slice

impl Eq for Slice

impl StructuralPartialEq for Slice