: slice: Slice::view

Differential Revision: D75761780

Author: shayne-fletcher

ndslice/src/slice.rs

@@ -30,6 +30,9 @@ pub enum SliceError {
 
     #[error("value {value} not in slice")]
     ValueNotInSlice { value: usize },
+
+    #[error("incompatible view: {reason}")]
+    IncompatibleView { reason: String },
 }
 
 /// Slice is a compact representation of indices into the flat
@@ -281,7 +284,112 @@ impl Slice {
             mapper,
         }
     }
+
+    /// Returns a new [`Slice`] representing a view of this slice with
+    /// the given shape.
+    ///
+    /// This operation attempts to logically reinterpret the layout of
+    /// the current slice using the provided `new_sizes`, without
+    /// copying or reallocating memory.
+    ///
+    /// # Requirements
+    ///
+    /// - The total number of elements must match:
+    ///   `self.sizes().iter().product() == new_sizes.iter().product()`
+    ///
+    /// - The physical layout of the current slice must be compatible
+    ///   with a standard row-major traversal of `new_sizes`. In other
+    ///   words, the linear memory addresses visited by iterating over
+    ///   the view must all be valid and reachable in the base slice.
+    ///
+    /// If these conditions are not met, an error is returned.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`SliceError::IncompatibleView`] if:
+    /// - The element count does not match
+    /// - The view's origin is unreachable
+    /// - Any address implied by the view is not accessible in the
+    ///   base layout
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// let base = Slice::new_row_major(&[2, 3, 4]);
+    /// let reshaped = base.view(&[4, 3, 2])?;
+    /// ```
+    ///
+    /// # Notes
+    ///
+    /// This is a conservative operation: it only succeeds when the
+    /// proposed view is fully compatible with the base layout,
+    /// ensuring safety without memory aliasing.
+    ///
+    /// Use this when reinterpreting shape while preserving layout
+    /// guarantees.
+    pub fn view(&self, new_sizes: &[usize]) -> Result<Slice, SliceError> {
+        let view_elems: usize = new_sizes.iter().product();
+        let base_elems: usize = self.sizes().iter().product();
+
+        if view_elems != base_elems {
+            return Err(SliceError::IncompatibleView {
+                reason: format!(
+                    "element count mismatch: base has {}, view wants {}",
+                    base_elems, view_elems
+                ),
+            });
+        }
+
+        // Compute row-major strides
+        let mut new_strides = vec![1; new_sizes.len()];
+        for i in (0..new_sizes.len().saturating_sub(1)).rev() {
+            new_strides[i] = new_strides[i + 1] * new_sizes[i + 1];
+        }
+
+        // Attempt to find base offset from origin
+        let origin = vec![0; new_sizes.len()];
+        let offset = self
+            .location(&origin)
+            .map_err(|_| SliceError::IncompatibleView {
+                reason: "could not compute origin offset in base".into(),
+            })?;
+
+        // Validate that every address in the new view maps to a valid
+        // coordinate in base
+        let mut coord = vec![0; new_sizes.len()];
+        for _ in 0..view_elems {
+            // Compute offset of coord in view
+            let offset_in_view = offset
+                + coord
+                    .iter()
+                    .zip(&new_strides)
+                    .map(|(i, s)| i * s)
+                    .sum::<usize>();
+
+            if self.coordinates(offset_in_view).is_ok() {
+                return Err(SliceError::IncompatibleView {
+                    reason: format!("offset {} not reachable in base", offset_in_view),
+                });
+            }
+
+            // Increment coordinate
+            for j in (0..coord.len()).rev() {
+                coord[j] += 1;
+                if coord[j] < new_sizes[j] {
+                    break;
+                }
+                coord[j] = 0;
+            }
+        }
+
+        Ok(Slice {
+            offset,
+            sizes: new_sizes.to_vec(),
+            strides: new_strides,
+        })
+    }
 }
+
 impl std::fmt::Display for Slice {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{:?}", self)