Macro rust_poly::poly

macro_rules! poly {
    () => { ... };
    (($re:expr, $im:expr); $n:expr) => { ... };
    ($elem:expr; $n:expr) => { ... };
    ($(($re:expr, $im:expr)),+ $(,)?) => { ... };
    ($($elems:expr),+ $(,)?) => { ... };
}

A more convenient way of writing Poly::new(&[Complex::new(...)...])

It takes ownership of its arguments.

It can take a list of Scalar or Complex<Scalar>. If left empty, it is equivalent to Poly::zero().

Examples

Basic syntax

use rust_poly::{poly, Poly};
use num_traits::Zero;
use num_complex::Complex;

let p1: Poly<f32> = poly![];
let p2 = poly![1.0f32, 2.0, 3.0];
let p3 = poly![Complex::from(1.0), Complex::from(2.0), Complex::from(3.0)];

assert_eq!(p1, Poly::zero());
assert_eq!(p2, p3);

Similarly to vec!, you can initialize a large polynomial where all coefficients are equal like so:

use num_complex::Complex;

let p1 = poly![2.0; 16];
let p2 = poly![Complex::from(2.0); 16];

assert_eq!(p1, p2);

You can also express complex numbers as a tuple of two scalars, mixing and matching this syntax with the other syntax rules:

use rust_poly::{poly, Poly};
use num_complex::Complex;

let p1 = poly![(1.0, 2.0), (1.0, 2.0)];
let p2 = poly![(1.0, 2.0); 2];
let p3 = poly![Complex::new(1.0, 2.0); 2];
let p4 = poly![Complex::new(1.0, 2.0), Complex::new(1.0, 2.0)];

assert_eq!(p1, p2);
assert_eq!(p1, p3);
assert_eq!(p1, p4);