Struct Factorization 

pub struct Factorization { /* private fields */ }

Factorization represents any integer value as its factorization or partly factorization.

Attributes:

• factors: holds FLINT’s struct for a factorization of an integer value

Implicit Typecasting

Most of our functions take as input values of type Integer. These capture all types that can be turned into a Z value. The types are Z, Modulus, i8, i16,i32,i64,u8,u16,u32,u64 and the references of all of these types. These types are then implicitly casted to a Z before the desired action is performed.

Examples

use qfall_math::utils::Factorization;
use qfall_math::integer::Z;
use std::str::FromStr;
use core::fmt;

// instantiations
let a = Z::from(1200);
let b = Z::from(20);

let fac_1 = Factorization::from(&a);
let mut fac_2 = Factorization::from((&a, &b));

// refinement
fac_2.refine();

// to_string
assert_eq!("[(3, 1), (20, 3)]", &fac_2.to_string());

Implementations

impl Factorization

pub fn refine(&mut self)

Allows to refine a partial factorization of type Factorization to a more complete one whose bases are pairwise relatively prime. The bases of the factors are then in ascending order.

For factorization [(2, 2), (40, 1), (9, 2)] the refinement looks like this [(2, 5), (5, 1), (9, 2)].

Examples

use qfall_math::utils::Factorization;
use core::fmt;

let mut fac = Factorization::from((1200, 20));
fac.refine();

println!("{}", fac);

Trait Implementations

impl Debug for Factorization

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

Formats the value using the given formatter.

impl Default for Factorization

fn default() -> Self

Returns an instantiation of Factorization with 1 as the only factor.

Examples

use std::default::Default;
use qfall_math::utils::Factorization;
  
let fac = Factorization::default();

impl Display for Factorization

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

Allows to convert a factorization of type Factorization into a String.

Returns the factorization in form of a String. For factorization 2^3 * 5 * 7^2 the String looks like this [(2, 3), (5, 1), (7, 2)].

Examples

use qfall_math::utils::Factorization;
use core::fmt;

let mut fac = Factorization::from((1200, 20));
fac.refine();

println!("{}", fac);

impl Drop for Factorization

fn drop(&mut self)

Drops the given Factorization value and frees the allocated memory.

Examples

use qfall_math::utils::Factorization;
{
    let fac = Factorization::from((8, 3));
} // as fac's scope ends here, it get's dropped

use qfall_math::utils::Factorization;

let fac = Factorization::from((8, 3));
drop(fac); // explicitly drops fac's value

impl From<&Factorization> for Vec<(Z, u64)>

fn from(factors: &Factorization) -> Self

Convert a Factorization into a Vec<(Z, u64)>.

Parameters:

• factors: the Factorization we want as a Vec<(Z, u64)> object.

Returns a new Vec<(Z, u64)> with the factors from Factorization represented as tuples with bases as Z and exponents as u64 values.

Examples

use qfall_math::utils::Factorization;
use qfall_math::integer::Z;

let fac = Factorization::from(10);

let vec = Vec::<(Z, u64)>::from(&fac);

impl From<&Vec<(Z, u64)>> for Factorization

fn from(factors: &Vec<(Z, u64)>) -> Self

Convert a Vec<(Z, u64)> into a Factorization.

Note that the order and occurrences of the factors are not altered by this method and an empty vector results in a factorization of 1.

Parameters:

• factors: the Vec<(Z, u64)> we want as a Factorization object.

Returns a new Factorization with the factors from Vec<(Z, u64)>.

Examples

use qfall_math::utils::Factorization;
use qfall_math::integer::Z;

let vec: Vec<(Z, u64)>  = vec![(Z::from(3), 2), (Z::from(8), 2), (Z::from(4), 1)];
let fac = Factorization::from(&vec);

impl<Integer: Into<Z>> From<(Integer, Integer)> for Factorization

fn from(factors: (Integer, Integer)) -> Self

Convert two integers into a Factorization.

Note that the order and occurrences of the factors are not altered by this method.

Parameters:

• factors: a tuple with two integers we want in the Factorization object.

Returns a new Factorization with factors as the only factors.

Examples

use qfall_math::utils::Factorization;

let fac = Factorization::from((10, 5));

impl<Integer: Into<Z>> From<Integer> for Factorization

fn from(factor: Integer) -> Self

Convert an integer into a Factorization.

Parameters:

• factor: the integer we want as a Factorization object.

Returns a new Factorization with factor as the only factor.

Examples

use qfall_math::utils::Factorization;

let fac = Factorization::from(10);