Struct LinearSolver 

pub struct LinearSolver {
    pub show_steps: bool,
}

Handles linear equations with step-by-step explanations

Fields

show_steps: bool

Enable step-by-step explanations

Implementations

impl LinearSolver

pub fn new() -> Self

Create new linear solver

pub fn new_fast() -> Self

Create solver without step-by-step (for performance)

Trait Implementations

impl Clone for LinearSolver

fn clone(&self) -> LinearSolver

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LinearSolver

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

Formats the value using the given formatter.

impl Default for LinearSolver

fn default() -> Self

Returns the “default value” for a type.

impl EquationSolver for LinearSolver

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

Solve linear equation ax + b = 0

Fractional solutions are automatically simplified to lowest terms via BigRational::new(), which reduces fractions using GCD. Integer solutions (where numerator is divisible by denominator) are returned as integers.

Examples

use mathhook_core::algebra::solvers::{linear::LinearSolver, EquationSolver, SolverResult};
use mathhook_core::core::{Expression, Number};
use mathhook_core::symbol;
use num_bigint::BigInt;

let solver = LinearSolver::new_fast();
let x = symbol!(x);

// Example: 4x = 6 gives x = 3/2 (simplified from 6/4)
let equation = Expression::add(vec![
    Expression::mul(vec![Expression::integer(4), Expression::symbol(x.clone())]),
    Expression::integer(-6),
]);

match solver.solve(&equation, &x) {
    SolverResult::Single(solution) => {
        if let Expression::Number(Number::Rational(r)) = solution {
            assert_eq!(r.numer(), &BigInt::from(3));
            assert_eq!(r.denom(), &BigInt::from(2));
        }
    }
    _ => panic!("Expected single solution"),
}

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 this solver can handle the equation