Struct PolyOverZ 

pub struct PolyOverZ { /* private fields */ }

PolyOverZ is a type of polynomial with arbitrarily many coefficients of type Z.

Examples

use qfall_math::integer::{PolyOverZ, Z};
use qfall_math::traits::*;
use std::str::FromStr;

// instantiations
let poly_1 = PolyOverZ::from_str("4  0 1 2 3").unwrap();
let poly_2 = PolyOverZ::default();

// arithmetic operations
let _ = &poly_1 + &poly_2;
let _ = &poly_1 * &poly_2;

// evaluate function
let value = Z::from(3);
let res: Z = poly_1.evaluate(&value);

// comparison
assert_ne!(poly_1, poly_2);

Implementations

impl PolyOverZ

pub fn dot_product(&self, other: &Self) -> Result<Z, MathError>

Returns the dot product of two polynomials of type PolyOverZ. The dot product for polynomials is obtained by treating the coefficients of the polynomials as vectors and then applying the standard dot product operation.

Parameters:

• other: specifies the other polynomial the dot product is calculated over

Returns the resulting dot_product as a PolyOverZ.

Examples

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let poly_1 = PolyOverZ::from_str("4  -1 0 1 1").unwrap();
let poly_2 = PolyOverZ::from(42);

let dot_prod = poly_1.dot_product(&poly_2).unwrap();

impl PolyOverZ

pub fn get_degree(&self) -> i64

Returns the degree of a polynomial PolyOverZ as a i64. The zero polynomial has degree -1.

Examples

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let poly = PolyOverZ::from_str("4  0 1 2 3").unwrap();

let degree = poly.get_degree();

assert_eq!(3, degree);

impl PolyOverZ

pub fn norm_eucl_sqrd(&self) -> Z

Returns the squared Euclidean norm or squared 2-norm of the given polynomial. The squared Euclidean norm for a polynomial is obtained by treating the coefficients of the polynomial as a vector and then applying the standard squared Euclidean norm.

Examples

use qfall_math::integer::{PolyOverZ, Z};
use std::str::FromStr;

let poly = PolyOverZ::from_str("3  1 2 3").unwrap();

let sqrd_2_norm = poly.norm_eucl_sqrd();

// 1*1 + 2*2 + 3*3 = 14
assert_eq!(Z::from(14), sqrd_2_norm);

pub fn norm_infty(&self) -> Z

Returns the infinity norm or the maximal absolute value of a coefficient of the given polynomial. The infinity norm for a polynomial is obtained by treating the coefficients of the polynomial as a vector and then applying the standard infinity norm.

Examples

use qfall_math::integer::{PolyOverZ, Z};
use std::str::FromStr;

let poly = PolyOverZ::from_str("3  1 2 3").unwrap();

let infty_norm = poly.norm_infty();

// max coefficient is 3
assert_eq!(Z::from(3), infty_norm);

impl PolyOverZ

pub fn is_one(&self) -> bool

Checks if a PolyOverZ is the constant polynomial with coefficient 1.

Returns true if there is only one coefficient, which is 1.

Examples

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let value = PolyOverZ::from(1);
assert!(value.is_one());

pub fn is_zero(&self) -> bool

Checks if every entry of a PolyOverZ is 0.

Returns true if PolyOverZ has no coefficients.

Examples

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let value = PolyOverZ::from(0);
assert!(value.is_zero());

impl PolyOverZ

pub fn reduce_by_poly(&mut self, modulus: &PolyOverZ)

Reduces a polynomial by a polynomial modulus. The modulus must have a leading coefficient of 1, else the function will panic.

Parameters:

• modulus: Specifies the polynomial by which self is reduced

Examples

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let mut a = PolyOverZ::from_str("4  0 0 2 3").unwrap();
let modulus = PolyOverZ::from_str("3  0 1 1").unwrap();

a.reduce_by_poly(&modulus);

assert_eq!(PolyOverZ::from_str("2  0 1").unwrap(), a);

Panics …

• if the modulus does not have a leading coefficient of 1.

impl PolyOverZ

pub fn sample_binomial( max_degree: impl TryInto<i64> + Display, n: impl Into<Z>, p: impl Into<Q>, ) -> Result<Self, MathError>

Generates a PolyOverZ instance of maximum degree max_degree and coefficients chosen according to the binomial distribution parameterized by n and p.

Parameters:

• max_degree: specifies the length of the polynomial, i.e. the number of coefficients
• n: specifies the number of trials
• p: specifies the probability of success

Returns a fresh PolyOverZ instance with each value sampled according to the binomial distribution or a MathError if n < 0, p ∉ (0,1), n does not fit into an i64, or max_degree is negative or does not into an i64.

Examples

use qfall_math::integer::PolyOverZ;

let sample = PolyOverZ::sample_binomial(2, 2, 0.5).unwrap();

Errors and Failures

• Returns a MathError of type InvalidIntegerInput if n < 0.
• Returns a MathError of type InvalidInterval if p ∉ (0,1).
• Returns a MathError of type ConversionError if n does not fit into an i64.
• Returns a MathError of type OutOfBounds if the max_degree is negative or it does not fit into an i64.

pub fn sample_binomial_with_offset( max_degree: impl TryInto<i64> + Display, offset: impl Into<Z>, n: impl Into<Z>, p: impl Into<Q>, ) -> Result<Self, MathError>

Generates a PolyOverZ instance of maximum degree max_degree and coefficients chosen according to the binomial distribution parameterized by n and p with given offset.

Parameters:

• max_degree: specifies the length of the polynomial, i.e. the number of coefficients
• offset: specifies an offset applied to each sample collected from the binomial distribution
• n: specifies the number of trials
• p: specifies the probability of success

Returns a fresh PolyOverZ instance with each value sampled according to the binomial distribution or a MathError if n < 0, p ∉ (0,1), n does not fit into an i64, or max_degree is negative or does not into an i64.

Examples

use qfall_math::integer::PolyOverZ;

let sample = PolyOverZ::sample_binomial_with_offset(2, -1, 2, 0.5).unwrap();

Errors and Failures

• Returns a MathError of type InvalidIntegerInput if n < 0.
• Returns a MathError of type InvalidInterval if p ∉ (0,1).
• Returns a MathError of type ConversionError if n does not fit into an i64.
• Returns a MathError of type OutOfBounds if the max_degree is negative or it does not fit into an i64.

impl PolyOverZ

pub fn sample_discrete_gauss( max_degree: impl TryInto<i64> + Display, center: impl Into<Q>, s: impl Into<Q>, ) -> Result<Self, MathError>

Initializes a new PolyOverZ with maximum degree max_degree and with each entry sampled independently according to the discrete Gaussian distribution, using Z::sample_discrete_gauss.

Parameters:

• max_degree: specifies the included maximal degree the created PolyOverZ should have
• center: specifies the positions of the center with peak probability
• s: specifies the Gaussian parameter, which is proportional to the standard deviation sigma * sqrt(2 * pi) = s

Returns a fresh PolyOverZ instance of maximum degree max_degree with coefficients chosen independently according the discrete Gaussian distribution or a MathError if s < 0.

Examples

use qfall_math::integer::PolyOverZ;

let sample = PolyOverZ::sample_discrete_gauss(2, 0, 1).unwrap();

Errors and Failures

• Returns a MathError of type InvalidIntegerInput if s < 0.

Panics …

• if max_degree is negative, or does not fit into an i64.

impl PolyOverZ

pub fn sample_uniform( max_degree: impl TryInto<i64> + Display, lower_bound: impl Into<Z>, upper_bound: impl Into<Z>, ) -> Result<Self, MathError>

Generates a PolyOverZ instance of maximum degree max_degree and coefficients chosen uniform at random in [lower_bound, upper_bound).

The internally used uniform at random chosen bytes are generated by ThreadRng, which uses ChaCha12 and is considered cryptographically secure.

Parameters:

• max_degree: specifies the length of the polynomial, i.e. the number of coefficients
• lower_bound: specifies the included lower bound of the interval over which is sampled
• upper_bound: specifies the excluded upper bound of the interval over which is sampled

Returns a fresh PolyOverZ instance of length max_degree with coefficients chosen uniform at random in [lower_bound, upper_bound) or a MathError if the max_degree was smaller than 0 or the provided interval was chosen too small.

Examples

use qfall_math::integer::{PolyOverZ, Z};

let sample = PolyOverZ::sample_uniform(3, 17, 26).unwrap();

Errors and Failures

• Returns a MathError of type InvalidInterval if the given upper_bound isn’t at least larger than lower_bound.
• Returns a MathError of type OutOfBounds if the max_degree is negative or it does not fit into an i64.

impl PolyOverZ

pub unsafe fn get_fmpz_poly_struct(&mut self) -> &mut fmpz_poly_struct

Returns a mutable reference to the field poly of type fmpz_poly_struct.

WARNING: The returned struct is part of flint_sys. Any changes to this object are unsafe and may introduce memory leaks.

This function is a passthrough to enable users of this library to use flint_sys and with that FLINT functions that might not be covered in our library yet. If this is the case, please consider contributing to this open-source project by opening a Pull Request at qfall_math to provide this feature in the future.

Safety

Any flint_sys struct and function is part of a FFI to the C-library FLINT. As FLINT is a C-library, it does not provide all memory safety features that Rust and our Wrapper provide. Thus, using functions of flint_sys can introduce memory leaks.

impl PolyOverZ

pub unsafe fn set_fmpz_poly_struct(&mut self, flint_struct: fmpz_poly_struct)

Sets the field poly of type fmpz_poly_struct to flint_struct.

Parameters:

• flint_struct: value to set the attribute to

This function is a passthrough to enable users of this library to use flint_sys and with that FLINT functions that might not be covered in our library yet. If this is the case, please consider contributing to this open-source project by opening a Pull Request at qfall_math to provide this feature in the future.

Safety

Ensure that the old struct does not share any memory with any other structs that might be used in the future. The memory of the old struct is freed using this function.

Any flint_sys struct and function is part of a FFI to the C-library FLINT. As FLINT is a C-library, it does not provide all memory safety features that Rust and our Wrapper provide. Thus, using functions of flint_sys can introduce memory leaks.

Trait Implementations

impl Add<&PolyOverZ> for &PolyOverQ

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

Implements the Add trait for PolyOverQ and PolyOverZ. Add is implemented for any combination of owned and borrowed values.

Parameters:

• other: specifies the polynomial to add to self

Returns the addition of both polynomials as a PolyOverQ.

Examples

use qfall_math::rational::PolyOverQ;
use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let a = PolyOverQ::from_str("4  1/2 0 3/7 1").unwrap();
let b = PolyOverZ::from_str("4  2 0 3 1").unwrap();

let c: PolyOverQ = &a + &b;

type Output = PolyOverQ

The resulting type after applying the + operator.

impl Add<&PolyOverZ> for &PolyOverZq

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

Implements the Add trait for PolyOverZq and PolyOverZ. Add is implemented for any combination of owned and borrowed values.

Parameters:

• other: specifies the polynomial to add to self

Returns the addition of both polynomials as a PolyOverZq.

Examples

use qfall_math::integer_mod_q::PolyOverZq;
use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let a = PolyOverZq::from_str("4  -1 0 1 1 mod 17").unwrap();
let b = PolyOverZ::from_str("4  2 0 3 1").unwrap();

let c: PolyOverZq = &a + &b;

type Output = PolyOverZq

The resulting type after applying the + operator.

impl Add<&PolyOverZ> for &PolynomialRingZq

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

Implements the Add trait for PolynomialRingZq and PolyOverZ. Add is implemented for any combination of owned and borrowed values.

Parameters:

• other: specifies the polynomial to add to self

Returns the addition of both polynomials as a PolynomialRingZq.

Examples

use qfall_math::integer_mod_q::PolynomialRingZq;
use qfall_math::integer_mod_q::ModulusPolynomialRingZq;
use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let modulus = ModulusPolynomialRingZq::from_str("4  1 0 0 1 mod 17").unwrap();
let poly = PolyOverZ::from_str("4  -1 0 1 1").unwrap();
let a = PolynomialRingZq::from((&poly, &modulus));
let b = PolyOverZ::from_str("4  2 0 3 1").unwrap();

let c: PolynomialRingZq = &a + &b;

type Output = PolynomialRingZq

The resulting type after applying the + operator.

impl Add<&PolyOverZ> for &Z

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

Implements the Add trait for Z and PolyOverZ values. Add is implemented for any combination of owned and borrowed values.

Parameters:

• other: specifies the polynomial to add to self

Returns the sum of both as a PolyOverZ.

Examples

use qfall_math::integer::PolyOverZ;
use qfall_math::integer::Z;
use std::str::FromStr;

let a: Z = Z::from(42);
let b: PolyOverZ = PolyOverZ::from_str("4  5 1 2 3").unwrap();

let c: PolyOverZ = &a + &b;
let d: PolyOverZ = a + b;
let e: PolyOverZ = &Z::from(42) + d;
let f: PolyOverZ = Z::from(42) + &e;

type Output = PolyOverZ

The resulting type after applying the + operator.

impl Add<&Z> for &PolyOverZ

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

Implements the Add trait for PolyOverZ and Z values. Add is implemented for any combination of owned and borrowed values.

Parameters:

• other: specifies the Z to add to self

Returns the sum of both as a PolyOverZ.

Examples

use qfall_math::integer::PolyOverZ;
use qfall_math::integer::Z;
use std::str::FromStr;

let b: PolyOverZ = PolyOverZ::from_str("4  5 1 2 3").unwrap();
let a: Z = Z::from(42);

let c: PolyOverZ = &a + &b;
let d: PolyOverZ = a + b;
let e: PolyOverZ = d + &Z::from(42);
let f: PolyOverZ = &e + Z::from(42);

type Output = PolyOverZ

The resulting type after applying the + operator.

impl Add for &PolyOverZ

fn add(self, other: Self) -> Self::Output

Implements the Add trait for two PolyOverZ values. Add is implemented for any combination of PolyOverZ and borrowed PolyOverZ.

Parameters:

• other: specifies the value to add to self

Returns the sum of both polynomials as a PolyOverZ.

Examples

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let a: PolyOverZ = PolyOverZ::from_str("3  1 2 -3").unwrap();
let b: PolyOverZ = PolyOverZ::from_str("5  1 2 -3 0 8").unwrap();

let c: PolyOverZ = &a + &b;
let d: PolyOverZ = a + b;
let e: PolyOverZ = &c + d;
let f: PolyOverZ = c + &e;

type Output = PolyOverZ

The resulting type after applying the + operator.

impl AddAssign<&PolyOverZ> for PolyOverQ

fn add_assign(&mut self, other: &PolyOverZ)

Documentation at PolyOverQ::add_assign.

impl AddAssign<&PolyOverZ> for PolyOverZ

fn add_assign(&mut self, other: &Self)

Computes the addition of self and other reusing the memory of self.

Parameters:

• other: specifies the polynomial to add to self

Returns the sum of both polynomials as a PolyOverZ.

Examples

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let mut a = PolyOverZ::from_str("3  1 2 -3").unwrap();
let b = PolyOverZ::from_str("5  1 2 -3 0 8").unwrap();

a += &b;
a += b;

impl AddAssign<&PolyOverZ> for PolyOverZq

fn add_assign(&mut self, other: &PolyOverZ)

Documentation at PolyOverZq::add_assign.

impl AddAssign<&PolyOverZ> for PolynomialRingZq

fn add_assign(&mut self, other: &PolyOverZ)

Documentation at PolynomialRingZq::add_assign.

impl AddAssign<PolyOverZ> for PolyOverQ

fn add_assign(&mut self, other: PolyOverZ)

Documentation at PolyOverQ::add_assign.

impl AddAssign<PolyOverZ> for PolyOverZq

fn add_assign(&mut self, other: PolyOverZ)

Documentation at PolyOverZq::add_assign.

impl AddAssign<PolyOverZ> for PolynomialRingZq

fn add_assign(&mut self, other: PolyOverZ)

Documentation at PolynomialRingZq::add_assign.

impl AddAssign for PolyOverZ

fn add_assign(&mut self, other: PolyOverZ)

Documentation at PolyOverZ::add_assign.

impl Clone for PolyOverZ

fn clone(&self) -> Self

Clones the given element and returns a deep clone of the PolyOverZ element.

Examples

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let a = PolyOverZ::from_str("3  0 1 2").unwrap();
let b = a.clone();

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

Performs copy-assignment from source.

impl CompareBase<&PolyOverZ> for MatNTTPolynomialRingZq

fn compare_base(&self, other: &T) -> bool

Compares the base elements of the objects and returns true if they match and an operation between the two provided types is possible.

fn call_compare_base_error(&self, other: &T) -> Option<MathError>

Calls an error that gives small explanation how the base elements differ. This function only calls the error and does not check if the two actually differ.

impl CompareBase<&PolyOverZ> for MatPolyOverZ

fn compare_base(&self, other: &T) -> bool

Compares the base elements of the objects and returns true if they match and an operation between the two provided types is possible.

fn call_compare_base_error(&self, other: &T) -> Option<MathError>

Calls an error that gives small explanation how the base elements differ. This function only calls the error and does not check if the two actually differ.

impl CompareBase<&PolyOverZ> for MatPolynomialRingZq

fn compare_base(&self, other: &T) -> bool

Compares the base elements of the objects and returns true if they match and an operation between the two provided types is possible.

fn call_compare_base_error(&self, other: &T) -> Option<MathError>

Calls an error that gives small explanation how the base elements differ. This function only calls the error and does not check if the two actually differ.

impl CompareBase<&PolyOverZ> for NTTPolynomialRingZq

fn compare_base(&self, other: &T) -> bool

Compares the base elements of the objects and returns true if they match and an operation between the two provided types is possible.

fn call_compare_base_error(&self, other: &T) -> Option<MathError>

Calls an error that gives small explanation how the base elements differ. This function only calls the error and does not check if the two actually differ.

impl CompareBase<&PolyOverZ> for PolyOverZq

fn compare_base(&self, other: &T) -> bool

Compares the base elements of the objects and returns true if they match and an operation between the two provided types is possible.

fn call_compare_base_error(&self, other: &T) -> Option<MathError>

Calls an error that gives small explanation how the base elements differ. This function only calls the error and does not check if the two actually differ.

impl CompareBase<&PolyOverZ> for PolynomialRingZq

fn compare_base(&self, other: &T) -> bool

Compares the base elements of the objects and returns true if they match and an operation between the two provided types is possible.

fn call_compare_base_error(&self, other: &T) -> Option<MathError>

Calls an error that gives small explanation how the base elements differ. This function only calls the error and does not check if the two actually differ.

impl<Integer: Into<Z>> CompareBase<Integer> for PolyOverZ

fn compare_base(&self, other: &T) -> bool

Compares the base elements of the objects and returns true if they match and an operation between the two provided types is possible.

fn call_compare_base_error(&self, other: &T) -> Option<MathError>

Calls an error that gives small explanation how the base elements differ. This function only calls the error and does not check if the two actually differ.

impl CompareBase<PolyOverZ> for MatNTTPolynomialRingZq

fn compare_base(&self, other: &T) -> bool

Compares the base elements of the objects and returns true if they match and an operation between the two provided types is possible.

fn call_compare_base_error(&self, other: &T) -> Option<MathError>

Calls an error that gives small explanation how the base elements differ. This function only calls the error and does not check if the two actually differ.

impl CompareBase<PolyOverZ> for MatPolyOverZ

fn compare_base(&self, other: &T) -> bool

Compares the base elements of the objects and returns true if they match and an operation between the two provided types is possible.

fn call_compare_base_error(&self, other: &T) -> Option<MathError>

Calls an error that gives small explanation how the base elements differ. This function only calls the error and does not check if the two actually differ.

impl CompareBase<PolyOverZ> for MatPolynomialRingZq

fn compare_base(&self, other: &T) -> bool

Compares the base elements of the objects and returns true if they match and an operation between the two provided types is possible.

fn call_compare_base_error(&self, other: &T) -> Option<MathError>

Calls an error that gives small explanation how the base elements differ. This function only calls the error and does not check if the two actually differ.

impl CompareBase<PolyOverZ> for NTTPolynomialRingZq

fn compare_base(&self, other: &T) -> bool

Compares the base elements of the objects and returns true if they match and an operation between the two provided types is possible.

fn call_compare_base_error(&self, other: &T) -> Option<MathError>

Calls an error that gives small explanation how the base elements differ. This function only calls the error and does not check if the two actually differ.

impl CompareBase<PolyOverZ> for PolyOverQ

fn compare_base(&self, other: &T) -> bool

Compares the base elements of the objects and returns true if they match and an operation between the two provided types is possible.

fn call_compare_base_error(&self, other: &T) -> Option<MathError>

Calls an error that gives small explanation how the base elements differ. This function only calls the error and does not check if the two actually differ.

impl CompareBase<PolyOverZ> for PolyOverZq

fn compare_base(&self, other: &T) -> bool

Compares the base elements of the objects and returns true if they match and an operation between the two provided types is possible.

fn call_compare_base_error(&self, other: &T) -> Option<MathError>

Calls an error that gives small explanation how the base elements differ. This function only calls the error and does not check if the two actually differ.

impl CompareBase<PolyOverZ> for PolynomialRingZq

fn compare_base(&self, other: &T) -> bool

Compares the base elements of the objects and returns true if they match and an operation between the two provided types is possible.

fn call_compare_base_error(&self, other: &T) -> Option<MathError>

Calls an error that gives small explanation how the base elements differ. This function only calls the error and does not check if the two actually differ.

impl CompareBase for PolyOverZ

fn compare_base(&self, other: &T) -> bool

Compares the base elements of the objects and returns true if they match and an operation between the two provided types is possible.

fn call_compare_base_error(&self, other: &T) -> Option<MathError>

Calls an error that gives small explanation how the base elements differ. This function only calls the error and does not check if the two actually differ.

impl Debug for PolyOverZ

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

Formats the value using the given formatter.

impl Default for PolyOverZ

fn default() -> Self

Initializes a PolyOverZ with the zero polynomial.

Examples

use qfall_math::integer::PolyOverZ;

let zero = PolyOverZ::default();

impl<'de> Deserialize<'de> for PolyOverZ

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Implements the deserialize option. This allows to create a PolyOverZ from a given Json-object.

impl Display for PolyOverZ

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

Allows to convert a polynomial of type PolyOverZ into a String.

Examples

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;
use core::fmt;

let poly = PolyOverZ::from_str("4  0 1 2 3").unwrap();
println!("{poly}");

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let poly = PolyOverZ::from_str("4  0 1 2 3").unwrap();
let poly_string = poly.to_string();

impl Drop for PolyOverZ

fn drop(&mut self)

Drops the given PolyOverZ value and frees the allocated memory.

Examples

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;
{
    let a = PolyOverZ::from_str("3  0 1 2").unwrap();
} // as a's scope ends here, it get's dropped

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let a = PolyOverZ::from_str("3  0 1 2").unwrap();
drop(a); // explicitly drops a's value

impl<Integer: Into<Z>> Evaluate<Integer, Z> for PolyOverZ

fn evaluate(&self, value: Integer) -> Z

Evaluates a PolyOverZ on a given input.

Parameters:

• value: the value with which to evaluate the polynomial.

Returns the evaluation of the polynomial as a Z.

Examples

use qfall_math::traits::*;
use qfall_math::integer::Z;
use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let poly = PolyOverZ::from_str("5  0 1 2 -3 1").unwrap();
let res: Z = poly.evaluate(3);

impl<Rational: Into<Q>> Evaluate<Rational, Q> for PolyOverZ

fn evaluate(&self, value: Rational) -> Q

Evaluates a PolyOverZ on a given input.

Parameters:

• value: the value with which to evaluate the polynomial.

Returns the evaluation of the polynomial as a Q.

Examples

use qfall_math::traits::*;
use qfall_math::rational::Q;
use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let poly = PolyOverZ::from_str("5  0 1 2 -3 1").unwrap();
let value = Q::from((3, 2));
let res: Q = poly.evaluate(&value);

impl From<&PolyOverZ> for PolyOverQ

fn from(poly: &PolyOverZ) -> Self

Creates a PolyOverQ from a PolyOverZ.

Parameters:

• poly: the polynomial from which the coefficients are copied

Examples

use qfall_math::integer::PolyOverZ;
use qfall_math::rational::PolyOverQ;
use std::str::FromStr;

let poly = PolyOverZ::from_str("4  0 1 102 3").unwrap();

let poly_q = PolyOverQ::from(&poly);

impl From<&PolyOverZ> for PolyOverZ

fn from(value: &PolyOverZ) -> Self

Alias for PolyOverZ::clone.

impl From<&PolyOverZ> for String

fn from(value: &PolyOverZ) -> Self

Converts a PolyOverZ into its String representation.

Parameters:

• value: specifies the polynomial that will be represented as a String

Returns a String of the form "[#number of coefficients]⌴⌴[0th coefficient]⌴[1st coefficient]⌴...".

Examples

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;
let poly = PolyOverZ::from_str("2  6 1").unwrap();

let string: String = poly.into();

impl<Integer: AsInteger + Into<Z>> From<Integer> for PolyOverZ

fn from(value: Integer) -> Self

Creates a constant PolyOverZ with a specified integer constant.

Parameters: value: an integer like Z, rust Integers or a reference to these values.

Returns a new constant polynomial with the specified value.

Examples

use qfall_math::{integer::*, traits::*};

let one = PolyOverZ::from(1);

assert_eq!(one.get_coeff(0).unwrap(), Z::ONE);
assert_eq!(one.get_degree(), 0);

impl From<PolyOverZ> for PolyOverQ

fn from(value: PolyOverZ) -> Self

Documentation can be found at PolyOverQ::from for &PolyOverZ.

impl From<PolyOverZ> for String

fn from(value: PolyOverZ) -> Self

Documentation can be found at String::from for &PolyOverZ.

impl FromCoefficientEmbedding<&MatZ> for PolyOverZ

fn from_coefficient_embedding(embedding: &MatZ) -> Self

Computes a polynomial from a vector. The first i-th entry of the column vector is taken as the coefficient of the polynomial. It inverts the operation of PolyOverZ::into_coefficient_embedding.

Parameters:

• embedding: the column vector that encodes the embedding

Returns a polynomial that corresponds to the embedding.

Examples

use std::str::FromStr;
use qfall_math::{
    integer::{MatZ, PolyOverZ},
    traits::FromCoefficientEmbedding,
};

let vector = MatZ::from_str("[[17],[3],[-5]]").unwrap();
let poly = PolyOverZ::from_coefficient_embedding(&vector);
let cmp_poly = PolyOverZ::from_str("3  17 3 -5").unwrap();
assert_eq!(cmp_poly, poly);

Panics …

• if the provided embedding is not a column vector.

impl FromStr for PolyOverZ

fn from_str(s: &str) -> Result<Self, Self::Err>

Creates a polynomial with arbitrarily many coefficients of type Z from a String.

Warning: If the input string starts with a correctly formatted PolyOverZ object, the rest of the string is ignored. This means that the input string "4 0 1 2 3" is the same as "4 0 1 2 3 4 5 6 7".

Parameters:

• s: the polynomial of form: "[#number of coefficients]⌴⌴[0th coefficient]⌴[1st coefficient]⌴...".

Note that the [#number of coefficients] and [0th coefficient] are divided by two spaces and the input string is trimmed, i.e. all whitespaces before and after are ignored.

Returns a PolyOverZ or an error if the provided string was not formatted correctly, the number of coefficients was smaller than the number provided at the start of the provided string, or the provided string contains a Null Byte.

Examples

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let poly = PolyOverZ::from_str("4  0 1 2 3").unwrap();

Errors and Failures

• Returns a MathError of type MathError::StringConversionError
  • if the provided string was not formatted correctly,
  • if the number of coefficients was smaller than the number provided at the start of the provided string,
  • if the provided value did not contain two whitespaces, or
  • if the provided string contains a Null Byte.

type Err = MathError

The associated error which can be returned from parsing.

impl GetCoefficient<Z> for PolyOverZ

unsafe fn get_coeff_unchecked(&self, index: i64) -> Z

Returns the coefficient of a polynomial PolyOverZ as a Z.

If an index is provided which exceeds the highest set coefficient, 0 is returned.

Parameters:

• index: the index of the coefficient to get (has to be positive)

Returns the coefficient as a Z, or a MathError if the provided index is negative and therefore invalid, or it does not fit into an i64.

Examples

use qfall_math::integer::{Z, PolyOverZ};
use std::str::FromStr;
use qfall_math::traits::*;

let poly = PolyOverZ::from_str("4  0 1 2 3").unwrap();

let coeff_0 = poly.get_coeff(0).unwrap();
let coeff_1 = unsafe{ poly.get_coeff_unchecked(1) };
let coeff_4 = poly.get_coeff(4).unwrap();

assert_eq!(Z::ZERO, coeff_0);
assert_eq!(Z::ONE, coeff_1);
assert_eq!(Z::ZERO, coeff_4);

Safety

To use this function safely, make sure that the selected index is greater or equal than 0.

fn get_coeff(&self, index: impl TryInto<i64> + Display) -> Result<T, MathError>

Returns a coefficient of the given object, e.g. a polynomial, for a given index.

impl IntoCoefficientEmbedding<MatZ> for &PolyOverZ

fn into_coefficient_embedding(self, size: impl Into<i64>) -> MatZ

Computes the coefficient embedding of the polynomial in a MatZ as a column vector, where the i-th entry of the vector corresponds to the i-th coefficient. It inverts the operation of PolyOverZ::from_coefficient_embedding.

Parameters:

• size: determines the number of rows of the embedding. It has to be larger than the degree of the polynomial.

Returns a coefficient embedding as a column vector if size is large enough.

Examples

use std::str::FromStr;
use qfall_math::{
    integer::{MatZ, PolyOverZ},
    traits::IntoCoefficientEmbedding,
};

let poly = PolyOverZ::from_str("3  17 3 -5").unwrap();
let vector = poly.into_coefficient_embedding(4);
let cmp_vector = MatZ::from_str("[[17],[3],[-5],[0]]").unwrap();
assert_eq!(cmp_vector, vector);

Panics …

• if size is not larger than the degree of the polynomial, i.e. not all coefficients can be embedded.

impl MatrixGetEntry<PolyOverZ> for MatPolyOverZ

unsafe fn get_entry_unchecked(&self, row: i64, column: i64) -> PolyOverZ

Outputs the PolyOverZ value of a specific matrix entry without checking whether it’s part of the matrix.

Parameters:

• row: specifies the row in which the entry is located
• column: specifies the column in which the entry is located

Returns the PolyOverZ value of the matrix at the position of the given row and column.

Safety

To use this function safely, make sure that the selected entry is part of the matrix. If it is not, memory leaks, unexpected panics, etc. might occur.

Examples

use qfall_math::integer::{MatPolyOverZ, PolyOverZ};
use qfall_math::traits::*;
use std::str::FromStr;

let matrix = MatPolyOverZ::from_str("[[1  1, 1  2],[1  3, 1  4],[0, 1  6]]").unwrap();

assert_eq!(PolyOverZ::from(2), unsafe { matrix.get_entry_unchecked(0, 1) });
assert_eq!(PolyOverZ::from(4), unsafe { matrix.get_entry_unchecked(1, 1) });

fn get_entry( &self, row: impl TryInto<i64> + Display, column: impl TryInto<i64> + Display, ) -> Result<T, MathError>

Returns the value of a specific matrix entry.

fn get_entries(&self) -> Vec<Vec<T>>

Outputs a Vec<Vec<T>> containing all entries of the matrix s.t. any entry in row i and column j can be accessed via entries[i][j] if entries = matrix.get_entries.

fn get_entries_rowwise(&self) -> Vec<T>

Outputs a Vec<T> containing all entries of the matrix in a row-wise order, i.e. a matrix [[2, 3, 4],[5, 6, 7]] can be accessed via this function in this order [2, 3, 4, 5, 6, 7].

fn get_entries_columnwise(&self) -> Vec<T>

Outputs a Vec<T> containing all entries of the matrix in a column-wise order, i.e. a matrix [[2, 3, 4],[5, 6, 7]] can be accessed via this function in this order [2, 5, 3, 6, 4, 7].

impl MatrixGetEntry<PolyOverZ> for MatPolynomialRingZq

unsafe fn get_entry_unchecked(&self, row: i64, column: i64) -> PolyOverZ

Outputs the PolyOverZ value of a specific matrix entry without checking whether it’s part of the matrix.

Parameters:

• row: specifies the row in which the entry is located
• column: specifies the column in which the entry is located

Returns the PolyOverZ value of the matrix at the position of the given row and column.

Safety

To use this function safely, make sure that the selected entry is part of the matrix. If it is not, memory leaks, unexpected panics, etc. might occur.

Examples

use qfall_math::integer_mod_q::{MatPolynomialRingZq, ModulusPolynomialRingZq};
use qfall_math::integer::{MatPolyOverZ, PolyOverZ};
use qfall_math::traits::*;
use std::str::FromStr;

let modulus = ModulusPolynomialRingZq::from_str("4  1 0 0 1 mod 50").unwrap();
let poly_mat = MatPolyOverZ::from_str("[[4  -1 0 1 1, 1  42],[0, 2  1 2]]").unwrap();
let poly_ring_mat = MatPolynomialRingZq::from((&poly_mat, &modulus));

let entry_1: PolyOverZ = unsafe { poly_ring_mat.get_entry_unchecked(1, 0) };
let entry_2: PolyOverZ = unsafe { poly_ring_mat.get_entry_unchecked(0, 1) };


assert_eq!(entry_1, PolyOverZ::from(0));
assert_eq!(entry_2, PolyOverZ::from(42));

fn get_entry( &self, row: impl TryInto<i64> + Display, column: impl TryInto<i64> + Display, ) -> Result<T, MathError>

Returns the value of a specific matrix entry.

fn get_entries(&self) -> Vec<Vec<T>>

Outputs a Vec<Vec<T>> containing all entries of the matrix s.t. any entry in row i and column j can be accessed via entries[i][j] if entries = matrix.get_entries.

fn get_entries_rowwise(&self) -> Vec<T>

Outputs a Vec<T> containing all entries of the matrix in a row-wise order, i.e. a matrix [[2, 3, 4],[5, 6, 7]] can be accessed via this function in this order [2, 3, 4, 5, 6, 7].

fn get_entries_columnwise(&self) -> Vec<T>

Outputs a Vec<T> containing all entries of the matrix in a column-wise order, i.e. a matrix [[2, 3, 4],[5, 6, 7]] can be accessed via this function in this order [2, 5, 3, 6, 4, 7].

impl MatrixSetEntry<&PolyOverZ> for MatPolyOverZ

unsafe fn set_entry_unchecked( &mut self, row: i64, column: i64, value: &PolyOverZ, )

Sets the value of a specific matrix entry according to a given value of type PolyOverZ without checking whether the coordinate is part of the matrix.

Parameters:

• row: specifies the row in which the entry is located
• column: specifies the column in which the entry is located
• value: specifies the value to which the entry is set

Safety

To use this function safely, make sure that the selected entry is part of the matrix. If it is not, memory leaks, unexpected panics, etc. might occur.

Examples

use qfall_math::integer::{MatPolyOverZ, PolyOverZ};
use qfall_math::traits::MatrixSetEntry;
use std::str::FromStr;

let mut matrix = MatPolyOverZ::new(2, 2);
let value = PolyOverZ::from_str("2  1 1").unwrap();

unsafe {
    matrix.set_entry_unchecked(0, 1, &value);
    matrix.set_entry_unchecked(1, 0, &PolyOverZ::from(2));
}

assert_eq!("[[0, 2  1 1],[1  2, 0]]", matrix.to_string());

fn set_entry( &mut self, row: impl TryInto<i64> + Display, column: impl TryInto<i64> + Display, value: T, ) -> Result<(), MathError>

Sets the value of a specific matrix entry according to a given value.

impl MatrixSetEntry<&PolyOverZ> for MatPolynomialRingZq

fn set_entry( &mut self, row: impl TryInto<i64> + Display, column: impl TryInto<i64> + Display, value: &PolyOverZ, ) -> Result<(), MathError>

Sets the value of a specific matrix entry according to a given value of type PolyOverZ.

Parameters:

• row: specifies the row in which the entry is located
• column: specifies the column in which the entry is located
• value: specifies the value to which the entry is set

Negative indices can be used to index from the back, e.g., -1 for the last element.

Returns an empty Ok if the action could be performed successfully. Otherwise, a MathError is returned if the specified entry is not part of the matrix.

Examples

use qfall_math::integer_mod_q::{MatPolynomialRingZq, ModulusPolynomialRingZq};
use qfall_math::integer::{MatPolyOverZ, PolyOverZ};
use crate::qfall_math::traits::*;
use std::str::FromStr;

let modulus = ModulusPolynomialRingZq::from_str("4  1 0 0 1 mod 17").unwrap();
let poly_mat = MatPolyOverZ::from_str("[[0, 1  42],[0, 2  1 2]]").unwrap();
let mut poly_ring_mat = MatPolynomialRingZq::from((&poly_mat, &modulus));
let value = PolyOverZ::default();

poly_ring_mat.set_entry(0, 1, &value).unwrap();
poly_ring_mat.set_entry(-1, -1, &value).unwrap();

let mat_cmp = MatPolynomialRingZq::from((&MatPolyOverZ::new(2, 2), &modulus));
assert_eq!(poly_ring_mat, mat_cmp);

Errors and Failures

• Returns a MathError of type MathError::OutOfBounds if row or column are greater than the matrix size.

unsafe fn set_entry_unchecked( &mut self, row: i64, column: i64, value: &PolyOverZ, )

Sets the value of a specific matrix entry according to a given value of type PolyOverZ without checking whether the coordinate is part of the matrix, if the moduli match or if the entry is reduced.

Parameters:

• row: specifies the row in which the entry is located
• column: specifies the column in which the entry is located
• value: specifies the value to which the entry is set

Safety

To use this function safely, make sure that the selected entry is part of the matrix. If it is not, memory leaks, unexpected panics, etc. might occur.

Examples

use qfall_math::integer_mod_q::{MatPolynomialRingZq, ModulusPolynomialRingZq};
use qfall_math::integer::{MatPolyOverZ, PolyOverZ};
use crate::qfall_math::traits::*;
use std::str::FromStr;

let modulus = ModulusPolynomialRingZq::from_str("4  1 0 0 1 mod 17").unwrap();
let poly_mat = MatPolyOverZ::from_str("[[0, 1  42],[0, 2  1 2]]").unwrap();
let mut poly_ring_mat = MatPolynomialRingZq::from((&poly_mat, &modulus));
let value = PolyOverZ::default();

unsafe {
    poly_ring_mat.set_entry_unchecked(0, 1, &value);
    poly_ring_mat.set_entry_unchecked(1, 1, &value);
}

let mat_cmp = MatPolynomialRingZq::from((&MatPolyOverZ::new(2, 2), &modulus));
assert_eq!(poly_ring_mat, mat_cmp);

impl MatrixSetEntry<PolyOverZ> for MatPolyOverZ

fn set_entry( &mut self, row: impl TryInto<i64> + Display, column: impl TryInto<i64> + Display, value: PolyOverZ, ) -> Result<(), MathError>

Documentation can be found at MatPolyOverZ::set_entry for &PolyOverZ.

unsafe fn set_entry_unchecked( &mut self, row: i64, column: i64, value: PolyOverZ, )

Documentation can be found at MatPolyOverZ::set_entry for &PolyOverZ.

impl MatrixSetEntry<PolyOverZ> for MatPolynomialRingZq

fn set_entry( &mut self, row: impl TryInto<i64> + Display, column: impl TryInto<i64> + Display, value: PolyOverZ, ) -> Result<(), MathError>

Documentation can be found at MatPolynomialRingZq::set_entry for &PolyOverZ.

unsafe fn set_entry_unchecked( &mut self, row: i64, column: i64, value: PolyOverZ, )

Documentation can be found at MatPolynomialRingZq::set_entry for &PolyOverZ.

impl Mul<&PolyOverZ> for &MatPolyOverZ

fn mul(self, scalar: &PolyOverZ) -> Self::Output

Implements the Mul trait for a MatPolyOverZ matrix with a PolyOverZ. Mul is implemented for any combination of owned and borrowed values.

Parameters:

• scalar: specifies the scalar by which the matrix is multiplied

Returns the product of self and scalar as a MatPolyOverZ.

Examples

use qfall_math::integer::MatPolyOverZ;
use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let mat_1 = MatPolyOverZ::from_str("[[2  1 42, 1  17],[1  8, 2  5 6]]").unwrap();
let poly = PolyOverZ::from_str("3  1 2 3").unwrap();

let mat_2 = &mat_1 * &poly;

type Output = MatPolyOverZ

The resulting type after applying the * operator.

impl Mul<&PolyOverZ> for &MatPolynomialRingZq

fn mul(self, scalar: &PolyOverZ) -> Self::Output

Implements the Mul trait for a MatPolynomialRingZq matrix with a PolyOverZ. Mul is implemented for any combination of owned and borrowed values.

Parameters:

• scalar: Specifies the scalar by which the matrix is multiplied.

Returns the product of self and scalar as a MatPolynomialRingZq.

Examples

use qfall_math::integer_mod_q::{MatPolynomialRingZq, ModulusPolynomialRingZq, PolynomialRingZq};
use qfall_math::integer::{MatPolyOverZ, PolyOverZ, Z};
use std::str::FromStr;

let modulus = ModulusPolynomialRingZq::from_str("4  1 0 0 1 mod 17").unwrap();
let poly_mat1 = MatPolyOverZ::from_str("[[3  0 1 1, 1  42],[0, 2  1 2]]").unwrap();
let poly_ring_mat1 = MatPolynomialRingZq::from((&poly_mat1, &modulus));
let poly = PolyOverZ::from_str("3  1 0 1").unwrap();

let poly_ring_mat2 = &poly_ring_mat1 * &poly;

type Output = MatPolynomialRingZq

The resulting type after applying the * operator.

impl Mul<&PolyOverZ> for &PolyOverQ

fn mul(self, other: &PolyOverZ) -> Self::Output

Implements the Mul trait for PolyOverQ and PolyOverZ. Mul is implemented for any combination of owned and borrowed values.

Parameters:

• other: specifies the polynomial to multiply to self

Returns the product of both polynomials as a PolyOverQ.

Examples

use qfall_math::rational::PolyOverQ;
use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let a = PolyOverQ::from_str("4  1/2 0 3/7 1").unwrap();
let b = PolyOverZ::from_str("4  2 0 3 1").unwrap();

let c: PolyOverQ = &a * &b;

type Output = PolyOverQ

The resulting type after applying the * operator.

impl Mul<&PolyOverZ> for &PolyOverZq

fn mul(self, other: &PolyOverZ) -> Self::Output

Implements the Mul trait for PolyOverZq and PolyOverZ. Mul is implemented for any combination of owned and borrowed values.

Parameters:

• other: specifies the polynomial to multiply to self

Returns the product of both polynomials as a PolyOverZq.

Examples

use qfall_math::integer_mod_q::PolyOverZq;
use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let a = PolyOverZq::from_str("4  -1 0 1 1 mod 17").unwrap();
let b = PolyOverZ::from_str("4  2 0 3 1").unwrap();

let c: PolyOverZq = &a * &b;

type Output = PolyOverZq

The resulting type after applying the * operator.

impl Mul<&PolyOverZ> for &PolynomialRingZq

fn mul(self, other: &PolyOverZ) -> Self::Output

Implements the Mul trait for PolynomialRingZq and PolyOverZ. Mul is implemented for any combination of owned and borrowed values.

Parameters:

• other: specifies the polynomial to multiply to self

Returns the product of both polynomials as a PolynomialRingZq.

Examples

use qfall_math::integer_mod_q::PolynomialRingZq;
use qfall_math::integer_mod_q::ModulusPolynomialRingZq;
use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let modulus = ModulusPolynomialRingZq::from_str("4  1 0 0 1 mod 17").unwrap();
let poly = PolyOverZ::from_str("4  -1 0 1 1").unwrap();
let a = PolynomialRingZq::from((&poly, &modulus));
let b = PolyOverZ::from_str("4  2 0 3 1").unwrap();

let c: PolynomialRingZq = &a * &b;

type Output = PolynomialRingZq

The resulting type after applying the * operator.

impl Mul<&Q> for &PolyOverZ

fn mul(self, scalar: &Q) -> PolyOverQ

Implements the Mul trait for a PolyOverZ with a Q. Mul is implemented for any combination of owned and borrowed values. Mul is also implemented for Q using PolyOverZ.

Parameters:

• scalar: specifies the scalar by which the polynomial is multiplied

Returns the product of self and scalar as a PolyOverQ.

Examples

use qfall_math::integer::PolyOverZ;
use qfall_math::rational::Q;
use std::str::FromStr;

let poly_1 = PolyOverZ::from_str("4  1 2 3 4").unwrap();
let rational = Q::from((3,2));

let poly_2 = &poly_1 * &rational;

type Output = PolyOverQ

The resulting type after applying the * operator.

impl Mul<&Z> for &PolyOverZ

fn mul(self, scalar: &Z) -> Self::Output

Implements the Mul trait for a PolyOverZ with a Z integer. Mul is implemented for any combination of owned and borrowed values. Mul is also implemented for Z using PolyOverZ.

Parameters:

• scalar: specifies the scalar by which the polynomial is multiplied

Returns the product of self and scalar as a PolyOverZ.

Examples

use qfall_math::integer::PolyOverZ;
use qfall_math::integer::Z;
use std::str::FromStr;

let poly_1 = PolyOverZ::from_str("4  1 2 3 4").unwrap();
let integer = Z::from(3);

let poly_2 = &poly_1 * &integer;

type Output = PolyOverZ

The resulting type after applying the * operator.

impl Mul<&Zq> for &PolyOverZ

fn mul(self, scalar: &Zq) -> PolyOverZq

Implements the Mul trait for a PolyOverZ with a Zq. Mul is implemented for any combination of owned and borrowed values. Mul is also implemented for Zq using PolyOverZ.

Parameters:

• scalar: specifies the scalar by which the matrix is multiplied

Returns the product of self and scalar as a PolyOverZq.

Examples

use qfall_math::integer::PolyOverZ;
use qfall_math::integer_mod_q::{PolyOverZq, Zq};
use std::str::FromStr;

let poly_1 = PolyOverZ::from_str("4  1 2 3 4").unwrap();
let integer = Zq::from((3,17));

let poly_2 = &poly_1 * &integer;

type Output = PolyOverZq

The resulting type after applying the * operator.

impl Mul for &PolyOverZ

fn mul(self, other: Self) -> Self::Output

Implements the Mul trait for two PolyOverZ values. Mul is implemented for any combination of PolyOverZ and borrowed PolyOverZ.

Parameters:

• other: specifies the value to multiply with self

Returns the product of both polynomials as a PolyOverZ.

Examples

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let a: PolyOverZ = PolyOverZ::from_str("3  1 2 -3").unwrap();
let b: PolyOverZ = PolyOverZ::from_str("5  1 2 -3 0 8").unwrap();

let c: PolyOverZ = &a * &b;
let d: PolyOverZ = a * b;
let e: PolyOverZ = &c * d;
let f: PolyOverZ = c * &e;

type Output = PolyOverZ

The resulting type after applying the * operator.

impl MulAssign<&PolyOverZ> for MatPolyOverZ

fn mul_assign(&mut self, scalar: &PolyOverZ)

Documentation at MatPolyOverZ::mul_assign.

impl MulAssign<&PolyOverZ> for PolyOverQ

fn mul_assign(&mut self, other: &PolyOverZ)

Documentation at PolyOverQ::mul_assign.

impl MulAssign<&PolyOverZ> for PolyOverZ

fn mul_assign(&mut self, other: &Self)

Computes the multiplication of self and other reusing the memory of self.

Parameters:

• other: specifies the polynomial to multiply to self

Returns the product of both polynomials as a PolyOverZ.

Examples

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let mut a = PolyOverZ::from_str("3  1 2 -3").unwrap();
let b = PolyOverZ::from_str("5  1 2 -3 0 8").unwrap();

a *= &b;
a *= b;

impl MulAssign<&PolyOverZ> for PolyOverZq

fn mul_assign(&mut self, other: &PolyOverZ)

Documentation at PolyOverZq::mul_assign.

impl MulAssign<&Z> for PolyOverZ

fn mul_assign(&mut self, scalar: &Z)

Computes the scalar multiplication of self and scalar reusing the memory of self.

Parameters:

• scalar: specifies the value to multiply to self

Returns the scalar of the polynomial as a PolyOverZ.

Examples

use qfall_math::integer::{Z,PolyOverZ};
use std::str::FromStr;

let mut a = PolyOverZ::from_str("3  1 2 -3").unwrap();
let b = Z::from(2);

a *= &b;
a *= b;
a *= 2;
a *= -2;

impl MulAssign<PolyOverZ> for MatPolyOverZ

fn mul_assign(&mut self, other: PolyOverZ)

Documentation at MatPolyOverZ::mul_assign.

impl MulAssign<PolyOverZ> for PolyOverQ

fn mul_assign(&mut self, other: PolyOverZ)

Documentation at PolyOverQ::mul_assign.

impl MulAssign<PolyOverZ> for PolyOverZq

fn mul_assign(&mut self, other: PolyOverZ)

Documentation at PolyOverZq::mul_assign.

impl MulAssign<Z> for PolyOverZ

fn mul_assign(&mut self, other: Z)

Documentation at PolyOverZ::mul_assign.

impl MulAssign<i16> for PolyOverZ

fn mul_assign(&mut self, other: i16)

Documentation at PolyOverZ::mul_assign.

impl MulAssign<i32> for PolyOverZ

fn mul_assign(&mut self, other: i32)

Documentation at PolyOverZ::mul_assign.

impl MulAssign<i64> for PolyOverZ

fn mul_assign(&mut self, scalar: i64)

Documentation at PolyOverZ::mul_assign.

impl MulAssign<i8> for PolyOverZ

fn mul_assign(&mut self, other: i8)

Documentation at PolyOverZ::mul_assign.

impl MulAssign<u16> for PolyOverZ

fn mul_assign(&mut self, other: u16)

Documentation at PolyOverZ::mul_assign.

impl MulAssign<u32> for PolyOverZ

fn mul_assign(&mut self, other: u32)

Documentation at PolyOverZ::mul_assign.

impl MulAssign<u64> for PolyOverZ

fn mul_assign(&mut self, scalar: u64)

Documentation at PolyOverZ::mul_assign.

impl MulAssign<u8> for PolyOverZ

fn mul_assign(&mut self, other: u8)

Documentation at PolyOverZ::mul_assign.

impl MulAssign for PolyOverZ

fn mul_assign(&mut self, other: PolyOverZ)

Documentation at PolyOverZ::mul_assign.

impl PartialEq<PolyOverZ> for PolyOverQ

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

Checks if an integer matrix and a rational matrix are equal. Used by the == and != operators. PartialEq is also implemented for PolyOverZ using PolyOverQ.

Parameters:

• other: the other value that is used to compare the elements

Returns true if the elements are equal, otherwise false.

Examples

use qfall_math::integer::PolyOverZ;
use qfall_math::rational::PolyOverQ;
use std::str::FromStr;
let a: PolyOverQ = PolyOverQ::from_str("3  1 2 3").unwrap();
let b: PolyOverZ = PolyOverZ::from_str("3  1 2 3").unwrap();

// These are all equivalent and return true.
let compared: bool = (a == b);
let compared: bool = (b == a);
let compared: bool = (&a == &b);
let compared: bool = (&b == &a);
let compared: bool = (a.eq(&b));
let compared: bool = (b.eq(&a));
let compared: bool = (PolyOverQ::eq(&a, &b));
let compared: bool = (PolyOverZ::eq(&b, &a));

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 PartialEq for PolyOverZ

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

Checks if two polynomials over Z are equal. Used by the == and != operators.

Parameters:

• other: the other value that is used to compare the elements

Returns true if the elements are equal, otherwise false.

Examples

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;
let a: PolyOverZ = PolyOverZ::from_str("2  42 1").unwrap();
let b: PolyOverZ = PolyOverZ::from_str("2  24 1").unwrap();

// These are all equivalent and return false.
let compared: bool = (a == b);
let compared: bool = (&a == &b);
let compared: bool = (a.eq(&b));
let compared: bool = (PolyOverZ::eq(&a, &b));

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 Rem<&Modulus> for &PolyOverZ

fn rem(self, modulus: &Modulus) -> Self::Output

Computes self mod modulus as long as modulus is greater than 1. For negative values of self, the smallest positive representative is returned.

Parameters:

• modulus: specifies a non-zero integer over which the positive remainder is computed

Returns self mod modulus as a PolyOverZ instance.

Examples

use qfall_math::integer_mod_q::Modulus;
use qfall_math::integer::{PolyOverZ, Z};
use std::str::FromStr;

let a: PolyOverZ = PolyOverZ::from_str("2  -2 42").unwrap();
let b = Modulus::from(24);

let c: PolyOverZ = a % b;

type Output = PolyOverZ

The resulting type after applying the % operator.

impl Rem<&Z> for &PolyOverZ

fn rem(self, modulus: &Z) -> Self::Output

Computes self mod modulus as long as modulus is greater than 1. For negative coefficients in self, the smallest positive representative is returned.

Parameters:

• modulus: specifies a non-zero integer over which the positive remainders are computed

Returns self mod modulus as a PolyOverZ instance.

Examples

use qfall_math::integer::{PolyOverZ, Z};
use std::str::FromStr;

let a: PolyOverZ = PolyOverZ::from_str("2  -2 42").unwrap();
let b: Z = Z::from(24);

let c: PolyOverZ = a % b;

Panics …

• if modulus is smaller than 2.

type Output = PolyOverZ

The resulting type after applying the % operator.

impl<Mod: Into<ModulusPolynomialRingZq>> Rem<Mod> for &PolyOverZ

fn rem(self, modulus: Mod) -> Self::Output

Computes self mod modulus as long as modulus is greater than 1. For negative values of self, the smallest positive representative is returned.

Parameters:

• modulus: specifies a non-zero integer over which the positive remainder is computed

Returns self mod modulus as a PolyOverZ instance.

Examples

use qfall_math::integer_mod_q::ModulusPolynomialRingZq;
use qfall_math::integer::{PolyOverZ, Z};
use std::str::FromStr;

let a: PolyOverZ = PolyOverZ::from_str("2  -2 42").unwrap();
let b = ModulusPolynomialRingZq::from_str("4  1 0 0 1 mod 24").unwrap();

let c: PolyOverZ = &a % b;

type Output = PolyOverZ

The resulting type after applying the % operator.

impl<Mod: Into<ModulusPolynomialRingZq>> Rem<Mod> for PolyOverZ

fn rem(self, modulus: Mod) -> Self::Output

Computes self mod modulus as long as modulus is greater than 1. For negative values of self, the smallest positive representative is returned.

Parameters:

• modulus: specifies a non-zero integer over which the positive remainder is computed

Returns self mod modulus as a PolyOverZ instance.

Examples

use qfall_math::integer_mod_q::ModulusPolynomialRingZq;
use qfall_math::integer::{PolyOverZ, Z};
use std::str::FromStr;

let a: PolyOverZ = PolyOverZ::from_str("2  -2 42").unwrap();
let b = ModulusPolynomialRingZq::from_str("4  1 0 0 1 mod 24").unwrap();

let c: PolyOverZ = a % b;

type Output = PolyOverZ

The resulting type after applying the % operator.

impl Rem<i16> for PolyOverZ

fn rem(self, modulus: i16) -> Self::Output

Documentation can be found at PolyOverZ::rem.

type Output = PolyOverZ

The resulting type after applying the % operator.

impl Rem<i32> for PolyOverZ

fn rem(self, modulus: i32) -> Self::Output

Documentation can be found at PolyOverZ::rem.

type Output = PolyOverZ

The resulting type after applying the % operator.

impl Rem<i64> for PolyOverZ

fn rem(self, modulus: i64) -> Self::Output

Documentation can be found at PolyOverZ::rem.

type Output = PolyOverZ

The resulting type after applying the % operator.

impl Rem<i8> for PolyOverZ

fn rem(self, modulus: i8) -> Self::Output

Documentation can be found at PolyOverZ::rem.

type Output = PolyOverZ

The resulting type after applying the % operator.

impl Rem<u16> for PolyOverZ

fn rem(self, modulus: u16) -> Self::Output

Documentation can be found at PolyOverZ::rem.

type Output = PolyOverZ

The resulting type after applying the % operator.

impl Rem<u32> for PolyOverZ

fn rem(self, modulus: u32) -> Self::Output

Documentation can be found at PolyOverZ::rem.

type Output = PolyOverZ

The resulting type after applying the % operator.

impl Rem<u64> for PolyOverZ

fn rem(self, modulus: u64) -> Self::Output

Documentation can be found at PolyOverZ::rem.

type Output = PolyOverZ

The resulting type after applying the % operator.

impl Rem<u8> for PolyOverZ

fn rem(self, modulus: u8) -> Self::Output

Documentation can be found at PolyOverZ::rem.

type Output = PolyOverZ

The resulting type after applying the % operator.

impl Serialize for PolyOverZ

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Implements the serialize option. This allows to create a Json-object from a given PolyOverZ.

impl<Integer: Into<Z>> SetCoefficient<Integer> for PolyOverZ

unsafe fn set_coeff_unchecked(&mut self, index: i64, value: Integer)

Sets the coefficient of a polynomial PolyOverZ. We advise to use small coefficients, since already 2^32 coefficients take space of roughly 34 GB. If not careful, be prepared that memory problems can occur, if the index is very high.

Parameters:

• index: the index of the coefficient to set (has to be positive)
• value: the new value the index should have

Examples

use qfall_math::integer::PolyOverZ;
use qfall_math::integer::Z;
use qfall_math::traits::*;
use std::str::FromStr;

let mut poly = PolyOverZ::from_str("4  0 1 2 3").unwrap();

assert!(poly.set_coeff(4, 1000).is_ok());
unsafe{ poly.set_coeff_unchecked(5, -1000) };

Safety

To use this function safely, make sure that the selected index is greater or equal than 0 and that the provided value has the same base so that they have a matching base.

fn set_coeff( &mut self, index: impl TryInto<i64> + Display, value: T, ) -> Result<(), MathError>

Sets coefficient of the object, e.g. polynomial, for a given input value and a index.

impl Sub<&PolyOverQ> for &PolyOverZ

fn sub(self, other: &PolyOverQ) -> Self::Output

Implements the Sub trait for PolyOverZ and PolyOverQ. Sub is implemented for any combination of owned and borrowed values.

Parameters:

• other: specifies the polynomial to subtract from self

Returns the subtraction of both polynomials as a PolyOverQ.

Examples

use qfall_math::rational::PolyOverQ;
use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let a = PolyOverZ::from_str("4  2 0 3 1").unwrap();
let b = PolyOverQ::from_str("4  1/2 0 3/7 1").unwrap();

let c: PolyOverQ = &a - &b;

type Output = PolyOverQ

The resulting type after applying the - operator.

impl Sub<&PolyOverZ> for &PolyOverQ

fn sub(self, other: &PolyOverZ) -> Self::Output

Implements the Sub trait for PolyOverQ and PolyOverZ. Sub is implemented for any combination of owned and borrowed values.

Parameters:

• other: specifies the polynomial to subtract from self

Returns the subtraction of both polynomials as a PolyOverQ.

Examples

use qfall_math::rational::PolyOverQ;
use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let a = PolyOverQ::from_str("4  1/2 0 3/7 1").unwrap();
let b = PolyOverZ::from_str("4  2 0 3 1").unwrap();

let c: PolyOverQ = &a - &b;

type Output = PolyOverQ

The resulting type after applying the - operator.

impl Sub<&PolyOverZ> for &PolyOverZq

fn sub(self, other: &PolyOverZ) -> Self::Output

Implements the Sub trait for PolyOverZq and PolyOverZ. Sub is implemented for any combination of owned and borrowed values.

Parameters:

• other: specifies the polynomial to subtract from self

Returns the subtraction of both polynomials as a PolyOverZq.

Examples

use qfall_math::integer_mod_q::PolyOverZq;
use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let a = PolyOverZq::from_str("4  -1 0 1 1 mod 17").unwrap();
let b = PolyOverZ::from_str("4  2 0 3 1").unwrap();

let c: PolyOverZq = &a - &b;

type Output = PolyOverZq

The resulting type after applying the - operator.

impl Sub<&PolyOverZ> for &PolynomialRingZq

fn sub(self, other: &PolyOverZ) -> Self::Output

Implements the Sub trait for PolynomialRingZq and PolyOverZ. Sub is implemented for any combination of owned and borrowed values.

Parameters:

• other: specifies the polynomial to subtract from self

Returns the subtraction of both polynomials as a PolynomialRingZq.

Examples

use qfall_math::integer_mod_q::PolynomialRingZq;
use qfall_math::integer_mod_q::ModulusPolynomialRingZq;
use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let modulus = ModulusPolynomialRingZq::from_str("4  1 0 0 1 mod 17").unwrap();
let poly = PolyOverZ::from_str("4  -1 0 1 1").unwrap();
let a = PolynomialRingZq::from((&poly, &modulus));
let b = PolyOverZ::from_str("4  2 0 3 1").unwrap();

let c: PolynomialRingZq = &a - &b;

type Output = PolynomialRingZq

The resulting type after applying the - operator.

impl Sub<&PolyOverZq> for &PolyOverZ

fn sub(self, other: &PolyOverZq) -> Self::Output

Implements the Sub trait for PolyOverZ and PolyOverZq. Sub is implemented for any combination of owned and borrowed values.

Parameters:

• other: specifies the polynomial to subtract from self

Returns the subtraction of both polynomials as a PolyOverZq.

Examples

use qfall_math::integer_mod_q::PolyOverZq;
use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let a = PolyOverZ::from_str("4  2 0 3 1").unwrap();
let b = PolyOverZq::from_str("4  -1 0 1 1 mod 17").unwrap();

let c: PolyOverZq = &a - &b;

type Output = PolyOverZq

The resulting type after applying the - operator.

impl Sub<&PolynomialRingZq> for &PolyOverZ

fn sub(self, other: &PolynomialRingZq) -> Self::Output

Implements the Sub trait for PolyOverZ and PolynomialRingZq. Sub is implemented for any combination of owned and borrowed values.

Parameters:

• other: specifies the polynomial to subtract from self

Returns the subtraction of both polynomials as a PolynomialRingZq.

Examples

use qfall_math::integer_mod_q::PolynomialRingZq;
use qfall_math::integer_mod_q::ModulusPolynomialRingZq;
use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let modulus = ModulusPolynomialRingZq::from_str("4  1 0 0 1 mod 17").unwrap();
let poly = PolyOverZ::from_str("4  -1 0 1 1").unwrap();
let a = PolynomialRingZq::from((&poly, &modulus));
let b = PolyOverZ::from_str("4  2 0 3 1").unwrap();

let c: PolynomialRingZq = &b - &a;

type Output = PolynomialRingZq

The resulting type after applying the - operator.

impl Sub for &PolyOverZ

fn sub(self, other: Self) -> Self::Output

Implements the Sub trait for two PolyOverZ values. Sub is implemented for any combination of PolyOverZ and borrowed PolyOverZ.

Parameters:

• other: specifies the value to subtract from self

Returns the result of the subtraction of both polynomials as a PolyOverZ.

Examples

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let a: PolyOverZ = PolyOverZ::from_str("3  1 2 -3").unwrap();
let b: PolyOverZ = PolyOverZ::from_str("5  1 2 -3 0 8").unwrap();

let c: PolyOverZ = &a - &b;
let d: PolyOverZ = a - b;
let e: PolyOverZ = &c - d;
let f: PolyOverZ = c - &e;

type Output = PolyOverZ

The resulting type after applying the - operator.

impl SubAssign<&PolyOverZ> for PolyOverQ

fn sub_assign(&mut self, other: &PolyOverZ)

Documentation at PolyOverQ::sub_assign.

impl SubAssign<&PolyOverZ> for PolyOverZ

fn sub_assign(&mut self, other: &Self)

Computes the subtraction of self and other reusing the memory of self.

Parameters:

• other: specifies the polynomial to subtract from self

Returns the difference of both polynomials as a PolyOverZ.

Examples

use qfall_math::integer::PolyOverZ;
use std::str::FromStr;

let mut a = PolyOverZ::from_str("3  1 2 -3").unwrap();
let b = PolyOverZ::from_str("5  1 2 -3 0 8").unwrap();

a -= &b;
a -= b;

impl SubAssign<&PolyOverZ> for PolyOverZq

fn sub_assign(&mut self, other: &PolyOverZ)

Documentation at PolyOverZq::sub_assign.

impl SubAssign<&PolyOverZ> for PolynomialRingZq

fn sub_assign(&mut self, other: &PolyOverZ)

Documentation at PolynomialRingZq::sub_assign.

impl SubAssign<PolyOverZ> for PolyOverQ

fn sub_assign(&mut self, other: PolyOverZ)

Documentation at PolyOverQ::sub_assign.

impl SubAssign<PolyOverZ> for PolyOverZq

fn sub_assign(&mut self, other: PolyOverZ)

Documentation at PolyOverZq::sub_assign.

impl SubAssign<PolyOverZ> for PolynomialRingZq

fn sub_assign(&mut self, other: PolyOverZ)

Documentation at PolynomialRingZq::sub_assign.

impl SubAssign for PolyOverZ

fn sub_assign(&mut self, other: PolyOverZ)

Documentation at PolyOverZ::sub_assign.

impl Eq for PolyOverZ