Refactor Tensor methods to use &[usize] instead of &Vec<usize> to reduce unnecessary overhead (#19)

* refactor some parameters and return types of Tensor to use slices instead of Vecs to reduce unnecessary overhead

* refactor parameters to use slices instead of Vecs to reduce unnecessary overhead

* update README to reflect changes made in refactor

Author: PaytonWebber

tensor/README.md

@@ -35,61 +35,60 @@ use tensor::Tensor;
    let data: Vec<f32> = (0..length).map(|v| v as f32 + 10.0).collect();
 
    // Create a Tensor, ensuring data.len() matches the product of shape
-   let a = Tensor::new(shape.clone(), data).unwrap();
+   let a = Tensor::new(shape, data).unwrap();
    ```
 2. **Zeros and Ones**  
    ```rust
    // 4x2 filled with zeros
-   let zeros_tensor = Tensor::zeros(vec![4, 2]);
+   let zeros_tensor = Tensor::zeros(&[4, 2]);
 
    // 1x9x2x5 filled with ones
-   let ones_tensor = Tensor::ones(vec![1, 9, 2, 5]);
+   let ones_tensor = Tensor::ones(&[1, 9, 2, 5]);
    ```
 
 ### 2. Indexing and Accessing Data
 
 - **Indexing** via `Index<Vec<usize>>`:  
   ```rust
-  let t = Tensor::ones(vec![2, 3]);
-  // t[vec![row, col]]
-  assert_eq!(t[vec![0, 2]], 1.0_f32);
+  let t = Tensor::ones(&[2, 3]);
+  // t[&[row, col]]
+  assert_eq!(t[&[0, 2]], 1.0_f32);
   ```
 - **Check `.shape()` and `.strides()`**:  
   ```rust
-  println!("Shape = {:?}", t.shape());   // e.g. [2, 3]
-  println!("Strides = {:?}", t.strides()); // e.g. [3, 1]
+  println!("Shape = {:?}", t.shape());     // [2, 3]
+  println!("Strides = {:?}", t.strides()); // [3, 1]
   ```
 - **Access raw data**:
   ```rust
-  let data_ref: &Vec<f32> = t.data();
-  // or get mutable reference with t.data_mut()
+  let data_ref: &[f32] = t.data();
   ```
 
 ### 3. Movement Ops: Reshaping, Permuting, Flattening, Transposing
 
 1. **Reshape**  
    ```rust
-   let mut a = Tensor::ones(vec![4, 2]);
-   a.reshape(vec![2, 2, 2]).unwrap(); 
+   let mut a = Tensor::ones(&[4, 2]);
+   a.reshape(&[2, 2, 2]).unwrap(); 
    // shape is now [2, 2, 2]
    ```
 2. **Permute** (change dimension ordering)  
    ```rust
-   let mut a = Tensor::ones(vec![1, 4, 2]);
+   let mut a = Tensor::ones(&[1, 4, 2]);
    // reorder dimensions to [1->4, 4->2, 2->1]
-   a.permute(vec![1, 2, 0]).unwrap();  
+   a.permute(&[1, 2, 0]).unwrap();  
    // shape is now [4, 2, 1]
-   // strides updated accordingly
+   // strides are now [2, 1, 8] as the data was not changed
    ```
 3. **Flatten**  
    ```rust
-   let mut a = Tensor::ones(vec![7, 6]);
+   let mut a = Tensor::ones(&[7, 6]);
    a.flatten();
    // shape becomes [42], strides is [1]
    ```
 4. **Transpose**  
    ```rust
-   let mut a = Tensor::new(vec![2, 3], vec![1., 2., 3., 4., 5., 6.]).unwrap();
+   let mut a = Tensor::new(&[2, 3], vec![1., 2., 3., 4., 5., 6.]).unwrap();
    a.transpose().unwrap();
    // shape is now [3, 2], data is reordered
    ```
@@ -110,15 +109,14 @@ They also have matching **trait operators**:
 #### a) Simple Elementwise
 
 ```rust
-let a = Tensor::ones(vec![2, 3]);
-let b = Tensor::ones(vec![2, 3]);
+let a = Tensor::ones(&[2, 3]);
+let b = Tensor::ones(&[2, 3]);
 
 // Out-of-place
 let c = a.add(&b).unwrap();  // or &a + &b
-// c has all 2.0 values
 
 // In-place
-let mut d = Tensor::zeros(vec![2, 3]);
+let mut d = Tensor::zeros(&[2, 3]);
 d.add_inplace(&c);
 ```
 
@@ -164,13 +162,13 @@ let c = a.matmul(&b).unwrap();
 2. **Sum Along a Dimension**  
    ```rust
    let reduced = a.sum_dim(1).unwrap();
-   // For shape [2, 3], sum_dim(1) -> shape [2], data is sum across columns
-   // e.g. [6., 15.]
+   // For shape [2, 3], sum_dim(1) -> shape [2],
+   // data is sum across columns [6., 15.]
    ```
 3. **Mean** and **Mean Along Dimension**  
    ```rust
-   let m = a.mean();          // overall mean
-   let m_dim = a.mean_dim(0); // per-row or per-col mean
+   let m = a.mean();          
+   let m_dim = a.mean_dim(0);
    ```
 
 ### 6. Unary Ops

tensor/src/core/mod.rs

@@ -13,42 +13,54 @@ pub struct Tensor {
 }
 
 impl Tensor {
-    pub fn new(shape: Vec<usize>, data: Vec<f32>) -> Result<Self, TensorError> {
-        let length: usize = shape.iter().product();
+    pub fn new<S>(shape: S, data: Vec<f32>) -> Result<Self, TensorError>
+    where
+        S: Into<Vec<usize>>,
+    {
+        let shape_vec = shape.into();
+        let length: usize = shape_vec.iter().product();
         if data.len() != length {
             return Err(TensorError::CreationError(
                 "Data does not fit within shape".to_string(),
             ));
         }
-        let strides: Vec<usize> = calculate_strides(&shape);
+        let strides: Vec<usize> = calculate_strides(&shape_vec);
         Ok(Tensor {
-            shape: shape.to_vec(),
+            shape: shape_vec,
             strides,
             data,
         })
     }
 
-    pub fn zeros(shape: Vec<usize>) -> Self {
-        let num_elements: usize = shape.iter().product();
-        let strides: Vec<usize> = calculate_strides(&shape);
+    pub fn zeros<S>(shape: S) -> Self
+    where
+        S: Into<Vec<usize>>,
+    {
+        let shape_vec = shape.into();
+        let num_elements: usize = shape_vec.iter().product();
+        let strides: Vec<usize> = calculate_strides(&shape_vec);
         Tensor {
-            shape: shape.to_vec(),
+            shape: shape_vec,
             strides,
             data: vec![0.0; num_elements],
         }
     }
 
-    pub fn ones(shape: Vec<usize>) -> Self {
-        let num_elements: usize = shape.iter().product();
-        let strides: Vec<usize> = calculate_strides(&shape);
+    pub fn ones<S>(shape: S) -> Self
+    where
+        S: Into<Vec<usize>>,
+    {
+        let shape_vec = shape.into();
+        let num_elements: usize = shape_vec.iter().product();
+        let strides: Vec<usize> = calculate_strides(&shape_vec);
         Tensor {
-            shape: shape.to_vec(),
+            shape: shape_vec,
             strides,
             data: vec![1.0; num_elements],
         }
     }
 
-    pub fn get(&self, indices: Vec<usize>) -> Option<&f32> {
+    pub fn get(&self, indices: &[usize]) -> Option<&f32> {
         if indices.len() != self.shape.len() {
             return None;
         }
@@ -63,15 +75,15 @@ impl Tensor {
         self.data.get(idx)
     }
 
-    pub fn shape(&self) -> &Vec<usize> {
+    pub fn shape(&self) -> &[usize] {
         &self.shape
     }
 
-    pub fn strides(&self) -> &Vec<usize> {
+    pub fn strides(&self) -> &[usize] {
         &self.strides
     }
 
-    pub fn data(&self) -> &Vec<f32> {
+    pub fn data(&self) -> &[f32] {
         &self.data
     }
 

tensor/src/core/ops/binary.rs

@@ -23,7 +23,7 @@ impl Tensor {
                 .zip(other.data.iter())
                 .map(|(a, b)| op(*a, *b))
                 .collect();
-            return Tensor::new(self_shape.clone(), result_data);
+            return Tensor::new(self_shape, result_data);
         }
 
         let (bc_shape, self_bc_strides, other_bc_strides) =
@@ -102,8 +102,8 @@ impl Tensor {
     }
 
     pub fn matmul(&self, other: &Tensor) -> Result<Tensor, TensorError> {
-        let lhs_shape: &Vec<usize> = self.shape();
-        let rhs_shape: &Vec<usize> = other.shape();
+        let lhs_shape = self.shape();
+        let rhs_shape = other.shape();
         if lhs_shape.len() != 2 || rhs_shape.len() != 2 {
             return Err(TensorError::BroadcastError(
                 "matmul requires 2D tensors".to_string(),
@@ -118,8 +118,8 @@ impl Tensor {
             ));
         }
 
-        let lhs_data: &Vec<f32> = self.data();
-        let rhs_data: &Vec<f32> = other.data();
+        let lhs_data = self.data();
+        let rhs_data = other.data();
         let mut result_data: Vec<f32> = vec![0.0_f32; rows_left * cols_right];
         for i in 0..rows_left {
             for k in 0..cols_left {

tensor/src/core/ops/broadcast.rs

@@ -1,6 +1,6 @@
-pub fn is_broadcastable(a: &Vec<usize>, b: &Vec<usize>) -> bool {
+pub fn is_broadcastable(a_shape: &[usize], b_shape: &[usize]) -> bool {
     // This is based on NumPy's rules: https://numpy.org/doc/stable/user/basics.broadcasting.html
-    for (i, j) in a.iter().rev().zip(b.iter().rev()) {
+    for (i, j) in a_shape.iter().rev().zip(b_shape.iter().rev()) {
         if *i == 1 || *j == 1 {
             continue;
         }
@@ -12,8 +12,8 @@ pub fn is_broadcastable(a: &Vec<usize>, b: &Vec<usize>) -> bool {
 }
 
 pub fn compute_broadcast_shape_and_strides(
-    a_shape: &Vec<usize>,
-    b_shape: &Vec<usize>,
+    a_shape: &[usize],
+    b_shape: &[usize],
 ) -> (Vec<usize>, Vec<usize>, Vec<usize>) {
     let ndims = a_shape.len().max(b_shape.len());
     let mut a_bc_strides = vec![1; ndims];

tensor/src/core/ops/movement.rs

@@ -2,20 +2,20 @@ use crate::core::{calculate_strides, TensorError};
 use crate::Tensor;
 
 impl Tensor {
-    pub fn reshape(&mut self, shape: Vec<usize>) -> Result<(), TensorError> {
+    pub fn reshape(&mut self, shape: &[usize]) -> Result<(), TensorError> {
         let new_length: usize = shape.iter().product();
         let current_length: usize = self.shape.iter().product();
         if new_length != current_length {
             return Err(TensorError::CreationError(
                 "The new shape does not align with the size of the data.".to_string(),
             ));
         }
-        self.strides = calculate_strides(&shape);
+        self.strides = calculate_strides(shape);
         self.shape = shape.to_vec();
         Ok(())
     }
 
-    pub fn permute(&mut self, order: Vec<usize>) -> Result<(), TensorError> {
+    pub fn permute(&mut self, order: &[usize]) -> Result<(), TensorError> {
         if order.len() != self.shape.len() {
             return Err(TensorError::CreationError(
                 "The permutation does not align with the current shape.".to_string(),

tensor/src/core/ops/reduce.rs

@@ -18,7 +18,7 @@ impl Tensor {
             ));
         }
 
-        let mut result_shape = self_shape.clone();
+        let mut result_shape = self_shape.to_vec().clone();
         let dim_size = result_shape.remove(dim);
 
         let result_size: usize = result_shape.iter().product();

tensor/src/core/ops/unary.rs

@@ -6,7 +6,7 @@ impl Tensor {
         F: Fn(f32) -> f32,
     {
         let result_data: Vec<f32> = self.data().iter().map(|x| op(*x)).collect();
-        return Tensor::new(self.shape().clone(), result_data).unwrap();
+        return Tensor::new(self.shape(), result_data).unwrap();
     }
 
     pub fn exp(&self) -> Tensor {

tensor/src/core/traits.rs

@@ -29,9 +29,9 @@ impl fmt::Display for Tensor {
     }
 }
 
-impl Index<Vec<usize>> for Tensor {
+impl Index<&[usize]> for Tensor {
     type Output = f32;
-    fn index(&self, indices: Vec<usize>) -> &Self::Output {
+    fn index(&self, indices: &[usize]) -> &Self::Output {
         self.get(indices).expect("Index out of bounds")
     }
 }
@@ -52,7 +52,7 @@ impl Add<f32> for &Tensor {
 
     fn add(self, rhs: f32) -> Self::Output {
         let result_data: Vec<f32> = self.data().iter().map(|&x| x + rhs).collect();
-        Tensor::new(self.shape().clone(), result_data).unwrap()
+        Tensor::new(self.shape(), result_data).unwrap()
     }
 }
 
@@ -61,7 +61,7 @@ impl Add<&Tensor> for f32 {
 
     fn add(self, rhs: &Tensor) -> Self::Output {
         let result_data: Vec<f32> = rhs.data().iter().map(|&x| x + self).collect();
-        Tensor::new(rhs.shape().clone(), result_data).unwrap()
+        Tensor::new(rhs.shape(), result_data).unwrap()
     }
 }
 
@@ -103,7 +103,7 @@ impl Sub<f32> for &Tensor {
 
     fn sub(self, rhs: f32) -> Self::Output {
         let result_data: Vec<f32> = self.data().iter().map(|&x| x - rhs).collect();
-        Tensor::new(self.shape().clone(), result_data).unwrap()
+        Tensor::new(self.shape(), result_data).unwrap()
     }
 }
 
@@ -112,7 +112,7 @@ impl Sub<&Tensor> for f32 {
 
     fn sub(self, rhs: &Tensor) -> Self::Output {
         let result_data: Vec<f32> = rhs.data().iter().map(|&x| x - self).collect();
-        Tensor::new(rhs.shape().clone(), result_data).unwrap()
+        Tensor::new(rhs.shape(), result_data).unwrap()
     }
 }
 
@@ -154,7 +154,7 @@ impl Mul<f32> for &Tensor {
 
     fn mul(self, rhs: f32) -> Self::Output {
         let result_data: Vec<f32> = self.data().iter().map(|&x| x * rhs).collect();
-        Tensor::new(self.shape().clone(), result_data).unwrap()
+        Tensor::new(self.shape(), result_data).unwrap()
     }
 }
 
@@ -163,7 +163,7 @@ impl Mul<&Tensor> for f32 {
 
     fn mul(self, rhs: &Tensor) -> Self::Output {
         let result_data: Vec<f32> = rhs.data().iter().map(|&x| x * self).collect();
-        Tensor::new(rhs.shape().clone(), result_data).unwrap()
+        Tensor::new(rhs.shape(), result_data).unwrap()
     }
 }
 
@@ -205,7 +205,7 @@ impl Div<f32> for &Tensor {
 
     fn div(self, rhs: f32) -> Self::Output {
         let result_data: Vec<f32> = self.data().iter().map(|&x| x / rhs).collect();
-        Tensor::new(self.shape().clone(), result_data).unwrap()
+        Tensor::new(self.shape(), result_data).unwrap()
     }
 }
 

tensor/src/core/utils.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-pub fn calculate_strides(shape: &Vec<usize>) -> Vec<usize> {
+pub fn calculate_strides(shape: &[usize]) -> Vec<usize> {
     let length: usize = shape.len();
     let mut strides = vec![1; length];
     strides.iter_mut().enumerate().for_each(|(i, stride)| {