@sjcrh/proteinpaint-rust 2.11.1 → 2.25.0

package/Cargo.toml

@@ -24,6 +24,10 @@ libmath = "^0.2.1"
 json = "^0.12.4"
 serde = {version = "^1.0.147", features = ["derive"]}
 serde_json="^1.0.88"
+num = "^0.4.1"
+#r_stats = { git = "https://github.com/derekdreery/r_stats.git"}
+#r_stats = { git = "https://github.com/robinpaul85/r_stats.git"}
+
 
 [profile.release]
 lto = "fat"
@@ -58,3 +62,7 @@ path="src/sv.rs"
 [[bin]]
 name="cluster"
 path="src/cluster.rs"
+
+#[[bin]]
+#name="wilcoxon"
+#path="src/wilcoxon.rs"

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.11.1",
+  "version": "2.25.0",
   "name": "@sjcrh/proteinpaint-rust",
   "description": "Rust-based utilities for proteinpaint",
   "main": "index.js",

package/src/cluster.rs

@@ -55,35 +55,28 @@ use colorgrad;
 use json;
 use json::JsonValue;
 use kodama::{linkage, Method};
-use nalgebra::base::dimension::Const;
 use nalgebra::base::dimension::Dyn;
 use nalgebra::base::Matrix;
 use nalgebra::base::VecStorage;
 use nalgebra::DMatrix;
-use serde::ser::{SerializeStruct, Serializer};
 use serde::{Deserialize, Serialize};
 use serde_json;
 use std::env;
 //use ndarray::Array1;
 use ndarray::ArrayBase;
 use ndarray::OwnedRepr;
-use petgraph::algo::dijkstra;
-//use petgraph::dot::Dot;
-use petgraph::graph::NodeIndex;
-use petgraph::prelude::Graph;
 use plotters::prelude::*;
 use rayon::prelude::*;
 use std::any::type_name;
 use std::io;
 use std::time::Instant;
 
-#[allow(dead_code)]
-#[derive(Debug, Clone, Serialize, Deserialize)]
-struct NewNodeInfo {
-    node_id: usize,
-    #[serde(skip_serializing_if = "Vec::is_empty")]
-    child_nodes: Vec<usize>,
-    height: f64, // Contains the weight of the dissimilarity of that particular step. For original nodes this will just be the height from the top most node
+#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
+struct Steps {
+    cluster1: usize,
+    cluster2: usize,
+    dissimilarity: f64,
+    size: usize,
 }
 
 #[allow(dead_code)]
@@ -96,67 +89,6 @@ struct NodeCoordinate {
     y: Option<f64>, // The y-position stores the relative distance from the last (top most) node in the dendrogram
 }
 
-impl Serialize for NodeCoordinate {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let x = &self.x;
-        let y = &self.y;
-
-        let mut state;
-        if x.is_some() && y.is_some() {
-            state = serializer.serialize_struct("NodeCoordinate", 2)?;
-            state.serialize_field("x", &self.x)?;
-            state.serialize_field("y", &self.y)?;
-        } else {
-            state = serializer.serialize_struct("NodeCoordinate", 0)?;
-        }
-        state.end()
-    }
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Clone, Deserialize)]
-struct NewNodeRelativeCoordinates {
-    node_id: usize,                   // Node ID of the current node.
-    node_coordinates: NodeCoordinate, // (X,Y) coordinates of the current node.
-    #[serde(skip_serializing_if = "Vec::is_empty")]
-    child_nodes: Vec<usize>, // ID's of the child node (if it exists). There will be no child node for the original (input) nodes in the dendrogram.
-    #[serde(skip_serializing_if = "Vec::is_empty")]
-    child_node_coordinates: Vec<NodeCoordinate>, // (X,Y) coordinates of each of the two child nodes (if they exist).
-    all_original_nodes: Vec<usize>, // Contains list of original descendant nodes. To be displayed in UI on clicking a derived node (or line).
-}
-
-impl Serialize for NewNodeRelativeCoordinates {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let child_nodes = &self.child_nodes;
-        let node_id = &self.node_id;
-        let node_coordinates = &self.node_coordinates;
-        let child_node_coordinates = &self.child_node_coordinates;
-        let all_original_nodes = &self.all_original_nodes;
-
-        let mut state;
-        if child_nodes.len() == 0 && all_original_nodes.len() == 0 {
-            // This will be true in case of the original nodes
-            state = serializer.serialize_struct("NewNodeRelativeCoordinates", 2)?;
-            state.serialize_field("node_id", node_id)?;
-            state.serialize_field("node_coordinates", &self.node_coordinates)?;
-        } else {
-            state = serializer.serialize_struct("NewNodeRelativeCoordinates", 5)?;
-            state.serialize_field("node_id", node_id)?;
-            state.serialize_field("child_nodes", child_nodes)?;
-            state.serialize_field("node_coordinates", node_coordinates)?;
-            state.serialize_field("child_node_coordinates", child_node_coordinates)?;
-            state.serialize_field("all_original_nodes", all_original_nodes)?;
-        }
-        state.end()
-    }
-}
-
 #[allow(dead_code)]
 fn type_of<T>(_: T) -> &'static str {
     type_name::<T>()
@@ -281,12 +213,11 @@ fn euclidean_distance3(
 fn sort_elements(
     coordinates: &Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>,
     cluster_method: &String,
-) -> (Vec<usize>, Vec<NewNodeRelativeCoordinates>) {
+) -> Vec<Steps> {
     //fn sort_elements(coordinates: &Vec<Vec<f64>>) -> Vec<usize> {
     //fn sort_elements(coordinates: &Vec<Array1<f64>>) -> Vec<usize> {
     let new_now = Instant::now();
-    let mut sorted_nodes = Vec::<usize>::new();
-    let mut node_coordinates_list = Vec::<NewNodeRelativeCoordinates>::new();
+    let mut steps_vec = Vec::<Steps>::new();
     if coordinates.len() > 0 {
         //let mut condensed = vec![];
         //for row in 0..coordinates.len() - 1 {
@@ -295,17 +226,6 @@ fn sort_elements(
         //    }
         //}
         let mut condensed = euclidean_distance4(coordinates);
-        let column_means = Matrix::column_mean(coordinates);
-        //println!("column_means:{:?}", column_means);
-
-        let mut min_mean_value = 100000000000.0;
-        let mut min_mean_value_index = 0;
-        for i in 0..column_means.len() {
-            if column_means[i] < min_mean_value {
-                min_mean_value = column_means[i];
-                min_mean_value_index = i;
-            }
-        }
 
         //println!("condensed:{:?}", condensed);
         let new_now2 = Instant::now();
@@ -316,7 +236,9 @@ fn sort_elements(
         //println!("coordinates.len():{:?}", coordinates.len());
 
         let dend;
-        if cluster_method == &"Complete" {
+        if cluster_method == &"Single" {
+            dend = linkage(&mut condensed, coordinates.nrows(), Method::Single);
+        } else if cluster_method == &"Complete" {
             dend = linkage(&mut condensed, coordinates.nrows(), Method::Complete);
         } else if cluster_method == &"Average" {
             dend = linkage(&mut condensed, coordinates.nrows(), Method::Average);
@@ -338,270 +260,22 @@ fn sort_elements(
             new_now3.duration_since(new_now2)
         );
 
-        let mut deps = Graph::new_undirected();
-
-        // Adding nodes and edges to graph
-        println!("Number of original nodes:{}", coordinates.nrows());
-        for i in 0..coordinates.nrows() {
-            // Add original nodes to graph
-            deps.add_node(i);
-        }
-
         //println!("dend.steps().len(){:?}", dend.steps().len());
-        let mut new_nodes = Vec::<NewNodeInfo>::new();
-        let mut max_length_node_distance = 0.0; // max-length between all original nodes and the topmost node
+        println!("Number of nodes:{}", coordinates.nrows());
+        //println!("max_length_node_distance:{}", max_length_node_distance);
         for i in 0..dend.steps().len() {
             let step = &dend.steps()[i];
-            //println!("step:{:?}", step);
-            let current_cluster_label = coordinates.nrows() + i;
-            //println!("current_cluster_label:{}", current_cluster_label);
-            // Adding nodes
-            //let node1 = deps.add_node(step.cluster1);
-            //let node2 = deps.add_node(step.cluster2);
-            let node3 = deps.add_node(current_cluster_label);
-            //println!("node1:{:?}", node1);
-
-            let new_node = NewNodeInfo {
-                node_id: current_cluster_label,
-                child_nodes: vec![step.cluster1, step.cluster2],
-                height: step.dissimilarity,
-            };
-            new_nodes.push(new_node);
-            // Adding edges
-            deps.add_edge(
-                NodeIndex::from(step.cluster1 as u32),
-                node3,
-                step.dissimilarity,
-            );
-            deps.add_edge(
-                NodeIndex::from(step.cluster2 as u32),
-                node3,
-                step.dissimilarity,
-            );
-
-            if i == dend.steps().len() - 1 {
-                max_length_node_distance = step.dissimilarity
-            }
-        }
-        //println!("Graph:{}", Dot::new(&deps));
-        let new_now4 = Instant::now();
-        println!(
-            "Time taken to generate graph:{:?}",
-            new_now4.duration_since(new_now3)
-        );
-
-        let mut remaining_nodes: Vec<usize> = (0..coordinates.nrows()).collect();
-        //println!("remaining_nodes:{:?}", remaining_nodes);
-
-        // Initialize first node from cluster1 of first step, not sure if this is the best place from where to stop
-        //let mut current_node = dend.steps()[0].cluster1.clone();
-        let mut current_node = min_mean_value_index;
-
-        let mut num_iter = 0;
-        while remaining_nodes.len() > 0 {
-            let mut smallest_distance = 1000000000; // Initialized to very high value
-
-            //println!("current_node:{}", current_node);
-            let distances = dijkstra(
-                &deps,
-                NodeIndex::from(current_node as u32),
-                None,
-                //Some(NodeIndex::from(node as u32)),
-                |_| 1,
-            );
-
-            //println!("distances:{:?}", distances);
-            let mut next_node = current_node;
-            let mut degenerate_nodes = Vec::<usize>::new();
-            for item in distances {
-                if item.0.le(&NodeIndex::from(coordinates.nrows() as u32 - 1)) == true
-                    && item.0.ne(&NodeIndex::from(current_node as u32)) == true
-                    && sorted_nodes.contains(&item.0.index()) == false
-                {
-                    //println!("item:{:?}", item);
-                    if item.1 < smallest_distance {
-                        smallest_distance = item.1;
-                        next_node = item.0.index();
-                        degenerate_nodes = vec![]; // Delete all previous degenerate nodes if another node with closer distance is found.
-                    } else if item.1 == smallest_distance {
-                        // If a node with the same distance is found as that in the variable smallest_distance then add both nodes to degenerate_nodes vector
-                        if degenerate_nodes.len() == 0 {
-                            // Add the first node only if the vector is empty
-                            degenerate_nodes.push(next_node)
-                        }
-                        degenerate_nodes.push(item.0.index());
-                    }
-                }
-                if item.0.eq(&NodeIndex::from(
-                    new_nodes[new_nodes.len() - 1].node_id as u32,
-                )) == true
-                {
-                    //node_y = item.1;
-                    //println!("item:{:?}", item);
-                    node_coordinates_list.push(NewNodeRelativeCoordinates {
-                        node_id: current_node,
-                        node_coordinates: NodeCoordinate {
-                            x: Some(num_iter as f64),
-                            y: Some(1.0),
-                        },
-                        child_nodes: vec![], // These are the original nodes, so they have no child nodes
-                        child_node_coordinates: vec![
-                            NodeCoordinate { x: None, y: None },
-                            NodeCoordinate { x: None, y: None },
-                        ],
-                        all_original_nodes: vec![],
-                    });
-                }
-            }
-
-            if degenerate_nodes.len() > 0 {
-                next_node = closest_degenerate_nodes(current_node, degenerate_nodes, &column_means);
-            }
-            //println!("next_node:{}", next_node);
-            sorted_nodes.push(current_node);
-            remaining_nodes.remove(
-                remaining_nodes
-                    .iter()
-                    .position(|x| *x == current_node)
-                    .expect(&(current_node.to_string() + " not found")),
-            );
-            current_node = next_node;
-            num_iter += 1;
-            //println!("remaining_nodes:{:?}", remaining_nodes);
-        }
-        //println!("sorted_nodes:{:?}", sorted_nodes);
-        for i in 0..new_nodes.len() {
-            let current_node = &new_nodes[i];
-            let mut all_original_nodes = Vec::<usize>::new();
-            //println!("current_node:{:?}", current_node);
-            let distances = dijkstra(
-                &deps,
-                NodeIndex::from(current_node.node_id as u32),
-                None,
-                //Some(NodeIndex::from(node as u32)),
-                |_| 1,
-            );
-            //println!("distances:{:?}", distances);
-
-            // Computing relative y-coordinate of new node
-            let mut node_y = 0.0;
-            for item in distances {
-                if item.0.eq(&NodeIndex::from(
-                    new_nodes[new_nodes.len() - 1].node_id as u32,
-                )) == true
-                {
-                    node_y =
-                        (max_length_node_distance - current_node.height) / max_length_node_distance;
-                    // Normalizing distance with distance of the farthest node
-                    //println!("item:{:?}", item);
-                }
-
-                //if item.1 > max_length_node_distance {
-                //    max_length_node_distance = item.1
-                //}
-            }
-
-            let (child_node1_x, child_node2_x): (Option<f64>, Option<f64>);
-            let (child_node1_y, child_node2_y): (Option<f64>, Option<f64>);
-            let child1_search_result = node_coordinates_list
-                .iter()
-                .find(|&i| i.node_id == current_node.child_nodes[0]);
-            match child1_search_result {
-                Some(item) => {
-                    child_node1_x = item.node_coordinates.x;
-                    child_node1_y = item.node_coordinates.y;
-                    if item.node_id < coordinates.nrows() {
-                        // Select only original nodes and put them in all_original_nodes
-                        all_original_nodes.push(item.node_id)
-                    }
-                    for child_item in &item.all_original_nodes {
-                        // Iterate through the child's all_original_nodes vector and add them to the current vectors all_original_nodes
-                        all_original_nodes.push(*child_item)
-                    }
-                }
-                None => {
-                    // Should not happen
-                    panic!(
-                        "X-coordinate of child node not found:{}",
-                        current_node.child_nodes[0]
-                    );
-                }
-            }
-
-            let child2_search_result = node_coordinates_list
-                .iter()
-                .find(|&i| i.node_id == current_node.child_nodes[1]);
-            match child2_search_result {
-                Some(item) => {
-                    child_node2_x = item.node_coordinates.x;
-                    child_node2_y = item.node_coordinates.y;
-                    if item.node_id < coordinates.nrows() {
-                        // Select only original nodes and put them in all_original_nodes
-                        all_original_nodes.push(item.node_id)
-                    }
-                    for child_item in &item.all_original_nodes {
-                        // Iterate through the child's all_original_nodes vector and add them to the current vectors all_original_nodes
-                        all_original_nodes.push(*child_item)
-                    }
-                }
-                None => {
-                    // Should not happen
-                    panic!(
-                        "X-coordinate of child node not found:{}",
-                        current_node.child_nodes[1]
-                    );
-                }
-            }
-
-            node_coordinates_list.push(NewNodeRelativeCoordinates {
-                node_id: current_node.node_id,
-                node_coordinates: NodeCoordinate {
-                    x: Some((child_node1_x.unwrap() + child_node2_x.unwrap()) / 2.0),
-                    y: Some(node_y),
-                },
-                child_nodes: current_node.child_nodes.clone(),
-                child_node_coordinates: vec![
-                    NodeCoordinate {
-                        x: child_node1_x,
-                        y: child_node1_y,
-                    },
-                    NodeCoordinate {
-                        x: child_node2_x,
-                        y: child_node2_y,
-                    },
-                ],
-                all_original_nodes: all_original_nodes,
+            steps_vec.push(Steps {
+                cluster1: step.cluster1,
+                cluster2: step.cluster2,
+                dissimilarity: step.dissimilarity,
+                size: step.size,
             })
         }
-        //println!("node_coordinates_final:{:?}", node_coordinates_final);
-        let new_now5 = Instant::now();
-        println!(
-            "Time for sorting nodes:{:?}",
-            new_now5.duration_since(new_now4)
-        );
     } else {
         panic!("The dissimilarity matrix length cannot be zero");
     }
-    (sorted_nodes, node_coordinates_list)
-}
-
-fn closest_degenerate_nodes(
-    current_node: usize,
-    degenerate_nodes: Vec<usize>,
-    //means: &Matrix<f64, Const<1>, Dyn, VecStorage<f64, Const<1>, Dyn>>,
-    means: &Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>,
-) -> usize {
-    let mean_current_node = means[current_node];
-    let mut closest_node = 0;
-    let mut min_diff = 100000000000000.0;
-    for item in degenerate_nodes {
-        let mean_degenerate_node = means[item];
-        if (mean_degenerate_node - mean_current_node).abs() < min_diff {
-            min_diff = (mean_degenerate_node - mean_current_node).abs();
-            closest_node = item;
-        }
-    }
-    closest_node
+    steps_vec
 }
 
 fn main() {
@@ -679,11 +353,11 @@ fn main() {
                     }
                     //println!("cluster_method:{}", cluster_method);
 
-                    let plot_image;
+                    let _plot_image;
                     let plot_image_option = &json_string["plot_image"].as_bool();
                     match plot_image_option {
-                        Some(plot_image_op) => plot_image = plot_image_op.to_owned(),
-                        None => plot_image = false,
+                        Some(plot_image_op) => _plot_image = plot_image_op.to_owned(),
+                        None => _plot_image = false,
                     }
                     //println!("plot_image:{}", plot_image);
 
@@ -732,75 +406,88 @@ fn main() {
 
                     // Build our condensed matrix by computinghe dissimilarity between all
                     // possible coordinate pairs.
-                    let (sorted_col_elements, sorted_col_coordinates) =
-                        sort_elements(&input_matrix, &cluster_method);
-                    println!("sorted_col_elements:{:?}", sorted_col_elements);
-
-                    let (sorted_row_elements, sorted_row_coordinates) =
-                        sort_elements(&input_matrix.transpose(), &cluster_method);
-                    println!("sorted_row_elements:{:?}", sorted_row_elements);
-                    let mut sorted_row_names = Vec::<String>::new();
-                    let mut sorted_col_names = Vec::<String>::new();
-
-                    match row_string_search.as_str() {
-                        Some(_row_string_se) => {
-                            sorted_row_names = sorted_row_elements
-                                .clone()
-                                .into_iter()
-                                .map(|x| row_names[x].clone())
-                                .collect::<Vec<String>>();
-                        }
-                        None => {}
-                    }
-
-                    match col_string_search.as_str() {
-                        Some(_col_string_se) => {
-                            sorted_col_names = sorted_col_elements
-                                .clone()
-                                .into_iter()
-                                .map(|x| col_names[x].clone())
-                                .collect::<Vec<String>>();
-                        }
-                        None => {}
-                    }
-                    //println!("sorted_row_names:{:?}", sorted_row_names);
-                    //println!("sorted_col_names:{:?}", sorted_col_names);
-
-                    let mut sorted_col_coordinates_string = "[".to_string();
-                    for i in 0..sorted_col_coordinates.len() {
-                        sorted_col_coordinates_string +=
-                            &serde_json::to_string(&sorted_col_coordinates[i]).unwrap();
-                        if i != sorted_col_coordinates.len() - 1 {
-                            sorted_col_coordinates_string += &",".to_string();
+                    let col_steps = sort_elements(&input_matrix, &cluster_method);
+                    let mut col_output_string = "[".to_string();
+                    for i in 0..col_steps.len() {
+                        col_output_string += &serde_json::to_string(&col_steps[i]).unwrap();
+                        if i != col_steps.len() - 1 {
+                            col_output_string += &",".to_string();
                         }
                     }
-                    sorted_col_coordinates_string += &"]".to_string();
-                    println!("sorted_col_coordinates:{:?}", sorted_col_coordinates_string);
-
-                    let mut sorted_row_coordinates_string = "[".to_string();
-                    for i in 0..sorted_row_coordinates.len() {
-                        sorted_row_coordinates_string +=
-                            &serde_json::to_string(&sorted_row_coordinates[i]).unwrap();
-                        if i != sorted_row_coordinates.len() - 1 {
-                            sorted_row_coordinates_string += &",".to_string();
+                    col_output_string += &"]".to_string();
+                    println!("colSteps:{:?}", col_output_string);
+                    let row_steps = sort_elements(&input_matrix.transpose(), &cluster_method);
+                    let mut row_output_string = "[".to_string();
+                    for i in 0..row_steps.len() {
+                        row_output_string += &serde_json::to_string(&row_steps[i]).unwrap();
+                        if i != row_steps.len() - 1 {
+                            row_output_string += &",".to_string();
                         }
                     }
-                    sorted_row_coordinates_string += &"]".to_string();
-                    println!("sorted_row_coordinates:{:?}", sorted_row_coordinates_string);
-                    if plot_image == true {
-                        let sorted_matrix =
-                            sort_matrix(sorted_col_elements, sorted_row_elements, &input_matrix);
-                        let sorted_matrix_transpose = sorted_matrix.transpose();
-                        //println!(
-                        //    "sorted_matrix:{:?}",
-                        //    &serde_json::to_string(&sorted_matrix_transpose).unwrap()
-                        //);
-                        let _plot_result = plot_matrix(
-                            &sorted_matrix_transpose,
-                            sorted_row_names,
-                            sorted_col_names,
-                        );
-                    }
+                    row_output_string += &"]".to_string();
+                    println!("rowSteps:{:?}", row_output_string);
+                    //let mut sorted_row_names = Vec::<String>::new();
+                    //let mut sorted_col_names = Vec::<String>::new();
+                    //
+                    //match row_string_search.as_str() {
+                    //    Some(_row_string_se) => {
+                    //        sorted_row_names = sorted_row_elements
+                    //            .clone()
+                    //            .into_iter()
+                    //            .map(|x| row_names[x].clone())
+                    //            .collect::<Vec<String>>();
+                    //    }
+                    //    None => {}
+                    //}
+                    //
+                    //match col_string_search.as_str() {
+                    //    Some(_col_string_se) => {
+                    //        sorted_col_names = sorted_col_elements
+                    //            .clone()
+                    //            .into_iter()
+                    //            .map(|x| col_names[x].clone())
+                    //            .collect::<Vec<String>>();
+                    //    }
+                    //    None => {}
+                    //}
+                    ////println!("sorted_row_names:{:?}", sorted_row_names);
+                    ////println!("sorted_col_names:{:?}", sorted_col_names);
+                    //
+                    //let mut sorted_col_coordinates_string = "[".to_string();
+                    //for i in 0..sorted_col_coordinates.len() {
+                    //    sorted_col_coordinates_string +=
+                    //        &serde_json::to_string(&sorted_col_coordinates[i]).unwrap();
+                    //    if i != sorted_col_coordinates.len() - 1 {
+                    //        sorted_col_coordinates_string += &",".to_string();
+                    //    }
+                    //}
+                    //sorted_col_coordinates_string += &"]".to_string();
+                    ////println!("sorted_col_coordinates:{:?}", sorted_col_coordinates_string);
+                    //
+                    //let mut sorted_row_coordinates_string = "[".to_string();
+                    //for i in 0..sorted_row_coordinates.len() {
+                    //    sorted_row_coordinates_string +=
+                    //        &serde_json::to_string(&sorted_row_coordinates[i]).unwrap();
+                    //    if i != sorted_row_coordinates.len() - 1 {
+                    //        sorted_row_coordinates_string += &",".to_string();
+                    //    }
+                    //}
+                    //sorted_row_coordinates_string += &"]".to_string();
+                    ////println!("sorted_row_coordinates:{:?}", sorted_row_coordinates_string);
+                    //if plot_image == true {
+                    //    let sorted_matrix =
+                    //        sort_matrix(sorted_col_elements, sorted_row_elements, &input_matrix);
+                    //    let sorted_matrix_transpose = sorted_matrix.transpose();
+                    //    //println!(
+                    //    //    "sorted_matrix:{:?}",
+                    //    //    &serde_json::to_string(&sorted_matrix_transpose).unwrap()
+                    //    //);
+                    //    let _plot_result = plot_matrix(
+                    //        &sorted_matrix_transpose,
+                    //        sorted_row_names,
+                    //        sorted_col_names,
+                    //    );
+                    //}
                 }
                 Err(error) => println!("Incorrect json: {}", error),
             }
@@ -810,6 +497,7 @@ fn main() {
     }
 }
 
+#[allow(dead_code)]
 fn sort_matrix(
     // Rearranging matrix so as to plot it
     sorted_elements: Vec<usize>,
@@ -836,6 +524,7 @@ fn sort_matrix(
     sorted_array
 }
 
+#[allow(dead_code)]
 fn plot_matrix(
     original_array: &Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>,
     sorted_row_names: Vec<String>,