Struct symbolic_polynomials::SymPolynomial [−] [src]

pub struct SymPolynomial {
    pub monomials: Vec<SymMonomial>,
    // some fields omitted
}

A symbolic polynomial over the integers.

Fields

monomials: Vec<SymMonomial>

Methods

impl SymPolynomial
[src]

fn is_const(&self) -> bool

Checks if the monomial is a constant

fn new(vars: usize) -> Self

Createse a new symbolic polynomial with the given number of variables

fn get_first_order(var: usize, vars: usize) -> Self

Returns a symolic polynomial representing the var variable in order to the power 1.

fn get_constant(value: i32, vars: usize) -> Self

Returns a symolic polynomial representing the constant value

fn simplify(&mut self)

The method "simplifies" the polynomial to its minimal form. It combines monomials which have the same powers of each symbolic variables and removing any monomials which are equal to 0. Before you perform any methods, such as addition, mutliplication and etc. you should always call simplify.

Examples

// simplify(2x^2y^3 + x^2y^3) = 3x^2y^3
let mut mon1 = SymMonomial::new(2);
mon1.coefficient = 2;
mon1.powers[0] = 2;
mon1.powers[1] = 3;
let mut mon2 = SymMonomial::new(2);
mon2.powers[0] = 2;
mon2.powers[1] = 3;
let mut mon3 = SymMonomial::new(2);
mon3.coefficient = 0;
let mut poly = SymPolynomial::new(2);
poly.monomials.push(mon1);
poly.monomials.push(mon2);
poly.monomials.push(mon3);
poly.simplify();
assert!(poly.monomials.len() == 1);
assert!(poly.monomials[0].coefficient == 3);
assert!(poly.monomials[0].powers.len() == 2);
assert!(poly.monomials[0].powers[0] == 2);
assert!(poly.monomials[0].powers[1] == 3);

Trait Implementations

impl Debug for SymPolynomial
[src]

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Clone for SymPolynomial
[src]

fn clone(&self) -> SymPolynomial

Returns a copy of the value. Read more

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

Performs copy-assignment from source. Read more

impl Default for SymPolynomial
[src]

The default implementation creates a new polynoimal using the default_variables.

fn default() -> Self

Returns the "default value" for a type. Read more

impl PartialEq for SymPolynomial
[src]

Two polynomials are considered equal only if their monomials are equal (including the coefficients). This is a slight disctinction between the monomials equality.

Panics

If the number of symbolic variables in the two polynomials is different

Examples

//-5x^2 == 2x^2 for a monomials, but -5x^2 != 2x^2 for a polynomial
let mut mon1 = SymMonomial::new(2);
mon1.powers[0] = 2;
mon1.coefficient = -5;
let mut mon2 = SymMonomial::new(2);
mon2.powers[0] = 2;
mon2.coefficient = 2;
assert!(mon1 == mon2);
let mut poly1 = SymPolynomial::new(2);
poly1.monomials.push(mon1);
let mut poly2 = SymPolynomial::new(2);
poly2.monomials.push(mon2);
assert!(poly1 != poly2);
//x^2y + 1 != x^2 + 1
let mut mon1 = SymMonomial::new(2);
mon1.powers[0] = 2;
mon1.powers[1] = 1;
let mut mon2 = SymMonomial::new(2);
mon2.powers[0] = 1;
mon2.powers[1] = 2;
// assert!(mon1 + 1 != mon2 + 1);

fn eq(&self, other: &SymPolynomial) -> bool

This method tests for self and other values to be equal, and is used by ==. Read more

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

This method tests for !=.

impl Eq for SymPolynomial
[src]

Directly uses PartialEq

impl Display for SymPolynomial
[src]

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

Formats the value using the given formatter.

impl<'a> Neg for &'a SymPolynomial
[src]

type Output = SymPolynomial

The resulting type after applying the - operator

fn neg(self) -> Self::Output

The method for the unary - operator

impl<'a, 'b> Add<&'b SymMonomial> for &'a SymPolynomial
[src]

Panics

If the number of symbolic variables in the monomial and polynomial are different

Examples

// (x + 1) + x = 2x + 1
let mut mon1 = SymMonomial::new(1);
mon1.powers[0] = 1;
let poly = &mon1 + 1;
let poly2 = &poly + &mon1;
assert!(poly2.monomials.len() == 2);
assert!(poly2.monomials[0].powers[0] == 1);
assert!(poly2.monomials[0].coefficient == 2);
assert!(poly2.monomials[1].is_const());
assert!(poly2.monomials[1].coefficient == 1);

type Output = SymPolynomial

The resulting type after applying the + operator

fn add(self, rhs: &'b SymMonomial) -> Self::Output

The method for the + operator

impl<'a, 'b> Add<&'b SymPolynomial> for &'a SymPolynomial
[src]

Panics

If the number of symbolic variables in the two polynomials are different

Examples

// (x+1) + (y+2) = x + y + 3
let mut mon1 = SymMonomial::new(2);
mon1.powers[0] = 1;
let poly1 = &mon1 + 1;
let mut mon2 = SymMonomial::new(2);
mon2.powers[1] = 1;
let poly2 = &mon2 + 2;
let polySum = &poly1 + &poly2;
assert!(polySum.monomials.len() == 3);
assert!(polySum.monomials[0].powers[0] == 1);
assert!(polySum.monomials[1].is_const());
assert!(polySum.monomials[1].coefficient == 3);
assert!(polySum.monomials[2].powers[1] == 1);

type Output = SymPolynomial

The resulting type after applying the + operator

fn add(self, rhs: &'b SymPolynomial) -> Self::Output

The method for the + operator

impl<'a> Add<i32> for &'a SymPolynomial
[src]

Examples

// (x + 1) + 2 = x + 3
let mut mon1 = SymMonomial::new(2);
mon1.powers[0] = 1;
let poly1 = &mon1 + 1;
let poly_sum = &poly1 + 2;
assert!(poly_sum.monomials.len() == 2);
assert!(poly_sum.monomials[0].powers[0] == 1);
assert!(poly_sum.monomials[1].is_const());
assert!(poly_sum.monomials[1].coefficient == 3);

type Output = SymPolynomial

The resulting type after applying the + operator

fn add(self, rhs: i32) -> Self::Output

The method for the + operator

impl<'a, 'b> Sub<&'b SymMonomial> for &'a SymPolynomial
[src]

Panics

If the number of symbolic variables in the monomial and polynomial are different

type Output = SymPolynomial

The resulting type after applying the - operator

fn sub(self, rhs: &'b SymMonomial) -> Self::Output

The method for the - operator

impl<'a, 'b> Sub<&'b SymPolynomial> for &'a SymPolynomial
[src]

Panics

If the number of symbolic variables in the two polynomials are different

type Output = SymPolynomial

The resulting type after applying the - operator

fn sub(self, rhs: &'b SymPolynomial) -> Self::Output

The method for the - operator

impl<'a> Sub<i32> for &'a SymPolynomial
[src]

type Output = SymPolynomial

The resulting type after applying the - operator

fn sub(self, rhs: i32) -> Self::Output

The method for the - operator

impl<'a, 'b> Mul<&'b SymMonomial> for &'a SymPolynomial
[src]

Panics

If the number of symbolic variables in the monomial and polynomial are different

Examples

// (2xy+1) * 3y^2 = 6xy^3 + 3y^2
let mut mon1 = SymMonomial::new(2);
mon1.powers[0] = 1;
mon1.powers[1] = 1;
mon1.coefficient = 2;
let mut mon2 = SymMonomial::new(2);
mon2.powers[1] = 2;
mon2.coefficient = 3;
let poly = &mon1 + 1;
let poly_prod = &poly * &mon2;
assert!(poly_prod.monomials.len() == 2);
assert!(poly_prod.monomials[0].coefficient == 6);
assert!(poly_prod.monomials[0].powers[0] == 1);
assert!(poly_prod.monomials[0].powers[1] == 3);
assert!(poly_prod.monomials[1].coefficient == 3);
assert!(poly_prod.monomials[1].powers[0] == 0);
assert!(poly_prod.monomials[1].powers[1] == 2);

type Output = SymPolynomial

The resulting type after applying the * operator

fn mul(self, rhs: &'b SymMonomial) -> Self::Output

The method for the * operator

impl<'a, 'b> Mul<&'b SymPolynomial> for &'a SymPolynomial
[src]

Panics

If the number of symbolic variables in the two polynomials are different

Examples

// (2xy+1) * (3y^2 + 2) = 6xy^3 + 4xy + 3y^2 + 2
let mut mon1 = SymMonomial::new(2);
mon1.powers[0] = 1;
mon1.powers[1] = 1;
mon1.coefficient = 2;
let mut mon2 = SymMonomial::new(2);
mon2.powers[1] = 2;
mon2.coefficient = 3;
let poly1 = &mon1 + 1;
let poly2 = &mon2 + 2;
let poly_prod = &poly1 * &poly2;
assert!(poly_prod.monomials.len() == 4);
assert!(poly_prod.monomials[0].coefficient == 6);
assert!(poly_prod.monomials[0].powers[0] == 1);
assert!(poly_prod.monomials[0].powers[1] == 3);
assert!(poly_prod.monomials[1].coefficient == 4);
assert!(poly_prod.monomials[1].powers[0] == 1);
assert!(poly_prod.monomials[1].powers[1] == 1);
assert!(poly_prod.monomials[2].coefficient == 3);
assert!(poly_prod.monomials[2].powers[0] == 0);
assert!(poly_prod.monomials[2].powers[1] == 2);
assert!(poly_prod.monomials[3].coefficient == 2);
assert!(poly_prod.monomials[3].is_const());

type Output = SymPolynomial

The resulting type after applying the * operator

fn mul(self, rhs: &'b SymPolynomial) -> Self::Output

The method for the * operator

impl<'a> Mul<i32> for &'a SymPolynomial
[src]

type Output = SymPolynomial

The resulting type after applying the * operator

fn mul(self, rhs: i32) -> Self::Output

The method for the * operator

impl<'a, 'b> Div<&'b SymMonomial> for &'a SymPolynomial
[src]

Returns None if the polynomial is not divisible by the monomial

Panics

If the number of symbolic variables in the monomial and polynomial are different

Examples

// (2x^2y + x^3y + xy) / xy = 2x + x^2 + 1
let mut mon1 = SymMonomial::new(2);
mon1.powers[0] = 1;
mon1.powers[1] = 1;
let mut mon2 = SymMonomial::new(2);
mon2.powers[0] = 1;
mon2.coefficient = 2;
let mut mon3 = SymMonomial::new(2);
mon3.powers[0] = 2;
let poly1 = &(&mon2 + &mon3) + 1;
let poly_prod = &poly1 * &mon1;
let option = &poly_prod / &mon1;
assert!(option.is_some());
assert!(option.unwrap()== poly1);
// (2x^2y + x^3y + xy + 1) / xy = None
let mut mon1 = SymMonomial::new(2);
mon1.powers[0] = 1;
mon1.powers[1] = 1;
let mut mon2 = SymMonomial::new(2);
mon2.powers[0] = 1;
mon2.coefficient = 2;
let mut mon3 = SymMonomial::new(2);
mon3.powers[0] = 2;
let poly1 = &(&mon2 + &mon3) + 1;
let poly_prod = &(&poly1 * &mon1) + 1;
let option = &poly_prod / &mon1;
assert!(option.is_none());

type Output = Option<SymPolynomial>

The resulting type after applying the / operator

fn div(self, rhs: &'b SymMonomial) -> Self::Output

The method for the / operator

impl<'a, 'b> Div<&'b SymPolynomial> for &'a SymPolynomial
[src]

Returns None if the polynomial is not divisible by the other polynomial

Panics

If the number of symbolic variables in the two polynomials are different

Examples

// (2x^4 + x^3y + 3x^2y + 2x^2 + xy^2 + xy + y^2 + y) / (x^2 + y + 1) = 2x^2 + y + xy
let mut mon1 = SymMonomial::new(2);
mon1.powers[0] = 2;
let mut mon2 = SymMonomial::new(2);
mon2.powers[1] = 1;
let mut mon3 = SymMonomial::new(2);
mon3.powers[0] = 1;
mon3.powers[1] = 1;
let poly_divisor = &mon1 + &(&mon2 +1);
let poly_result = &(2 * &mon1) + &(&mon2 + &mon3);
let poly_prod = &poly_divisor * &poly_result;
let option = &poly_prod / &poly_divisor;
assert!(option.is_some());
assert!(option.unwrap()== poly_result);
// (2x^4 + x^3y + 3x^2y + 2x^2 + xy^2 + xy + y^2 + y) / (x^2 + y + 2) = None
let mut mon1 = SymMonomial::new(2);
mon1.powers[0] = 2;
let mut mon2 = SymMonomial::new(2);
mon2.powers[1] = 1;
let mut mon3 = SymMonomial::new(2);
mon3.powers[0] = 1;
mon3.powers[1] = 1;
let poly_divisor = &mon1 + &(&mon2 +1);
let poly_result = &(2 * &mon1) + &(&mon2 + &mon3);
let poly_prod = &poly_divisor * &poly_result;
let poly_newdivisor = &poly_divisor + 1;
let option = &poly_prod / &poly_newdivisor;
assert!(option.is_none());

type Output = Option<SymPolynomial>

The resulting type after applying the / operator

fn div(self, rhs: &'b SymPolynomial) -> Self::Output

The method for the / operator

impl<'a> Div<i32> for &'a SymPolynomial
[src]

Returns None if the polynomial is not divisible by the other polynomial

Examples

// (2x^2 + 2xy) / 2 = x^2 + xy
let mut mon1 = SymMonomial::new(2);
mon1.powers[0] = 2;
let mut mon2 = SymMonomial::new(2);
mon2.powers[1] = 1;
mon2.powers[1] = 1;
let poly_result = &mon1 + &mon2;
let poly_prod = 2 * &poly_result;
let option = &poly_prod / 2;
assert!(option.is_some());
assert!(option.unwrap()== poly_result);
// (2x^2 + 2xy + 1) / 2 = None
let mut mon1 = SymMonomial::new(2);
mon1.powers[0] = 2;
let mut mon2 = SymMonomial::new(2);
mon2.powers[1] = 1;
mon2.powers[1] = 1;
let poly_result = &mon1 + &mon2;
let poly_prod = &(2 * &poly_result) + 1;
let option = &poly_prod / 2;
assert!(option.is_none());

type Output = Option<SymPolynomial>

The resulting type after applying the / operator

fn div(self, rhs: i32) -> Self::Output

The method for the / operator