Struct Integer

Source

pub struct Integer { /* private fields */ }

pub const fn as_ptr(&self) -> *const fmpz

Returns a pointer to the inner FLINT integer.

Source

pub fn as_mut_ptr(&mut self) -> *mut fmpz

Returns a mutable pointer to the inner FLINT integer.

Source

pub const unsafe fn from_raw(raw: fmpz) -> Integer

Create an Integer from an initialized FLINT integer.

§Safety

The function must not be used to create a constant Integer, though it can be used to create a static Integer. This is because constant values are copied on use, leading to undefined behavior when they are dropped.
The value must be initialized.
The fmpz::fmpz type can be considered as a kind of pointer, so there can be multiple copies of it. Since this function takes over ownership, no other copies of the passed value should exist.

Source

pub const fn into_raw(self) -> fmpz

The returned object should be freed to avoid memory leaks.

Source

pub fn to_str_radix(&self, base: u8) -> String

Convert the Integer to a string in base base.

use inertia_core::Integer;

let x = Integer::from(1024);
assert_eq!(x.to_str_radix(2), "10000000000")

Source

pub fn sizeinbase(&self, base: i32) -> usize

Determines the size of the absolute value of an Integer in base base in terms of number of digits. The base can be between 2 and 62, inclusive.

use inertia_core::Integer;

let z = Integer::from(1000001);
assert_eq!(8, z.sizeinbase(7));

Source

pub fn size(&self) -> i64

Returns the number of limbs required to store the absolute value of an Integer. Returns zero if the Integer is zero.

use inertia_core::Integer;

let z: Integer = "18446744073709551616".parse().unwrap();
assert_eq!(2, z.size());

Source

pub fn bits(&self) -> u64

Returns the number of bits required to store the absolute value of an Integer. Returns zero if the Integer is zero.

use inertia_core::Integer;

let x = Integer::from(16);
assert_eq!(x.bits(), 5);

Source

pub fn fits_si(&self) -> bool

Determine if the Integer fits in a signed long.

use inertia_core::Integer;

let z: Integer = "18446744073709551616".parse().unwrap();
assert_eq!(z.fits_si(), false);

Source

pub fn abs_fits_ui(&self) -> bool

Determine if the absolute value of an Integer fits in an unsigned long.

use inertia_core::Integer;

let z: Integer = "18446744073709551614".parse().unwrap();
assert_eq!(z.abs_fits_ui(), true);

Source

pub fn get_si(&self) -> Option<i64>

Return an Option containing the input as a signed long (libc::c_long) if possible.

use inertia_core::Integer;

let z = Integer::from(-1234);
assert_eq!(z.get_si().unwrap(), -1234);

Source

pub fn get_ui(&self) -> Option<u64>

Return an Option containing the input as an unsigned long (libc::c_ulong) if possible.

use inertia_core::Integer;

let z = Integer::from(-1234);
assert!(z.get_ui().is_none());

Source

pub fn get_ui_vector(&self) -> Vec<u64>

Return a vector A of unsigned longs such that the original Integer can be written as a[0] + a[1]*x + ... + a[n-1]*x^(n-1) where x = 2^FLINT_BITS.

use inertia_core::*;

let z = Integer::from(2).pow(65u8);
let v = z.get_ui_vector();
assert!(v == vec![0, 2]);

let mut t = Integer::default();
t.set_ui_vector(v);
assert_eq!(z, t);

let x: Integer = "18446744073709551616".parse().unwrap();
let v = x.get_ui_vector();
let mut t = Integer::default();
t.set_ui_vector(v);
assert_eq!(x, t);

Source

pub fn set_ui_vector(&mut self, vec: Vec<u64>)

Set self to the nonnegative Integer vec[0] + vec[1]*x + ... + vec[n-1]*x^(n-1) where x = 2^FLINT_BITS.

use inertia_core::*;

let mut z = Integer::default();
z.set_ui_vector(vec![0,2]);
assert_eq!(z, Integer::from(2).pow(65u8));

Source

pub fn is_even(&self) -> bool

Check if the Integer is even.

use inertia_core::Integer;

let z = Integer::from(102);
assert!(z.is_even());

Source

pub fn is_odd(&self) -> bool

Check if the Integer is odd.

use inertia_core::Integer;

let z = Integer::from(103);
assert!(z.is_odd());

Source

pub fn sign(&self) -> i32

Returns -1 if the Integer is negative, +1 if the Integer is positive, and 0 otherwise.

use inertia_core::Integer;

let z = Integer::from(-12);
assert_eq!(z.sign(), -1);

let z = Integer::from(0);
assert_eq!(z.sign(), 0);

let z = Integer::from(12);
assert_eq!(z.sign(), 1);

Source

pub fn abs(&self) -> Integer

Returns the absolute value of an Integer

use inertia_core::Integer;

let z = Integer::from(-99);
assert_eq!(z.abs(), Integer::from(99));

Source

pub fn abs_assign(&mut self)

Set the input to its absolute value.

use inertia_core::Integer;

let mut z = Integer::from(-99);
z.abs_assign();
assert_eq!(z, Integer::from(99));

Source

pub fn invmod<T>(&self, modulus: T) -> Option<Integer>
where T: AsRef<Integer>,

Attempt to invert self modulo modulus.

use inertia_core::Integer;

let z = Integer::from(4);
assert_eq!(z.invmod(Integer::from(7)).unwrap(), 2);

Source

pub fn is_prime(&self) -> bool

Returns true if self is a prime.

use inertia_core::Integer;

let a = Integer::from(3);
assert!(a.is_prime());

let b = Integer::from(6);
assert!(!b.is_prime());

Source

pub fn setbit(&mut self, bit_index: u64)

Sets the bit index bit_index of an Integer.

use inertia_core::*;

let mut z = Integer::from(1024);
z.setbit(0);
assert_eq!(1025, z);

Source

pub fn testbit(&self, bit_index: u64) -> bool

Test the bit index bit_index of an Integer. Return true if it is 1, false if it is zero.

use inertia_core::*;

let z = Integer::from(1025);
assert!(z.testbit(0));

Source

pub fn mul2_uiui<S>(&self, x: S, y: S) -> Integer
where S: Into<u64>,

Outputs self * x * y where x, y can be converted to unsigned longs.

use inertia_core::Integer;

let f = Integer::from(-1);
assert_eq!(f.mul2_uiui(10u32, 3u32), -30i32);

Source

pub fn mul2_uiui_assign<S>(&mut self, x: S, y: S)
where S: Into<u64>,

Set self to self * x * y where x, y can be converted to unsigned longs.

use inertia_core::Integer;

let mut f = Integer::from(-1);
f.mul2_uiui_assign(10u8, 3u8);
assert_eq!(f, -30);

Source

pub fn mul_2exp<S>(&self, exp: S) -> Integer
where S: Into<u64>,

Output self * 2^exp.

use inertia_core::Integer;

let g = Integer::from(2);
assert_eq!(g.mul_2exp(3u64), 16);

Source

pub fn mul_2exp_assign<S>(&mut self, exp: S)
where S: Into<u64>,

Compute self * 2^exp in place.

use inertia_core::Integer;

let mut g = Integer::from(2);
g.mul_2exp_assign(3u32);
assert_eq!(g, 16);

Source

pub fn addmul<T>(&self, x: T, y: T) -> Integer
where T: AsRef<Integer>,

Return self + (x * y).

use inertia_core::Integer;

let z = Integer::from(2);
assert_eq!(z.addmul(Integer::from(3), Integer::from(4)), 14);

Source

pub fn addmul_assign<T>(&mut self, x: T, y: T)
where T: AsRef<Integer>,

Compute self + (x * y) in place.

use inertia_core::Integer;

let mut z = Integer::from(2);
z.addmul_assign(Integer::from(3), Integer::from(4));
assert_eq!(z, 14);

Source

pub fn addmul_ui<S, T>(&self, x: T, y: S) -> Integer
where S: Into<u64>, T: AsRef<Integer>,

Return self + (x * y) where y can be converted to an unsigned long.

use inertia_core::*;

let z = Integer::from(2);
assert_eq!(z.addmul_ui(Integer::from(3), 4u32), 14);

Source

pub fn addmul_ui_assign<S, T>(&mut self, x: T, y: S)
where S: Into<u64>, T: AsRef<Integer>,

Compute self + (x * y) in place where y can be converted to an unsigned long.

use inertia_core::*;

let mut z = Integer::from(2);
z.addmul_ui_assign(Integer::from(3), 4u8);
assert_eq!(z, 14);

Source

pub fn cdiv<T>(&self, other: T) -> Integer
where T: AsRef<Integer>,

Return the quotient self/other rounded up towards infinity.

use inertia_core::*;

let x = Integer::from(11);
let y = Integer::from(2);
assert_eq!(x.cdiv(y), 6);

Source

pub fn cdiv_assign<T>(&mut self, other: T)
where T: AsRef<Integer>,

Compute the quotient self/other rounded up towards infinity and assign it to the input.

use inertia_core::*;

let mut x = Integer::from(11);
let y = Integer::from(2);
x.cdiv_assign(y);
assert_eq!(x, 6);

Source

pub fn fdiv<T>(&self, other: T) -> Integer
where T: AsRef<Integer>,

Return the quotient self/other rounded down towards negative infinity.

use inertia_core::*;

let x = Integer::from(11);
let y = Integer::from(2);
assert_eq!(x.fdiv(y), 5);

Source

pub fn fdiv_assign<T>(&mut self, other: T)
where T: AsRef<Integer>,

Compute the quotient self/other rounded down towards negative infinity and assign it to the input.

use inertia_core::*;

let mut x = Integer::from(11);
let y = Integer::from(2);
x.fdiv_assign(y);
assert_eq!(x, 5);

Source

pub fn tdiv<T>(&self, other: T) -> Integer
where T: AsRef<Integer>,

Return the quotient self/other rounded to the nearest integer.

use inertia_core::*;

let x = Integer::from(-19);
let y = Integer::from(10);
assert_eq!(x.tdiv(y), -1);

Source

pub fn tdiv_assign<T>(&mut self, other: T)
where T: AsRef<Integer>,

Compute the quotient self/other rounded to the nearest integer and assign it to the input.

use inertia_core::*;

let mut x = Integer::from(-19);
let y = Integer::from(10);
x.tdiv_assign(y);
assert_eq!(x, -1);

Converts this type into a shared reference of the (usually inferred) input type.

Returns a duplicate of the value. Read more

impl Hash for Integer

Source §

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher. Read more

1.3.0 · Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more

The resulting type after applying the - operator.

Source §

fn neg(self) -> Integer

Performs the unary - operation. Read more

Source §

impl Neg for Integer

Source §

type Output = Integer

The resulting type after applying the - operator.

Source §

fn neg(self) -> Integer

Performs the unary - operation. Read more

The resulting type after applying the ! operator.

Source §

fn not(self) -> Integer

Source §

fn cmp(&self, rhs: &Integer) -> Ordering

This method returns an Ordering between self and other. Read more

1.21.0 · Source§

fn max(self, other: Self) -> Self
where Self: Sized,

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

Tests less than or equal to (for self and other) and is used by the <= operator. Read more

1.0.0 · Source§

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

Tests greater than (for self and other) and is used by the > operator. Read more

1.0.0 · Source§

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

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more

Source §

This method returns an ordering between self and other values if one exists. Read more

1.0.0 · Source§

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

Tests less than (for self and other) and is used by the < operator. Read more

1.0.0 · Source§

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

Tests less than or equal to (for self and other) and is used by the <= operator. Read more

1.0.0 · Source§

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

Tests greater than (for self and other) and is used by the > operator. Read more

1.0.0 · Source§

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

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more

Source §

This method returns an ordering between self and other values if one exists. Read more

1.0.0 · Source§

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

Tests less than (for self and other) and is used by the < operator. Read more

1.0.0 · Source§

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

Tests less than or equal to (for self and other) and is used by the <= operator. Read more

1.0.0 · Source§

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

Tests greater than (for self and other) and is used by the > operator. Read more

1.0.0 · Source§

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

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more

Source §

This method returns an ordering between self and other values if one exists. Read more

1.0.0 · Source§

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

Tests less than (for self and other) and is used by the < operator. Read more

1.0.0 · Source§

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

Tests less than or equal to (for self and other) and is used by the <= operator. Read more

1.0.0 · Source§

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

Tests greater than (for self and other) and is used by the > operator. Read more

1.0.0 · Source§

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

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more

Source §

This method returns an ordering between self and other values if one exists. Read more

1.0.0 · Source§

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

Tests less than (for self and other) and is used by the < operator. Read more

1.0.0 · Source§

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

Tests less than or equal to (for self and other) and is used by the <= operator. Read more

1.0.0 · Source§

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

Tests greater than (for self and other) and is used by the > operator. Read more

1.0.0 · Source§

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

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more

Source §

This method returns an ordering between self and other values if one exists. Read more

1.0.0 · Source§

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

Tests less than (for self and other) and is used by the < operator. Read more

1.0.0 · Source§

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

Tests less than or equal to (for self and other) and is used by the <= operator. Read more

1.0.0 · Source§

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

Tests greater than (for self and other) and is used by the > operator. Read more

1.0.0 · Source§

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

Source §

impl Eq for Integer

impl<T, U> Into for T
where U: From<T>,

Source §

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source §

impl<T> ToOwned for T
where T: Clone,

Source §

type Owned = T

The resulting type after obtaining ownership.

Source §

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

Performs the conversion.

Source §

impl<T, U> TryInto for T
where U: TryFrom<T>,

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Implementations§

impl Integer

pub fn with_capacity(limbs: u64) -> Integer

pub fn zero() -> Integer

pub fn one() -> Integer

pub fn zero_assign(&mut self)

pub fn one_assign(&mut self)

pub fn is_zero(&self) -> bool

pub fn is_one(&self) -> bool

pub const fn as_ptr(&self) -> *const fmpz

pub fn as_mut_ptr(&mut self) -> *mut fmpz

pub const unsafe fn from_raw(raw: fmpz) -> Integer

§Safety

pub const fn into_raw(self) -> fmpz

pub fn to_str_radix(&self, base: u8) -> String

pub fn sizeinbase(&self, base: i32) -> usize

pub fn size(&self) -> i64

pub fn bits(&self) -> u64

pub fn fits_si(&self) -> bool

pub fn abs_fits_ui(&self) -> bool

pub fn get_si(&self) -> Option<i64>

pub fn get_ui(&self) -> Option<u64>

pub fn get_ui_vector(&self) -> Vec<u64>

pub fn set_ui_vector(&mut self, vec: Vec<u64>)

pub fn is_even(&self) -> bool

pub fn is_odd(&self) -> bool

pub fn sign(&self) -> i32

pub fn abs(&self) -> Integer

pub fn abs_assign(&mut self)

pub fn invmod<T>(&self, modulus: T) -> Option<Integer>where T: AsRef<Integer>,

pub fn is_prime(&self) -> bool

pub fn setbit(&mut self, bit_index: u64)

pub fn testbit(&self, bit_index: u64) -> bool

pub fn mul2_uiui<S>(&self, x: S, y: S) -> Integerwhere S: Into<u64>,

pub fn mul2_uiui_assign<S>(&mut self, x: S, y: S)where S: Into<u64>,

pub fn mul_2exp<S>(&self, exp: S) -> Integerwhere S: Into<u64>,

pub fn mul_2exp_assign<S>(&mut self, exp: S)where S: Into<u64>,

pub fn addmul<T>(&self, x: T, y: T) -> Integerwhere T: AsRef<Integer>,

pub fn addmul_assign<T>(&mut self, x: T, y: T)where T: AsRef<Integer>,

pub fn addmul_ui<S, T>(&self, x: T, y: S) -> Integerwhere S: Into<u64>, T: AsRef<Integer>,

pub fn addmul_ui_assign<S, T>(&mut self, x: T, y: S)where S: Into<u64>, T: AsRef<Integer>,

pub fn cdiv<T>(&self, other: T) -> Integerwhere T: AsRef<Integer>,

pub fn cdiv_assign<T>(&mut self, other: T)where T: AsRef<Integer>,

pub fn fdiv<T>(&self, other: T) -> Integerwhere T: AsRef<Integer>,

pub fn fdiv_assign<T>(&mut self, other: T)where T: AsRef<Integer>,

pub fn tdiv<T>(&self, other: T) -> Integerwhere T: AsRef<Integer>,

pub fn tdiv_assign<T>(&mut self, other: T)where T: AsRef<Integer>,

Trait Implementations§

impl Add<&FinFldElem> for &Integer

type Output = FinFldElem

fn add(self, rhs: &FinFldElem) -> FinFldElem

impl Add<&FinFldElem> for Integer

type Output = FinFldElem

fn add(self, rhs: &FinFldElem) -> FinFldElem

impl Add<&IntMod> for &Integer

type Output = IntMod

fn add(self, rhs: &IntMod) -> IntMod

impl Add<&IntMod> for Integer

type Output = IntMod

fn add(self, rhs: &IntMod) -> IntMod

impl Add<&IntModPoly> for &Integer

type Output = IntModPoly

fn add(self, rhs: &IntModPoly) -> IntModPoly

impl Add<&IntModPoly> for Integer

type Output = IntModPoly

fn add(self, rhs: &IntModPoly) -> IntModPoly

impl Add<&IntPoly> for &Integer

type Output = IntPoly

fn add(self, rhs: &IntPoly) -> IntPoly

impl Add<&IntPoly> for Integer

type Output = IntPoly

fn add(self, rhs: &IntPoly) -> IntPoly

impl Add<&Integer> for &FinFldElem

type Output = FinFldElem

fn add(self, rhs: &Integer) -> FinFldElem

impl Add<&Integer> for &IntMod

type Output = IntMod

fn add(self, rhs: &Integer) -> IntMod

impl Add<&Integer> for &IntModPoly

Struct Integer

pub fn invmod<T>(&self, modulus: T) -> Option<Integer>
where T: AsRef<Integer>,

pub fn mul2_uiui<S>(&self, x: S, y: S) -> Integer
where S: Into<u64>,

pub fn mul2_uiui_assign<S>(&mut self, x: S, y: S)
where S: Into<u64>,

pub fn mul_2exp<S>(&self, exp: S) -> Integer
where S: Into<u64>,

pub fn mul_2exp_assign<S>(&mut self, exp: S)
where S: Into<u64>,

pub fn addmul<T>(&self, x: T, y: T) -> Integer
where T: AsRef<Integer>,

pub fn addmul_assign<T>(&mut self, x: T, y: T)
where T: AsRef<Integer>,

pub fn addmul_ui<S, T>(&self, x: T, y: S) -> Integer
where S: Into<u64>, T: AsRef<Integer>,

pub fn addmul_ui_assign<S, T>(&mut self, x: T, y: S)
where S: Into<u64>, T: AsRef<Integer>,

pub fn cdiv<T>(&self, other: T) -> Integer
where T: AsRef<Integer>,

pub fn cdiv_assign<T>(&mut self, other: T)
where T: AsRef<Integer>,

pub fn fdiv<T>(&self, other: T) -> Integer
where T: AsRef<Integer>,

pub fn fdiv_assign<T>(&mut self, other: T)
where T: AsRef<Integer>,

pub fn tdiv<T>(&self, other: T) -> Integer
where T: AsRef<Integer>,

pub fn tdiv_assign<T>(&mut self, other: T)
where T: AsRef<Integer>,