Struct Roots 

pub struct Roots<const N: usize> { /* private fields */ }

Tagged root container for N roots. Types are packed 3 bits per root into a u64, identical to C++ Roots<N>. For complex conjugate pairs, slot i holds the real part and slot i+1 holds the imaginary part; both slots are tagged Complex.

Implementations

impl<const N: usize> Roots<N>

pub fn get(&self, i: usize) -> f64

Value stored at slot i.

Out of range reads NaN, and never panics

i >= N is a caller bug either way. Returning NaN rather than panicking is what lets this type be lifted verbatim into petir, which targets bare metal – there a panic is not a stack trace and a non-zero exit, it is the end of the program. NaN still surfaces the bug, just downstream of the read.

pub fn root_type(&self, i: usize) -> RootType

Root type at slot i.

pub fn set_type(&mut self, i: usize, t: RootType)

Overwrite the type at slot i.

impl Roots<1>

pub fn new(t: RootType, x: f64) -> Self

Single root with the given type and value.

impl Roots<2>

pub fn from_pair(a: Roots<1>, b: Roots<1>) -> Self

Concatenate two single roots. C++ Roots<2>(Roots<1>, Roots<1>).

pub fn with_tail(head: Roots<1>, t: RootType, x: f64) -> Self

Roots<1> followed by one additional root. C++ Roots<2>(Roots<1>, type, x).

pub fn both(r: Roots<1>) -> Self

Duplicate a single root into both slots. C++ Roots<2>(r, r).

impl Roots<3>

pub fn uniform(t: RootType, x: f64) -> Self

All three slots get the same type and value. C++ Roots<3>(type, x).

pub fn concat_1_2(a: Roots<1>, b: Roots<2>) -> Self

Concatenate Roots<1> then Roots<2>. C++ Roots<3>(Roots<1>, Roots<2>).

pub fn concat_2_1(a: Roots<2>, b: Roots<1>) -> Self

Concatenate Roots<2> then Roots<1>. C++ Roots<3>(Roots<2>, Roots<1>).

pub fn with_tail(head: Roots<2>, t: RootType, x: f64) -> Self

Roots<2> followed by one additional root. C++ Roots<3>(Roots<2>, type, x).

Trait Implementations

impl<const N: usize> Clone for Roots<N>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Copy for Roots<N>

impl<const N: usize> Debug for Roots<N>

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

Formats the value using the given formatter.

impl<const N: usize> Index<usize> for Roots<N>

type Output = f64

The returned type after indexing.

fn index(&self, i: usize) -> &f64

Performs the indexing (container[index]) operation.