menue eingefügt

Cargo.toml

@@ -4,4 +4,5 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-num-complex = "0.4"
+num-complex = "0.4"
+crossterm = "0.27"

src/arithmetic/basic_arithmetic_ops/brackets_solver.rs

@@ -17,8 +17,8 @@ pub fn calculate_resolve_brackets(numbers: Vec<String>) -> Vec<String> {
         let mut result_index_brackets: Vec<(usize, usize)> = find_index(&result_brackets_calc);
 
         // Hier hole ich den höchsten Index für die Klammerpaarungen
-        // und die Auflösungen nach dem Prinzip innen nach aussen, und 
-        // Klammern die unabhängig von den verschachtelten bin. Mit
+        // für die Auflösungen nach dem Prinzip von innen nach aussen, und 
+        // Klammernpaare die unabhängig von den verschachtelten sind. Mit
         // dieser Art wird die Reihenfolge eingehalten.
         for i in result_index_brackets.iter() {
             println!("Vektor Klammer: [{:?}, {:?}]", i.0, i.1);
@@ -61,7 +61,7 @@ fn calculate_brackets(numbers: &mut Vec<String>, brackets_index: (usize, usize))
     println!("Vektor davor: {:?}", numbers);
 
     // Ich benutze hier drain, damit kann ich den Teil für die Berechnung
-    // heraus entfernen. Dadurch wird mir der Teil gegeben den ich berechnen kann.
+    // heraus entfernen kann. Dadurch wird mir der Teil gegeben den ich berechnen kann.
     let mut removed_slices: Vec<String> = numbers.drain(brackets_index.0..=brackets_index.1).collect();
 
     // Die Klammern müssen entfernt werden sonst würde es zu
@@ -72,7 +72,7 @@ fn calculate_brackets(numbers: &mut Vec<String>, brackets_index: (usize, usize))
 
     println!("Herausgenommener Term: {:?}", removed_slices);
 
-    // Berechnen nach den Regeln/Reihenfolge der Mathemathik
+    // Berechnen nach den Regeln/Reihenfolge der Mathematik
     let bracket_result: String = rules_for_calculation(removed_slices);
 
     // Zuletzt wird hier das Ergebnis in den Verktor wieder eingefügt,

src/arithmetic/basic_arithmetic_ops/calculating.rs

@@ -90,12 +90,12 @@ pub fn calculate_numbers_mult_diff(numbers: Vec<String>) -> Vec<String> {
         }
 
         // Division
-        else if result_mul_div_vector[index].contains("/") {
+        else if result_mul_div_vector[index].contains(":") || result_mul_div_vector[index].contains("/") {
 
             counter_div += 1;
 
             println!("Vektor davor: {:?}", result_mul_div_vector);
-            let result_mult: String = calculate_mult_diff(&result_mul_div_vector, counter_div, '/');
+            let result_mult: String = calculate_mult_diff(&result_mul_div_vector, counter_div, result_mul_div_vector[index].parse::<char>().unwrap());
 
             removing_from_vector(&mut result_mul_div_vector, index, result_mult);
             println!("Vektor danach: {:?}", result_mul_div_vector);
@@ -126,7 +126,12 @@ fn calculate_mult_diff(numbers: &Vec<String>, counter: usize, which_operator: ch
                     result = left_right[0] * left_right[1];
                     operation = "Multiplikation".to_string();
                 }
-                '/' => {
+                ':' | '/' => {
+                    // Prüfen des rechten Operanden auf 0, wenn ja
+                    // abbruch.
+                    if left_right[1] == 0.0 {
+                        panic!("Division durch 0 nicht möglich!");
+                    }
                     result = left_right[0] / left_right[1];
                     operation = "Division".to_string();
                 }