changed_06_08_25

src/algebra/math_formulas/equations/linear_equations/solution_with_one_unknown.rs

@@ -1,49 +1,217 @@
-pub fn one_unknown(equation: String) {
+use crate::{arithmetic::basic_arithmetic_ops::calculation_rules::rules_for_calculation, paths::str_manipulation::{remove_variables_from_number, reorganize_variable_with_brackets, strings_refactor}};
+
+struct LeftRightSide {
+    left: Vec<String>,
+    right: Vec<String>,
+}
+
+pub fn one_unknown(equation: Vec<String>, original_equation: String) {
+
+    println!("\n1. Aufteilung der Gleichung:\n");
+
+    let mut left_right_side: LeftRightSide = split_left_right(equation);
+
+    println!("Links: {:?}", left_right_side.left);
+    println!("Rechts: {:?}", left_right_side.right);
+
+    println!("\n2. Umstellen nach x:\n");
+
+    reorganize_to_variable(&mut left_right_side);
+
+    // Zur Kontrolle ob es auch funktioniert 😎
+    println!("Links: {:?}", left_right_side.left);
+    println!("Rechts: {:?}", left_right_side.right);
+
+    println!("\nDie Variablen sind nur noch auf der rechten Seite.");
+    println!("\nJetzt werden die Zahlen von der rechten Seite\nauf die Linke verschoben\n");
+
+    reorganize_to_numbers(&mut left_right_side);
+
+    println!("Links: {:?}", left_right_side.left);
+    println!("Rechts: {:?}", left_right_side.right);
+
+    println!("\nJetzt sind die Zahlen auf der linken Seite\nund die Variablen auf der rechten.\n");
+
+    println!("\nDamit die rechte Seite mit den Variablen konform zu rechnen sind,\nmuss bei den einzelnen Variablen eine 1 davor gesetzt werden.\n");
+
+    println!("Links: {:?}", left_right_side.left);
+    println!("Rechts: {:?}", left_right_side.right);
+
+    println!("\n3. Berechnung der linken Seite:\n");
+
+    let string_left_temp = left_right_side.left.into_iter().map(|s| s.to_string()).collect();
+    left_right_side.left = strings_refactor(string_left_temp);
+
+    let result_left: String = rules_for_calculation(left_right_side.left);
+
+    println!("\n4. Berechnung der rechten Seite:\n");
+
+    println!("\nErstmal werden die x Variablen in den Token weggenommen.");
+    println!("\nVektor davor: {:?}", left_right_side.right);
+    let left_right_removed_variable: Vec<String> = remove_variables_from_number(left_right_side.right);
+
+    println!("Ergebnis rechte Seite: {:?}", left_right_removed_variable);
+
+    println!("\nJetzt wird die rechte Seite wie gewohnt berechnet und ein x mit angehängt.");
+    let string_right_temp: String = left_right_removed_variable.into_iter().map(|s| s.to_string()).collect();
+    let result_right: String = rules_for_calculation(strings_refactor(string_right_temp));
+
+    left_right_side.left = strings_refactor(result_left);
+    left_right_side.right = strings_refactor(result_right);
+
+    left_right_side.right.push("*".to_string());
+    left_right_side.right.push("x".to_string());
 
-    println!("\nOriginal Gleichung: {}", &equation);
+    println!("\nErgebnis links = {:?} und rechts = {:?}", left_right_side.left, left_right_side.right);
 
-    println!("\n1. Leerzeichen entfernen: \n");
+    println!("\n5. Finialisieren von der Gleichung:\n");
 
-    // Alle Leerzeichen entfernen
-    // let without_whitespaces: String = paths::str_manipulation::remove_whitespaces(equation);
+    println!("\n In diesem letzten Schritt wird das x abgelöst in dem wir den Wert vor x\n mit beiden Seiten teilen.\n");
+    println!("Dadurch bekommen wir eine Gleichung wie: x = 12");
 
-    // println!("Ergebnis: {}", without_whitespaces);
+    finalize_variable_to_result(&mut left_right_side);
 
+    let temp_left_result: String = rules_for_calculation(left_right_side.left);
 
-    // Der Split von der Gleichung zu einer rechten und linken Seite.
-    //let equation_split_equal: Vec<String> = without_whitespaces.split('=').map(str::to_string).collect(); 
+    println!("\nGleichungsergebnis: {:?} = {:?}", left_right_side.right, temp_left_result);
 
-    println!("\n2. Aufteilung der Gleichung: \n");
+    println!("\n5. Validierung/Überprüfung der Gleichung:\n");
+    println!("Jetzt werden die Variablen ersetzt durch den Wert wen wir \nausgerechnet haben.");
 
-    // for left_and_right in equation_split_equal.iter() {
-    //     println!("{}", left_and_right);
-    // }
+    validate_equation(temp_left_result, original_equation);
 
-    // Hier ersetze ich die Operatoren mit einem zusätzlichen Leerzeichen
-    // um es später weiter splitten zu können. Mit der ausgelagerten Funktion
-    // terms_replace_operators, damit spare ich mir redudanten Code.
-    //let terms_replaced_operators_both: String = paths::str_manipulation::terms_replace_operators(equation_split_equal);
+    //todo!("one_unknown not completed!")
 
-    println!("\n3. Leerzeichen vor den Operatoren setzten: \n");
+}
+
+// Diese Funktion ist zum aufteilen der Gleichung damit man sie auf jeder Seite
+// einzeln berechnen kann, bzw. zum besseren aufteilen von Variablen.
+fn split_left_right(split_terms: Vec<String>) -> LeftRightSide {
+
+    // Hier wird der aktuelle Vektor durchlaufen. Die Funktionen .position() gibt die 
+    // Position des Zeichen zurück und anhand daran wird es in eine Struktur geschrieben
+    // die hier in eine linke und rechte Seite enthält. Wenn das Zeichen nicht vorhanden
+    // ist wird es nur auf die linke Seite geschrieben.
+    let (left, right) = match split_terms.iter().position(|s| s == "=") {
+        Some(pos) => (
+            split_terms[..pos].to_vec(),
+            split_terms[pos + 1..].to_vec(),
+        ),
+        None => (split_terms.clone(), Vec::new()),
+    };
 
-    // for terms_with_whitespace_ops in terms_replaced_operators_both.iter() {
-    //     println!("{:+}", terms_with_whitespace_ops);
-    // }
+    LeftRightSide { left, right }
 }
 
+// Hier wird die Variable zu einer Seite gebracht. Hier habe ich die Methode 
+// gewählt die Variablen von hinten her zu erkennen, sie zu verschieben um
+// sie dann zu löschen. Damit erspare ich mir jedesmal die Indexierung neu
+// zu berechnen wenn ich es von vorne machen würde.
+fn reorganize_to_variable(lr_sides: &mut LeftRightSide) {
 
+    // Die Länge des Vektors ermitteln
+    let mut index: usize = lr_sides.left.len();
 
-fn split_x_and_number_terms(split_terms: Vec<&str>) -> (Vec<&str>, Vec<i32>) {
-    let mut tupel_terms: (Vec<&str>, Vec<i32>) = (Vec::new(), Vec::new());
+    // Schleife um den Vektor von hinten nach vorne durchzugehen.
+    while index > 0 {
+        index -= 1;
 
-    for term in split_terms {
-        if term.contains("x") {
-            tupel_terms.0.push(term);
+        let token: &String = &lr_sides.left[index];
+
+        // Wenn eine Variable gefunden wird, dann wird das Vorzeichen umgedreht
+        // und die Variable und dem Vorzeichen auf die andere Seite der Gleichung gebracht und von
+        // der linken Seite gelöscht und das Vorzeichen auch.
+        if token.contains("x") {
+            if index > 0 {
+                match lr_sides.left[index - 1].as_str() {
+                    "-" => lr_sides.right.push("+".to_string()),
+                    "+" => lr_sides.right.push("-".to_string()),
+                    _ => {}
+                }
+                lr_sides.right.push(lr_sides.left.remove(index));
+                lr_sides.left.remove(index - 1);
+
+                if index > 0 {
+                    index -= 1;
+                }
+            } else {
+                // Für den Fall das die Variable am Anfang steht und kein Vorzeichen hat.
+                // Laut Mathematik ist eine Variable oder Zahl immer positiv wenn es kein 
+                // Vorzeichen gibt. Und natürlich wird das Vorzeichen umgedreht.
+                lr_sides.right.push("-".to_string());
+                lr_sides.right.push(lr_sides.left.remove(0));
+            }
         }
-        else {
-            tupel_terms.1.push(term.parse::<i32>().unwrap());
+    }
+
+}
+
+// Diese Funktion ist wie die obige reorganize_to_variable aufgebaut.
+// Nur mit dem Unterschied das hier nach Zahlen gegangen wird.
+fn reorganize_to_numbers(lr_sides: &mut LeftRightSide) {
+    // Die Länge des Vektors
+    let mut index: usize = lr_sides.right.len();
+
+    // Schleife für den Vektor -> hinten nach vorne
+    while index > 0 {
+        index -= 1;
+
+        // Hier muss ich mit parse() arbeiten, da contains() auch solche Zahlen herausholt
+        // die zu einer Variablen gehören.
+        if lr_sides.right[index].parse::<f64>().is_ok() {
+            if index > 0 {
+                match lr_sides.right[index - 1].as_str() {
+                    "-" => lr_sides.left.push("+".to_string()),
+                    "+" => lr_sides.left.push("-".to_string()),
+                    _ => {},
+                }
+                lr_sides.left.push(lr_sides.right.remove(index));
+                lr_sides.right.remove(index - 1);
+
+                if index > 0 {
+                    index -= 1;
+                }
+            } else {
+                // Für den Fall das die Variable am Anfang steht und kein Vorzeichen hat.
+                // Laut Mathematik ist eine Variable oder Zahl immer positiv wenn es kein 
+                // Vorzeichen gibt. Und natürlich wird das Vorzeichen umgedreht.
+                lr_sides.left.push("-".to_string());
+                lr_sides.left.push(lr_sides.right.remove(0));
+            }
         }
     }
+}
+
+// Funktion für das Endergebnis zu Bsp.: x=12
+fn finalize_variable_to_result(final_equation: &mut LeftRightSide) {
+    let mut index: usize = 0;
+    let mut removed_value: String = String::new();
+
+    while index < final_equation.right.len() {
+        if final_equation.right[index] == "*" {
+            removed_value = final_equation.right.remove(index - 1);
+            final_equation.right.remove(index - 1);
+            final_equation.left.push(":".to_string());
+            final_equation.left.push(removed_value);
+            break;
+        }
+        index += 1;
+    }
+}
 
-    tupel_terms
+// Funktion zur Überprüfung ob die Gleichung richtig ist.
+fn validate_equation(string_equation: String, original_equation: String) {
+    let valdiation_variable: String = string_equation;
+
+    let temp: Vec<String> = strings_refactor(original_equation);
+
+    let left_right_side: LeftRightSide = split_left_right(reorganize_variable_with_brackets(temp, valdiation_variable));
+
+    let result_left: String = rules_for_calculation(left_right_side.left);
+    let result_right: String = rules_for_calculation(left_right_side.right);
+
+    println!("\nBessere Lesbarkeit: {:?} = {:?}", result_left, result_right);
+
+
+    //todo!("validate_equation not completed!")
 }

src/arithmetic/basic_arithmetic_ops/calculating.rs

@@ -26,6 +26,10 @@ pub fn calculate_numbers_powers(numbers: Vec<String>) -> Vec<String> {
         else {
             index += 1;
         }
+        if result_powers_vector[index].contains("1")  {
+            index += 1;
+        }
+
     }
     return result_powers_vector
 }
@@ -162,7 +166,7 @@ pub fn calculate_numbers_addition(numbers: Vec<String>) -> Vec<String> {
 
     while index < result_add_sub_vector.len(){
 
-        // Multiplikation
+        // Addition
         if result_add_sub_vector[index].contains("+") {
 
             counter_mult += 1;
@@ -176,7 +180,7 @@ pub fn calculate_numbers_addition(numbers: Vec<String>) -> Vec<String> {
             index = 0;
         }
 
-        // Division
+        // Subtraktion
         else if result_add_sub_vector[index].contains("-") && result_add_sub_vector[index].len() == 1 {
 
             counter_div += 1;