merge vector version with previous version.

.gitignore

@@ -1,10 +1,10 @@
 /target
-/src/attempts/
+/src/ignoreme/
 /src/aplay/
 /.vscode
 /.idea/
 /.idea/misc.xml
 /src/erroring.rs
 /src/versions.rs
 /timing_order.txt
-/oprofile_data
+/oprofile_data

Cargo.toml

@@ -4,10 +4,13 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+chrono = "0.4.24"
 common_macros = "0.1.1"
+csv = "1.2.1"
 itertools = "0.10.5"
-ndarray = "0.15.6"
+ndarray = { version = "0.15.6", features = ["blas", "rayon", "matrixmultiply-threading"] } 
 rayon = "1.7.0"
+serde = { version = "1", features = ["derive"] }
 
 [profile.release]
 debug = true

src/graph/defs.rs

@@ -4,59 +4,80 @@ use std::collections::{HashMap, HashSet, VecDeque};
 
 use super::utils::{check_edge::is_valid_edge, modify::orient};
 
+pub const DISP_VECTORS: [[[i16; 2]; 2]; 4] = [
+    [[-2, 0], [0, -2]],
+    [[-2, 0], [0, 2]],
+    [[2, 0], [0, 2]],
+    [[2, 0], [0, -2]],
+];
+
 pub type Adjacency = HashMap<Node, Neighbors>;
 pub type ZAdjacency = HashMap<[Point; 2], Vec<[Point; 2]>>;
 pub type Bobbins = Vec<Node>;
 pub type Count = usize;
 pub type Edge = (Node, Node);
 pub type Edges = HashSet<Edge>;
-pub type Loom = Vec<YarnEnds>;
-pub type Neighbors = HashSet<Node>;
-pub type Node = u32;
+pub type Loom = Vec<VecDeque<[i16; 3]>>;
+pub type LoomSlice = [VecDeque<[i16; 3]>];
+pub type Neighbors = HashSet<[i16; 3]>;
+pub type Node = [i16; 3];
 pub type Nodes = HashSet<Node>;
 pub type Order = u32;
 pub type Point = i16;
 pub type Points = HashSet<Point>;
 pub type Solution = Tour;
+pub type Spindle = Vec<[i16; 2]>;
 pub type Spool = HashMap<u32, Yarn>;
+pub type Spun = HashMap<[i16; 2], bool>;
 pub type Subtours = Vec<Tour>;
-pub type Tour = Vec<Node>;
-pub type TourSlice<'a> = &'a [Node];
-pub type TourSliceThick<'a> = &'a [[i16; 2]];
+pub type Tour = Vec<[i16; 3]>;
+pub type TourSlice<'a> = &'a [[i16; 2]];
 pub type YarnEnds = VecDeque<Node>;
+pub type Var2 = [i16; 2];
 pub type Vert = (Point, Point, Point);
-pub type Verts = [Vert];
+pub type Verts = [[i16; 3]];
 pub type VecVert = Vec<Vert>;
 pub type VIMap = HashMap<Vert, Node>;
-pub type Warps = Subtours;
+pub type Warps = Vec<Vec<[i16; 3]>>;
 pub type Weights = HashMap<Node, Point>;
 pub type SignedIdx = i32;
 pub type Yarn = Array2<Point>;
 pub type ZlevelNodesMap = HashMap<Point, Nodes>;
 pub type ZOrder = Vec<(Point, usize)>;
+use serde::Serialize;
+use std::error::Error;
+
+#[derive(Debug, Clone, Copy)]
+pub enum XY {
+    X,
+    Y,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "PascalCase")]
+struct Vector {
+    x: i16,
+    y: i16,
+    z: i16,
+}
 
 #[derive(Clone, Debug)]
-pub struct Weaver<'a> {
+pub struct Weaver {
     pub data: Tour,
-    verts: &'a Verts,
     lead: bool,
     min_xyz: Point,
     order: u32,
 }
 
-impl<'a> Weaver<'a> {
-    pub fn new(
-        mut data: YarnEnds,
-        verts: &'a Verts,
-        lead: bool,
-        min_xyz: Point,
-    ) -> Weaver<'a> {
+impl Weaver {
+    pub fn new(mut data: YarnEnds, lead: bool, min_xyz: Point, order: u32) -> Weaver {
+        let mut preallocated = Vec::with_capacity(order as usize);
+        preallocated.extend(data.drain(..));
         Weaver {
-            data: data.drain(..).collect(),
-            verts,
+            data: preallocated,
             lead,
             min_xyz,
-            order: verts.len() as u32,
+            order,
         }
     }
 
@@ -65,28 +86,19 @@ impl<'a> Weaver<'a> {
             .iter()
             .circular_tuple_windows()
             .map(|(a, b)| orient(*a, *b))
-            .filter(|&(m, n)| {
-                is_valid_edge(
-                    self.verts[m as usize],
-                    self.verts[n as usize],
-                    self.min_xyz,
-                    self.order,
-                    false,
-                )
-            })
+            .filter(|&(m, n)| is_valid_edge(m, n, self.min_xyz, self.order, false))
             .collect()
     }
 
-    pub fn join(&mut self, edge: Edge, wedge: Edge, warp: &mut Tour) {
-        self.rotated_to_edge(edge);
-        Weaver::rotate_to_edge(warp, wedge);
-        self.data.append(warp);
-    }
-
-    pub fn rotated_to_edge(&mut self, (lhs, rhs): (u32, u32)) {
+    pub fn rotated_to_edge(&mut self, (lhs, rhs): ([i16; 3], [i16; 3])) {
+        // more prudent than using splice() which has preferences for optimality:
+        // The tail (elements in the vector after range) is empty,
+        // or replace_with yields fewer or equal elements than range’s length
+        // or the lower bound of its size_hint() is exact. blah blah blah.
+        // More steps to fulfill optimality than just doing what's correct.
         if lhs == self.data[self.data.len() - 1] && rhs == self.data[0] {
             self.data.reverse();
-        } else {
+        } else if !(lhs == self.data[0] && rhs == self.data[self.data.len() - 1]) {
             match (
                 self.data.iter().position(|&x| x == lhs).unwrap(),
                 self.data.iter().position(|&x| x == rhs).unwrap(),
@@ -100,19 +112,19 @@ impl<'a> Weaver<'a> {
         }
     }
 
-    pub fn rotate_to_edge(other: &mut Tour, (lhs, rhs): (u32, u32)) {
-        if lhs == other[other.len() - 1] && rhs == other[0] {
-            other.reverse();
-        } else {
+    pub fn rotate_to_edge(cycle: &mut Tour, (lhs, rhs): ([i16; 3], [i16; 3])) {
+        if lhs == cycle[cycle.len() - 1] && rhs == cycle[0] {
+            cycle.reverse();
+        } else if !(lhs == cycle[0] && rhs == cycle[cycle.len() - 1]) {
             match (
-                other.iter().position(|&x| x == lhs).unwrap(),
-                other.iter().position(|&x| x == rhs).unwrap(),
+                cycle.iter().position(|&x| x == lhs).unwrap(),
+                cycle.iter().position(|&x| x == rhs).unwrap(),
             ) {
                 (idx_lhs, idx_rhs) if idx_lhs < idx_rhs => {
-                    other.rotate_left(idx_rhs);
-                    other.reverse()
+                    cycle.rotate_left(idx_rhs);
+                    cycle.reverse()
                 }
-                (idx_lhs, _) => other.rotate_left(idx_lhs),
+                (idx_lhs, _) => cycle.rotate_left(idx_lhs),
             }
         }
     }
@@ -122,27 +134,43 @@ impl<'a> Weaver<'a> {
             .iter()
             .circular_tuple_windows()
             .map(|(a, b)| orient(*a, *b))
-            .filter(|&(m, n)| {
-                is_valid_edge(
-                    self.verts[m as usize],
-                    self.verts[n as usize],
-                    self.min_xyz,
-                    self.order,
-                    self.lead,
-                )
-            })
+            .filter(|&(m, n)| is_valid_edge(m, n, self.min_xyz, self.order, self.lead))
             .collect()
     }
 
-    pub fn get_nodes(&self) -> Solution {
+    pub fn get_weave(&self) -> Solution {
         self.data.to_vec()
     }
 
-    pub fn get_vectors(&self) -> VecVert {
-        self.data
-            .to_vec()
-            .iter()
-            .map(|node| self.verts[*node as usize])
-            .collect()
+    /// Python script using plotly and pandas to display the solution from the .csv file produced by the function below:
+    ///```
+    /// import pandas as pd
+    /// import plotly.express as px
+    ///
+    /// def create_3d_line_plot(file_path):
+    ///     df = pd.read_csv(file_path)
+    ///     fig = px.line_3d(df, x='X', y='Y', z='Z')
+    ///     fig.show()
+    ///
+    ///```
+    /// Save solution to file_path as a csv file where each axis X, Y, Z is a separate column.
+    /// Structured for easy read and plotting using python and plotly (see above).
+    pub fn save_to_csv(&self, file_path: &str) -> Result<(), Box<dyn Error>> {
+        let file = std::fs::File::create(file_path)?;
+        let mut writer = csv::Writer::from_writer(file);
+        self.data.iter().for_each(|[x, y, z]| {
+            writer
+                .serialize(Vector {
+                    x: *x,
+                    y: *y,
+                    z: *z,
+                })
+                .ok();
+        });
+        // Add first value to last to form a loop:
+        let [x, y, z] = self.data[0];
+        writer.serialize(Vector { x, y, z })?;
+        writer.flush()?;
+        Ok(())
     }
 }