style: run fmt

Author: siliconlad

src/coordinate.rs

@@ -22,7 +22,9 @@ impl Coordinate {
     pub fn insert(&self, index: usize, axis: usize) -> Self {
         let mut new_indices = self.indices.clone();
         new_indices.insert(index, axis);
-        Self { indices: new_indices }
+        Self {
+            indices: new_indices,
+        }
     }
 }
 

src/iter.rs

@@ -45,7 +45,6 @@ impl Iterator for IndexIterator {
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -84,4 +83,4 @@ mod tests {
 
         assert_eq!(iter.next(), None);
     }
-}
+}

src/lib.rs

@@ -1,9 +1,9 @@
-pub mod shape;
-pub mod iter;
-pub mod error;
+pub mod axes;
 pub mod coordinate;
+pub mod error;
+pub mod iter;
+pub mod matrix;
+pub mod shape;
 pub mod storage;
 pub mod tensor;
 pub mod vector;
-pub mod matrix;
-pub mod axes;

src/matrix.rs

@@ -1,14 +1,14 @@
-use std::ops::{Add, Sub, Mul, Div, Deref, Index, IndexMut, DerefMut};
+use std::ops::{Add, Deref, DerefMut, Div, Index, IndexMut, Mul, Sub};
 
-use num::{Num, Float};
+use crate::axes::Axes;
+use crate::coord;
+use crate::coordinate::Coordinate;
 use crate::error::ShapeError;
 use crate::shape;
-use crate::coord;
 use crate::shape::Shape;
 use crate::tensor::DynamicTensor;
 use crate::vector::DynamicVector;
-use crate::axes::Axes;
-use crate::coordinate::Coordinate;
+use num::{Float, Num};
 
 pub struct DynamicMatrix<T: Num> {
     tensor: DynamicTensor<T>,
@@ -17,9 +17,11 @@ pub type Matrix<T> = DynamicMatrix<T>;
 
 impl<T: Num + PartialOrd + Copy> DynamicMatrix<T> {
     pub fn new(shape: &Shape, data: &[T]) -> Result<DynamicMatrix<T>, ShapeError> {
-        Ok(DynamicMatrix { tensor: DynamicTensor::new(shape, data)? })
+        Ok(DynamicMatrix {
+            tensor: DynamicTensor::new(shape, data)?,
+        })
     }
-    
+
     pub fn from_tensor(tensor: DynamicTensor<T>) -> Result<DynamicMatrix<T>, ShapeError> {
         if tensor.shape().order() != 2 {
             return Err(ShapeError::new("Shape must have order of 2"));
@@ -38,8 +40,12 @@ impl<T: Num + PartialOrd + Copy> DynamicMatrix<T> {
         }
         Ok(result)
     }
-    pub fn zeros(shape: &Shape) -> Result<DynamicMatrix<T>, ShapeError> { Self::fill(shape, T::zero()) }
-    pub fn ones(shape: &Shape) -> Result<DynamicMatrix<T>, ShapeError> { Self::fill(shape, T::one()) }
+    pub fn zeros(shape: &Shape) -> Result<DynamicMatrix<T>, ShapeError> {
+        Self::fill(shape, T::zero())
+    }
+    pub fn ones(shape: &Shape) -> Result<DynamicMatrix<T>, ShapeError> {
+        Self::fill(shape, T::one())
+    }
 
     pub fn sum(&self, axes: Axes) -> DynamicVector<T> {
         let result = self.tensor.sum(axes);
@@ -597,7 +603,7 @@ mod tests {
         assert_eq!(result[coord![1, 1]], 2.0);
         assert_eq!(result.shape(), &shape);
     }
-    
+
     #[test]
     fn test_div_matrix_tensor() {
         let shape = shape![2, 2].unwrap();
@@ -648,4 +654,4 @@ mod tests {
         assert_eq!(result[coord![1, 1]], 25.0);
         assert_eq!(result.shape(), &shape);
     }
-}
+}

src/shape.rs

@@ -111,4 +111,4 @@ mod tests {
         let extended_shape = shape1.stack(&shape2);
         assert_eq!(extended_shape.dims, vec![2, 3, 4, 5]);
     }
-}
+}

src/storage.rs

@@ -1,8 +1,8 @@
 use std::ops::{Index, IndexMut};
 
 use crate::coordinate::Coordinate;
-use crate::shape::Shape;
 use crate::error::ShapeError;
+use crate::shape::Shape;
 
 #[derive(Debug, PartialEq)]
 pub struct DynamicStorage<T> {
@@ -23,13 +23,15 @@ impl<T> DynamicStorage<T> {
 
         for (i, &dim) in coord.iter().enumerate() {
             if dim >= shape[i] {
-                return Err(ShapeError::new(format!("out of bounds for dimension {}", i).as_str()));
+                return Err(ShapeError::new(
+                    format!("out of bounds for dimension {}", i).as_str(),
+                ));
             }
         }
 
         let mut index = 0;
         for k in 0..shape.order() {
-            let stride = shape[k+1..].iter().product::<usize>();
+            let stride = shape[k + 1..].iter().product::<usize>();
             index += coord[k] * stride;
         }
         Ok(index)
@@ -54,7 +56,6 @@ impl<T> Index<usize> for DynamicStorage<T> {
     fn index(&self, index: usize) -> &Self::Output {
         &self.data[index]
     }
-
 }
 
 impl<T> Index<std::ops::Range<usize>> for DynamicStorage<T> {