Struct Polynomial 

pub struct Polynomial<F> {
    pub terms: Vec<Term<F>>,
    pub nvars: usize,
    pub order: MonomialOrder,
}

Fields

terms: Vec<Term<F>>

nvars: usize

order: MonomialOrder

Implementations

impl<F: Field> Polynomial<F>

pub fn new(terms: Vec<Term<F>>, nvars: usize, order: MonomialOrder) -> Self

Examples found in repository

examples/basic.rs (lines 12-29)

fn main() {
    // Example: Compute a Groebner basis for the ideal (x^2 + y^2 - 1, x - y)
    // Variables: x = 0, y = 1
    let nvars = 2;
    let order = MonomialOrder::Lex;

    // x^2 + y^2 - 1
    let f = Polynomial::new(
        vec![
            Term::new(
                BigRational::new(1.into(), 1.into()),
                Monomial::new(vec![2, 0]),
            ), // x^2
            Term::new(
                BigRational::new(1.into(), 1.into()),
                Monomial::new(vec![0, 2]),
            ), // y^2
            Term::new(
                BigRational::new((-1).into(), 1.into()),
                Monomial::new(vec![0, 0]),
            ), // -1
        ],
        nvars,
        order,
    );

    // x - y
    let g = Polynomial::new(
        vec![
            Term::new(
                BigRational::new(1.into(), 1.into()),
                Monomial::new(vec![1, 0]),
            ), // x
            Term::new(
                BigRational::new((-1).into(), 1.into()),
                Monomial::new(vec![0, 1]),
            ), // -y
        ],
        nvars,
        order,
    );

    // Compute the Groebner basis
    match groebner_basis(vec![f, g], order, true) {
        Ok(basis) => {
            println!("Groebner basis:");
            for (i, poly) in basis.iter().enumerate() {
                println!("g{}: {}", i + 1, poly);
            }
        }
        Err(e) => {
            println!("Error computing Groebner basis: {e}");
        }
    }
}

pub fn zero(nvars: usize, order: MonomialOrder) -> Self

pub fn constant(coeff: F, nvars: usize, order: MonomialOrder) -> Self

pub fn is_zero(&self) -> bool

pub fn leading_term(&self) -> Option<&Term<F>>

pub fn leading_monomial(&self) -> Option<&Monomial>

pub fn leading_coefficient(&self) -> Option<&F>

pub fn make_monic(&self) -> Self

pub fn add(&self, other: &Self) -> Self

pub fn subtract(&self, other: &Self) -> Self

pub fn multiply_scalar(&self, scalar: &F) -> Self

pub fn multiply_monomial(&self, monomial: &Monomial) -> Self

pub fn multiply(&self, other: &Self) -> Self

pub fn s_polynomial(&self, other: &Self) -> Result<Self, PolynomialError>

pub fn reduce(&self, basis: &[Self]) -> Result<Self, PolynomialError>

Trait Implementations

impl<F: Clone> Clone for Polynomial<F>

fn clone(&self) -> Polynomial<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug> Debug for Polynomial<F>

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

Formats the value using the given formatter.

impl<F: Field> Display for Polynomial<F>

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

Formats the value using the given formatter.

impl<F: PartialEq> PartialEq for Polynomial<F>

fn eq(&self, other: &Polynomial<F>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F> StructuralPartialEq for Polynomial<F>