Unfortunately the library fails to evaluate roots of fourth-degree equations. Take this code for example:

use rustnomial::{Polynomial};

fn main() {
    let poly = Polynomial::<f64>::new(vec![1.0, 1.0, 1.0, 1.0, 1.0]);
    let roots = poly.roots();
    match roots {
        rustnomial::Roots::OnlyRealRoots(_) => {
            println!("roots() returned `Only Real Roots`");
        },
        _ => {
            println!("roots() returned some other type.");
        }
    }
}

Running this with rustnomial = "0.2.0" prints:

roots() returned `Only Real Roots`

while in fact x^4 + x^3 + x^2 + x + 1 has no real roots. The vector V in OnlyRealRoots(V) is empty too.

Some other times, the library returns OnlyRealRoots(V) with V containing only real roots, skipping complex ones.

Maybe I'm missing something here, but my understanding was that the library should have returned ManyComplexRoots in these cases.

BTW, thanks for the nice package. I'm using it in an educational project.

It seems unnecessary to me that roots() consumes self. Could we not make roots() accept &self instead of self, since find_roots only requires a reference?

impl Polynomial<f64> {
    pub fn roots(self) -> Roots<f64> {
        find_roots(&self)
    }
}

Hi again

The solution find_roots returns for x^3 + 36 * x^2 + 144 * x + 64 = 0 is wrong. If you run this code on rustnomial 0.3.2 (or older versions):

fn main() {
    let poly = Polynomial::<f64>::new(vec![1.0, 36.0, 144.0, 64.0]);
    let roots = poly.roots();
    match roots {
        rustnomial::Roots::ManyRealRoots(v) => {
            println!("roots() returned `Many Real Roots` with values:");
            for v_ in v {
                println!("{}", v_);
            }
        },
        _ => {
            println!("roots() returned some other type.");
        }
    }
}

it returns:

roots() returned `Many Real Roots` with values:
-31.053752658339498
1.4912025299402378
-6.43744987160074

but in reality the equation has different roots:

-4
-31.492
-0.50807

(See here for exact forms)