Implement Tensor struct

Cargo.toml

@@ -4,8 +4,9 @@ version = "0.1.0"
 edition = "2021"
 description = "A tensor library for scientific computing in Rust"
 license = "MIT"
-license-file = "LICENSE"
 homepage = "https://github.com/Rust-Scientific-Computing/feotensor"
 repository = "https://github.com/Rust-Scientific-Computing/feotensor"
 
 [dependencies]
+itertools = "0.13.0"
+num = "0.4.3"

src/axes.rs

@@ -0,0 +1 @@
+pub type Axes = Vec<usize>;

src/coordinate.rs

@@ -0,0 +1,131 @@
+use std::fmt;
+use std::ops::{Index, IndexMut};
+
+use crate::error::ShapeError;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Coordinate {
+    indices: Vec<usize>,
+}
+
+impl Coordinate {
+    pub fn new(indices: Vec<usize>) -> Result<Self, ShapeError> {
+        if indices.is_empty() {
+            return Err(ShapeError::new("Coordinate cannot be empty"));
+        }
+        Ok(Self { indices })
+    }
+
+    pub fn order(&self) -> usize {
+        self.indices.len()
+    }
+
+    pub fn iter(&self) -> std::slice::Iter<'_, usize> {
+        self.indices.iter()
+    }
+
+    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,
+        }
+    }
+}
+
+impl Index<usize> for Coordinate {
+    type Output = usize;
+
+    fn index(&self, index: usize) -> &Self::Output {
+        &self.indices[index]
+    }
+}
+
+impl IndexMut<usize> for Coordinate {
+    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
+        &mut self.indices[index]
+    }
+}
+
+impl fmt::Display for Coordinate {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use itertools::Itertools;
+        let idxs = self.indices.iter().map(|&x| format!("{}", x)).join(", ");
+        write!(f, "({})", idxs)
+    }
+}
+
+#[macro_export]
+macro_rules! coord {
+    ($($index:expr),*) => {
+        {
+            use $crate::coordinate::Coordinate;
+            Coordinate::new(vec![$($index),*])
+        }
+    };
+
+    ($index:expr; $count:expr) => {
+        {
+            use $crate::coordinate::Coordinate;
+            Coordinate::new(vec![$index; $count])
+        }
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_order() {
+        let coord = coord![1, 2, 3].unwrap();
+        assert_eq!(coord.order(), 3);
+    }
+
+    #[test]
+    fn test_iter() {
+        let coord = coord![1, 2, 3].unwrap();
+        let mut iter = coord.iter();
+        assert_eq!(iter.next(), Some(&1));
+        assert_eq!(iter.next(), Some(&2));
+        assert_eq!(iter.next(), Some(&3));
+        assert_eq!(iter.next(), None);
+    }
+
+    #[test]
+    fn test_insert() {
+        let coord = coord![1, 2, 3].unwrap();
+        let new_coord = coord.insert(1, 4);
+        assert_eq!(new_coord, coord![1, 4, 2, 3].unwrap());
+    }
+
+    #[test]
+    fn test_index() {
+        let coord = coord![1, 2, 3].unwrap();
+        assert_eq!(coord[0], 1);
+        assert_eq!(coord[1], 2);
+        assert_eq!(coord[2], 3);
+    }
+
+    #[test]
+    fn test_index_mut() {
+        let mut coord = coord![1, 2, 3].unwrap();
+        coord[1] = 4;
+        assert_eq!(coord[1], 4);
+    }
+
+    #[test]
+    fn test_display() {
+        let coord = coord![1, 2, 3].unwrap();
+        assert_eq!(format!("{}", coord), "(1, 2, 3)");
+    }
+
+    #[test]
+    fn test_coord_macro() {
+        let coord = coord![1, 2, 3].unwrap();
+        assert_eq!(coord, Coordinate::new(vec![1, 2, 3]).unwrap());
+
+        let coord_repeated = coord![1; 3].unwrap();
+        assert_eq!(coord_repeated, Coordinate::new(vec![1, 1, 1]).unwrap());
+    }
+}

src/error.rs

@@ -0,0 +1,20 @@
+use std::fmt;
+
+#[derive(Debug, Clone)]
+pub struct ShapeError {
+    reason: String,
+}
+
+impl ShapeError {
+    pub fn new(reason: &str) -> Self {
+        ShapeError {
+            reason: reason.to_string(),
+        }
+    }
+}
+
+impl fmt::Display for ShapeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "ShapeError: {}", self.reason)
+    }
+}

src/iter.rs

@@ -0,0 +1,88 @@
+use crate::coord;
+use crate::coordinate::Coordinate;
+use crate::shape::Shape;
+use std::cmp::max;
+
+pub struct IndexIterator {
+    shape: Shape,
+    current: Coordinate,
+    done: bool,
+}
+
+impl IndexIterator {
+    pub fn new(shape: &Shape) -> Self {
+        // (shape.order() == 0) => `next` returns None before `current` is used
+        let current = coord![0; max(shape.order(), 1)].unwrap();
+        IndexIterator {
+            shape: shape.clone(),
+            current,
+            done: false,
+        }
+    }
+}
+
+impl Iterator for IndexIterator {
+    type Item = Coordinate;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.done || self.shape.order() == 0 {
+            return None;
+        }
+
+        let result = self.current.clone();
+
+        for i in (0..self.shape.order()).rev() {
+            if self.current[i] + 1 < self.shape[i] {
+                self.current[i] += 1;
+                break;
+            } else {
+                self.current[i] = 0;
+                if i == 0 {
+                    self.done = true;
+                }
+            }
+        }
+
+        Some(result)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::shape;
+
+    #[test]
+    fn test_index_iterator() {
+        let shape = shape![2, 3].unwrap();
+        let mut iter = IndexIterator::new(&shape);
+
+        assert_eq!(iter.next(), Some(coord![0, 0].unwrap()));
+        assert_eq!(iter.next(), Some(coord![0, 1].unwrap()));
+        assert_eq!(iter.next(), Some(coord![0, 2].unwrap()));
+        assert_eq!(iter.next(), Some(coord![1, 0].unwrap()));
+        assert_eq!(iter.next(), Some(coord![1, 1].unwrap()));
+        assert_eq!(iter.next(), Some(coord![1, 2].unwrap()));
+        assert_eq!(iter.next(), None);
+    }
+
+    #[test]
+    fn test_index_iterator_single_dimension() {
+        let shape = shape![4].unwrap();
+        let mut iter = IndexIterator::new(&shape);
+
+        assert_eq!(iter.next(), Some(coord![0].unwrap()));
+        assert_eq!(iter.next(), Some(coord![1].unwrap()));
+        assert_eq!(iter.next(), Some(coord![2].unwrap()));
+        assert_eq!(iter.next(), Some(coord![3].unwrap()));
+        assert_eq!(iter.next(), None);
+    }
+
+    #[test]
+    fn test_index_iterator_empty_tensor() {
+        let shape = shape![].unwrap();
+        let mut iter = IndexIterator::new(&shape);
+
+        assert_eq!(iter.next(), None);
+    }
+}

src/lib.rs

@@ -1,14 +1,9 @@
-pub fn add(left: usize, right: usize) -> usize {
-    left + right
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
-    }
-}
+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;