temp

src/container.rs

@@ -50,7 +50,7 @@ impl Container {
     pub fn add_element(&mut self, mut element: Element) -> Result<usize, StatusError> {
         element.id = self.elements.len();
         element.validate()?;
-        let id: usize = self.add_element_core(element);
+        let id: usize = self.add_element_no_id(element);
         let check = self.validate();
         if check.is_err() {
             self.elements.pop();
@@ -59,7 +59,7 @@ impl Container {
         Ok(id)
     }
 
-    pub(crate) fn add_element_core(&mut self, mut element: Element) -> usize {
+    pub(crate) fn add_element_no_id(&mut self, mut element: Element) -> usize {
         let id: usize = self.elements.len();
         if element.name == "" {
             element.name = element.class.basic_string();
@@ -69,6 +69,15 @@ impl Container {
         id
     }
 
+    pub(crate) fn add_element_core(&mut self, mut element: Element) -> usize {
+        if element.name == "" {
+            element.name = element.class.basic_string();
+        }
+        let id = element.id.clone();
+        self.elements.push(Rc::new(RefCell::new(element)));
+        id
+    }
+
     fn add_tool(&mut self, mut tool: Tool) {
         if !self.tools.is_empty() {
             let new_id: usize = self.tools.get(self.tools.len() - 1).unwrap().borrow().id + 1;
@@ -389,8 +398,8 @@ mod tests {
         .unwrap();
 
         let mut container = Container::new();
-        container.add_element_core(Element::new(Resistor, 1.0, vec![2], vec![3]));
-        container.add_element_core(Element::new(Resistor, 1.0, vec![2], vec![3]));
+        container.add_element_no_id(Element::new(Resistor, 1.0, vec![2], vec![3]));
+        container.add_element_no_id(Element::new(Resistor, 1.0, vec![2], vec![3]));
         println!("{:?}", container);
         assert!(re.is_match(&format!("{:?}", container)));
     }
@@ -406,7 +415,7 @@ mod tests {
 
         // Test multiple grounds
         container = create_basic_container();
-        container.add_element_core(Element::new(Ground, 1.0, vec![2], vec![]));
+        container.add_element_no_id(Element::new(Ground, 1.0, vec![2], vec![]));
         assert!(container.validate().is_err());
     }
 

src/elements.rs

@@ -1,28 +1,30 @@
 use crate::component::Component;
 use crate::component::Component::Ground;
+use crate::container::Container;
 use crate::util::PrettyPrint;
 use crate::validation::Status::Valid;
 use crate::validation::StatusError::Known;
-use crate::validation::{Validation, ValidationResult};
+use crate::validation::{StatusError, Validation, ValidationResult};
 use operations::math::{EquationMember, EquationRepr};
 use operations::prelude::{Operation, Value};
 use serde::ser::SerializeStruct;
 use serde::{Deserialize, Serialize, Serializer};
 use std::cell::RefCell;
 use std::fmt::Display;
+use std::rc::{Rc, Weak};
 
 /// Representation of a Schematic Element
 #[derive(Debug, Deserialize, Clone)]
 pub struct Element {
     #[serde(skip_deserializing)]
     pub(crate) name: String,
-    pub(crate) id: usize, //
+    pub(crate) id: usize,  //
     pub(crate) value: f64, //
     #[serde(skip_deserializing)]
     pub(crate) current: Operation,
     #[serde(skip_deserializing)]
     pub(crate) voltage_drop: f64,
-    pub(crate) class: Component, //
+    pub(crate) class: Component,     //
     pub(crate) positive: Vec<usize>, // Link to other elements
     pub(crate) negative: Vec<usize>, //
 }
@@ -84,6 +86,17 @@ impl Element {
     pub(crate) fn set_voltage_drop(&mut self, voltage_drop: f64) {
         self.voltage_drop = voltage_drop;
     }
+
+    pub(crate) fn get_positive_elements(
+        &self,
+        container: &Container,
+    ) -> Result<Vec<Weak<RefCell<Element>>>, StatusError> {
+        let out = Vec::new();
+        for id in self.positive.iter() {
+            let element: Weak<RefCell<Element>> = Rc::downgrade(container.get_element_by_id(*id));
+        }
+        Ok(out)
+    }
 }
 
 impl PrettyPrint for Element {

src/interfaces.rs

@@ -47,6 +47,14 @@ pub fn get_tools(container_js: JsValue) -> Result<String, StatusError> {
     Ok(serde_json::to_string(&nodes).unwrap())
 }
 
+#[wasm_bindgen]
+pub fn validate(container_js: JsValue) -> Result<String, StatusError> {
+    let setup: ContainerSetup = from_value(container_js).unwrap();
+    let mut c: Container = Container::from(setup);
+    c.validate()?;
+    Ok(String::from("Validated Successfully"))
+}
+
 #[wasm_bindgen]
 pub fn solve(matrix: bool, nodal: bool, container_js: JsValue) -> Result<String, String> {
     let setup: ContainerSetup = if let Ok(setup) = from_value(container_js) {
@@ -64,6 +72,7 @@ pub fn solve(matrix: bool, nodal: bool, container_js: JsValue) -> Result<String,
             c.create_super_nodes()?;
             let steps: Vec<Step>;
             if matrix {
+                return Err(String::from(Known("Matrix solver not implemented for nodal".to_string())));
                 let mut solver: NodeMatrixSolver = Solver::new(Rc::new(RefCell::new(c)));
                 steps = solver.solve()?;
             } else {
@@ -73,34 +82,16 @@ pub fn solve(matrix: bool, nodal: bool, container_js: JsValue) -> Result<String,
             serialize_steps(steps)
         }
         false => {
-            c.create_meshes();
-            c.create_super_meshes();
-            Err(format!(
+            return Err(format!(
                 "{} Solver not implemented for meshes",
                 if matrix { "Matrix" } else { "Step" }
-            ))
+            ));
+            c.create_meshes();
+            c.create_super_meshes();
         }
     };
 }
 
-#[wasm_bindgen]
-pub fn return_solved_step_example() -> Result<String, String> {
-    let mut c: Container = create_mna_container();
-    c.create_nodes()?;
-    c.create_super_nodes()?;
-    let mut solver: NodeStepSolver = Solver::new(Rc::new(RefCell::new(c)));
-    serialize_steps(solver.solve()?)
-}
-
-#[wasm_bindgen]
-pub fn return_solved_matrix_example() -> Result<String, String> {
-    let mut c: Container = create_mna_container();
-    c.create_nodes()?;
-    c.create_super_nodes()?;
-    let mut solver: NodeMatrixSolver = Solver::new(Rc::new(RefCell::new(c)));
-    serialize_steps(solver.solve()?)
-}
-
 #[wasm_bindgen]
 pub fn test_wasm() -> String {
     "Hello from Rust! 🦀🦀🦀".to_string()
@@ -129,7 +120,7 @@ impl From<Vec<Element>> for Container {
     fn from(wasm: Vec<Element>) -> Container {
         let mut container = Container::new();
         for element in wasm {
-            container.add_element_core(element);
+            container.add_element_no_id(element);
         }
         container
     }
@@ -139,7 +130,7 @@ impl From<ContainerSetup> for Container {
     fn from(setup: ContainerSetup) -> Container {
         let mut container = Container::new();
         for element in setup.elements {
-            container.add_element_core(element);
+            container.add_element_no_id(element);
         }
         container
     }

src/solvers/mesh_matrix_solver.rs

@@ -1,5 +1,6 @@
 use crate::container::Container;
 use crate::solvers::solver::{Solver, Step};
+use crate::validation::StatusError;
 use std::cell::RefCell;
 use std::rc::Rc;
 
@@ -14,7 +15,7 @@ impl Solver for MeshMatrixSolver {
         MeshMatrixSolver { container }
     }
 
-    fn solve(&mut self) -> Result<Vec<Step>, String> {
+    fn solve(&mut self) -> Result<Vec<Step>, StatusError> {
         todo!()
     }
 }

src/solvers/mesh_step_solver.rs

@@ -1,5 +1,6 @@
 use crate::container::Container;
 use crate::solvers::solver::{Solver, Step};
+use crate::validation::StatusError;
 use std::cell::RefCell;
 use std::rc::Rc;
 
@@ -14,7 +15,7 @@ impl Solver for MeshStepSolver {
         MeshStepSolver { container }
     }
 
-    fn solve(&mut self) -> Result<Vec<Step>, String> {
+    fn solve(&mut self) -> Result<Vec<Step>, StatusError> {
         todo!()
     }
 }

src/solvers/node_matrix_solver.rs

@@ -3,7 +3,8 @@ use crate::container::Container;
 use crate::elements::Element;
 use crate::solvers::solver::{Solver, Step, SubStep};
 use crate::util::PrettyPrint;
-use crate::validation::Validation;
+use crate::validation::StatusError::Known;
+use crate::validation::{StatusError, Validation};
 use nalgebra::{DMatrix, DVector};
 use operations::math::{EquationMember, EquationRepr};
 use operations::prelude::{Divide, Negate, Operation, Sum, Text, Value, Variable};
@@ -40,7 +41,7 @@ impl Solver for NodeMatrixSolver {
     }
 
     /// Returns a string that represents the matrix equation to solve the circuit.
-    fn solve(&mut self) -> Result<Vec<Step>, String> {
+    fn solve(&mut self) -> Result<Vec<Step>, StatusError> {
         let mut steps: Vec<Step> = Vec::new();
 
         let inverse_result: Option<DMatrix<f64>> = DMatrix::from_iterator(
@@ -56,10 +57,10 @@ impl Solver for NodeMatrixSolver {
                 inverse = a;
             }
             None => {
-                return Err(format!(
+                return Err(Known(format!(
                     "Matrix is not invertible!\nThis might have something to do with sizing.\n{}\n",
                     self.a_matrix.latex_string()
-                ));
+                )));
             }
         }
 

src/solvers/node_step_solver.rs

@@ -4,7 +4,8 @@ use crate::elements::Element;
 use crate::solvers::solver::{Solver, Step, SubStep};
 use crate::tools::Tool;
 use crate::tools::ToolType::{Node, SuperNode};
-use crate::validation::Validation;
+use crate::validation::StatusError::Known;
+use crate::validation::{StatusError, Validation};
 use nalgebra::{DMatrix, DVector};
 use operations::mappings::expand;
 use operations::math::EquationMember;
@@ -64,7 +65,7 @@ impl Solver for NodeStepSolver {
     /// Returns a vector of strings that represent the steps to solve the circuit.
     ///
     /// This Handles the formatting of the data into what the frontend requires.
-    fn solve(&mut self) -> Result<Vec<Step>, String> {
+    fn solve(&mut self) -> Result<Vec<Step>, StatusError> {
         // SETUP and CALCULATIONS
         self.setup_connections()?;
         self.setup_node_equations()?;
@@ -121,7 +122,7 @@ impl NodeStepSolver {
         Ok(())
     }
 
-    fn solve_node_voltages(&mut self) -> Result<(), String> {
+    fn solve_node_voltages(&mut self) -> Result<(), StatusError> {
         let mut source_voltages: DVector<f64> = DVector::zeros(self.sources.len() + 1);
 
         self.sources.iter().enumerate().for_each(|(i, x)| {
@@ -147,17 +148,32 @@ impl NodeStepSolver {
             });
         });
 
-        let inverse_result: Result<DMatrix<f64>, Box<dyn Any + Send>> =
-            panic::catch_unwind(|| self.connection_matrix.clone().try_inverse().unwrap());
+        if self.connection_matrix.len() == 0 {
+            return Err(Known("No nodes to solve".to_string()));
+        }
+        if !self.connection_matrix.is_square() {
+            return Err(Known(format!(
+                "Matrix is not square: {}",
+                self.connection_matrix.equation_repr()
+            )));
+        }
+
+        let inverse_result: Result<Option<DMatrix<f64>>, Box<dyn Any + Send>> =
+            panic::catch_unwind(|| self.connection_matrix.clone().try_inverse());
 
         let inverse: DMatrix<f64>;
         if let Err(_) = inverse_result {
-            return Err(format!(
+            return Err(Known(format!(
                 "Unable to invert matrix: {}",
                 self.connection_matrix.equation_repr()
-            ));
+            )));
+        } else if let Ok(None) = inverse_result {
+            return Err(Known(format!(
+                "Unable to invert matrix: {}",
+                self.connection_matrix.equation_repr()
+            )));
         } else {
-            inverse = inverse_result.unwrap();
+            inverse = inverse_result.unwrap().unwrap();
         }
 
         self.inverse = inverse.clone();

src/solvers/solver.rs

@@ -1,4 +1,5 @@
 use crate::container::Container;
+use crate::validation::StatusError;
 use operations::prelude::*;
 use serde::ser::SerializeStruct;
 use serde::{Deserialize, Serialize, Serializer};
@@ -12,7 +13,7 @@ use wasm_bindgen::JsValue;
 
 pub trait Solver {
     fn new(container: Rc<RefCell<Container>>) -> Self;
-    fn solve(&mut self) -> Result<Vec<Step>, String>;
+    fn solve(&mut self) -> Result<Vec<Step>, StatusError>;
 }
 
 #[derive(Clone, Serialize, Deserialize, Debug)]