Struct SystemSolver 

pub struct SystemSolver;

System equation solver

Implementations

impl SystemSolver

pub fn new() -> Self

Trait Implementations

impl Clone for SystemSolver

fn clone(&self) -> SystemSolver

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SystemSolver

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SystemSolver

fn default() -> Self

Returns the “default value” for a type.

impl EquationSolver for SystemSolver

fn solve(&self, equation: &Expression, variable: &Symbol) -> SolverResult

Solve equation for given variable

fn solve_with_explanation( &self, equation: &Expression, variable: &Symbol, ) -> (SolverResult, StepByStepExplanation)

Solve with step-by-step explanation

fn can_solve(&self, _equation: &Expression) -> bool

Check if solver can handle this equation type

impl SystemEquationSolver for SystemSolver

fn solve_system( &self, equations: &[Expression], variables: &[Symbol], ) -> SolverResult

Solve system of linear or polynomial equations

Automatically detects system type and routes to appropriate solver:

• Linear systems: LU decomposition via Matrix::solve()
• Polynomial systems: Gröbner basis computation (Buchberger’s algorithm)

Examples

Linear system:

use mathhook_core::algebra::solvers::{SystemSolver, SystemEquationSolver};
use mathhook_core::{Expression, symbol};

let x = symbol!(x);
let y = symbol!(y);
// System: 2x + y = 5, x - y = 1
let eq1 = Expression::add(vec![
    Expression::mul(vec![Expression::integer(2), Expression::symbol(x.clone())]),
    Expression::symbol(y.clone()),
    Expression::integer(-5)
]);
let eq2 = Expression::add(vec![
    Expression::symbol(x.clone()),
    Expression::mul(vec![Expression::integer(-1), Expression::symbol(y.clone())]),
    Expression::integer(-1)
]);
let solver = SystemSolver::new();
let result = solver.solve_system(&[eq1, eq2], &[x, y]);
// Solution: x = 2, y = 1

Polynomial system:

use mathhook_core::algebra::solvers::{SystemSolver, SystemEquationSolver};
use mathhook_core::{Expression, symbol, expr};

let x = symbol!(x);
let y = symbol!(y);
// System: x² + y² = 1, x - y = 0
let eq1 = Expression::add(vec![expr!(x^2), expr!(y^2), expr!(-1)]);
let eq2 = expr!(x - y);
let solver = SystemSolver::new();
let result = solver.solve_system(&[eq1, eq2], &[x, y]);
// Finds intersection of circle and line

fn solve_system_with_explanation( &self, equations: &[Expression], variables: &[Symbol], ) -> (SolverResult, StepByStepExplanation)

Solve system with step-by-step explanation