SimulSolverTest.java

import Engineering.EngCalc;
import Scientific.SimulSolver;
import java.util.*;

public class SimulSolverTest {
    private static final Scanner scanner = new Scanner(System.in);
    private static final EngCalc engCalc = new EngCalc();

    public static void main(String[] args) {
        System.out.println("===== Simultaneous Equation Solver =====\n");
        System.out.println("Choose the system to solve:");
        System.out.println("1. 2x2 System of Equations");
        System.out.println("2. 3x3 System of Equations");

        int choice = Integer.parseInt(scanner.nextLine().trim());

        switch (choice) {
            case 1:
                solve2x2System();
                break;
            case 2:
                solve3x3System();
                break;
            default:
                System.out.println("Invalid choice. Exiting...");
        }
    }

    private static void solve2x2System() {
        System.out.println("\nEnter two equations in the form: ax + by = c");

        double[][] A = new double[2][2];
        double[][] B = new double[2][1];

        for (int i = 0; i < 2; i++) {
            System.out.printf("Enter equation %d: ", i + 1);
            String equation = scanner.nextLine().trim();

            Map<String, Double> coefficients = parseEquation(equation, new String[]{"x", "y"});
            A[i][0] = coefficients.getOrDefault("x", 0.0);
            A[i][1] = coefficients.getOrDefault("y", 0.0);
            B[i][0] = coefficients.get("constant");
        }

        try {
            double[] solution = SimulSolver.solve2x2(A, B);
            System.out.printf("Solution:\n x = %.6f, y = %.6f\n", solution[0], solution[1]);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }

    private static void solve3x3System() {
        System.out.println("\nEnter three equations in the form: ax + by + cz = d");

        double[][] A = new double[3][3];
        double[][] B = new double[3][1];

        for (int i = 0; i < 3; i++) {
            System.out.printf("Enter equation %d: ", i + 1);
            String equation = scanner.nextLine().trim();

            Map<String, Double> coefficients = parseEquation(equation, new String[]{"x", "y", "z"});
            A[i][0] = coefficients.getOrDefault("x", 0.0);
            A[i][1] = coefficients.getOrDefault("y", 0.0);
            A[i][2] = coefficients.getOrDefault("z", 0.0);
            B[i][0] = coefficients.get("constant");
        }

        try {
            double[] solution = SimulSolver.solve3x3(A, B);
            System.out.printf("Solution:\n x = %.6f, y = %.6f, z = %.6f\n", solution[0], solution[1], solution[2]);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }

    private static Map<String, Double> parseEquation(String equation, String[] variables) {
        Map<String, Double> coefficients = new HashMap<>();
        coefficients.put("constant", 0.0); // Initialize constant term
    
        // Normalize the equation: remove spaces and separate RHS
        equation = equation.replace(" ", "");
        String[] parts = equation.split("=");
    
        if (parts.length != 2) {
            throw new IllegalArgumentException("Invalid equation format. Use 'ax + by + cz = d'.");
        }
    
        String lhs = parts[0]; // Left-hand side
        double rhs = Double.parseDouble(parts[1]); // Right-hand side
    
        // Split the left-hand side into terms using regex
        String[] terms = lhs.split("(?=[+-])"); // Splits at '+' or '-' but keeps them
    
        for (String term : terms) {
            term = term.trim();
            if (term.isEmpty()) continue;
    
            boolean isVariable = false;
    
            // Check for variables (x, y, z)
            for (String var : variables) {
                if (term.contains(var)) {
                    isVariable = true;
    
                    // Extract the coefficient part
                    String coefficient = term.replace(var, "");
                    double value;
    
                    if (coefficient.isEmpty() || coefficient.equals("+")) {
                        value = 1.0; // Implicit +1
                    } else if (coefficient.equals("-")) {
                        value = -1.0; // Implicit -1
                    } else {
                        value = Double.parseDouble(coefficient); // Explicit coefficient
                    }
    
                    // Store the coefficient
                    coefficients.put(var, coefficients.getOrDefault(var, 0.0) + value);
                    break;
                }
            }
    
            // If no variable is found, it's a constant term
            if (!isVariable) {
                coefficients.put("constant", coefficients.get("constant") + Double.parseDouble(term));
            }
        }
    
        // Adjust the constant term to move RHS to LHS
        coefficients.put("constant", coefficients.get("constant") - rhs);
    
        return coefficients;
    }
    
}