Implementing Quadratic Equations and Polynomial Evaluations in Rust

Rust, being a memory-safe system programming language, is great for numerical computations due to its performance and reliability. In this article, we will explore how to implement quadratic equations and general polynomial evaluations in Rust.

Understanding Quadratic Equations

A quadratic equation is a second-order polynomial in a single variable with three coefficients: a, b, and c. It is generally written as:

a * x2 + b * x + c = 0

The solutions for x can be found using the quadratic formula:

x = (-b ± √(b2 - 4ac)) / (2a)

Implementing a Quadratic Solver in Rust

Let's start by implementing a quadratic solver in Rust:

fn solve_quadratic(a: f64, b: f64, c: f64) -> Vec<f64> {
    let discriminant = b.powi(2) - 4.0 * a * c;
    if discriminant > 0.0 {
        // Two real solutions
        let sqrt_discriminant = discriminant.sqrt();
        vec![
            (-b + sqrt_discriminant) / (2.0 * a),
            (-b - sqrt_discriminant) / (2.0 * a),
        ]
    } else if discriminant == 0.0 {
        // One real solution
        vec![
            -b / (2.0 * a)
        ]
    } else {
        // No real solution
        vec![]
    }
}

This function calculates the discriminant (b^2 - 4ac) to determine the nature of the roots, switching between returning two roots in the case of a positive discriminant, one root for zero discriminant, and an empty vector when the discriminant is negative.

Polynomial Evaluations

Beyond quadratic equations, Rust can also handle polynomial evaluations of any degree. Evaluating polynomials is a combination of computational efficiency and accuracy.

A general polynomial can be expressed as:

P(x) = a_n * x^n + a_(n-1) * x^(n-1) + ... + a_1 * x + a_0

Implementing a Polynomial Evaluator in Rust

The Horner’s method is an efficient algorithm to evaluate a polynomial:

fn evaluate_polynomial(coeffs: &[f64], x: f64) -> f64 {
    coeffs.iter().rev().fold(0.0, |acc, &coeff| acc * x + coeff)
}

The evaluate_polynomial function uses Horner's rule to compute polynomial values efficiently by reducing the number of multiplications. This works by restructuring the polynomial expression to minimize complexity, drastically improving performance for large-scale polynomials.