: slice: Slice::view (#113)

Summary:

implements `Slice::view(&[usize]) -> Result<Slice>` with validation logic mirroring `torch.Tensor.view`. requires element count match and verifies row-major view layout is reachable in the base slice. conservative, safe reshape for canonical slices.

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,92 @@ impl Slice {
             mapper,
         }
     }
+
+    /// Returns a new [`Slice`] with the given shape by reinterpreting
+    /// the layout of this slice.
+    ///
+    /// Constructs a new shape with standard row-major strides, using
+    /// the same base offset. Returns an error if the reshaped view
+    /// would access coordinates not valid in the original slice.
+    ///
+    /// # Requirements
+    ///
+    /// - This slice must be contiguous and have offset == 0.
+    /// - The number of elements must match:
+    ///   `self.sizes().iter().product() == new_sizes.iter().product()`
+    /// - Each flat offset in the proposed view must be valid in `self`.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`SliceError::IncompatibleView`] if:
+    /// - The element count differs
+    /// - The base offset is nonzero
+    /// - Any offset in the view is not reachable in the original slice
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use ndslice::Slice;
+    /// let base = Slice::new_row_major(&[2, 3, 4]);
+    /// let reshaped = base.view(&[6, 4]).unwrap();
+    /// ```
+    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];
+        }
+
+        let offset = self.offset();
+
+        // 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_err() {
+                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)
@@ -557,4 +645,44 @@ mod tests {
         assert_eq!(s.sizes(), &[4, 4, 4]);
         assert_eq!(s.strides(), &[16, 4, 1]);
     }
+
+    #[test]
+    fn test_slice_view_smoke() {
+        use crate::Slice;
+
+        let base = Slice::new_row_major([2, 3, 4]);
+
+        // Reshape: compatible shape and layout
+        let view = base.view(&[6, 4]).unwrap();
+        assert_eq!(view.sizes(), &[6, 4]);
+        assert_eq!(view.offset(), 0);
+        assert_eq!(view.strides(), &[4, 1]);
+        assert_eq!(
+            view.location(&[5, 3]).unwrap(),
+            base.location(&[1, 2, 3]).unwrap()
+        );
+
+        // Reshape: identity (should succeed)
+        let view = base.view(&[2, 3, 4]).unwrap();
+        assert_eq!(view.sizes(), base.sizes());
+        assert_eq!(view.strides(), base.strides());
+
+        // Reshape: incompatible shape (wrong element count)
+        let err = base.view(&[5, 4]);
+        assert!(err.is_err());
+
+        // Reshape: incompatible layout (simulate select)
+        let selected = Slice::new(1, vec![2, 3], vec![6, 1]).unwrap(); // not offset=0
+        let err = selected.view(&[3, 2]);
+        assert!(err.is_err());
+
+        // Reshape: flat 1D view
+        let flat = base.view(&[24]).unwrap();
+        assert_eq!(flat.sizes(), &[24]);
+        assert_eq!(flat.strides(), &[1]);
+        assert_eq!(
+            flat.location(&[23]).unwrap(),
+            base.location(&[1, 2, 3]).unwrap()
+        );
+    }
 }