Trait rug::integer::IntegerExt64
source · pub trait IntegerExt64: Sealed {
Show 56 methods
// Required methods
fn to_f32_exp64(&self) -> (f32, u64);
fn to_f64_exp64(&self) -> (f64, u64);
fn is_divisible_u64(&self, divisor: u64) -> bool;
fn is_divisible_2pow_64(&self, b: u64) -> bool;
fn is_congruent_u64(&self, c: u64, divisor: u64) -> bool;
fn is_congruent_2pow_64(&self, c: &Self, b: u64) -> bool;
fn significant_bits_64(&self) -> u64;
fn signed_bits_64(&self) -> u64;
fn count_ones_64(&self) -> Option<u64>;
fn count_zeros_64(&self) -> Option<u64>;
fn find_zero_64(&self, start: u64) -> Option<u64>;
fn find_one_64(&self, start: u64) -> Option<u64>;
fn set_bit_64(&mut self, index: u64, val: bool) -> &mut Self;
fn get_bit_64(&self, index: u64) -> bool;
fn toggle_bit_64(&mut self, index: u64) -> &mut Self;
fn hamming_dist_64(&self, other: &Self) -> Option<u64>;
fn keep_bits_64(self, n: u64) -> Self;
fn keep_bits_64_mut(&mut self, n: u64);
fn keep_bits_64_ref(&self, n: u64) -> KeepBitsIncomplete<'_>;
fn keep_signed_bits_64(self, n: u64) -> Self;
fn keep_signed_bits_64_mut(&mut self, n: u64);
fn keep_signed_bits_64_ref(&self, n: u64) -> KeepSignedBitsIncomplete<'_>;
fn mod_u64(&self, modulo: u64) -> u64;
fn div_exact_u64(self, divisor: u64) -> Self;
fn div_exact_u64_mut(&mut self, divisor: u64);
fn div_exact_u64_ref(&self, divisor: u64) -> DivExactUIncomplete<'_>;
fn u64_pow_u64(base: u64, exponent: u64) -> UPowUIncomplete;
fn i64_pow_u64(base: i64, exponent: u64) -> IPowUIncomplete;
fn root_64(self, n: u64) -> Self;
fn root_64_mut(&mut self, n: u64);
fn root_64_ref(&self, n: u64) -> RootIncomplete<'_>;
fn root_rem_64(self, remainder: Self, n: u64) -> (Self, Self);
fn root_rem_64_mut(&mut self, remainder: &mut Self, n: u64);
fn root_rem_64_ref(&self, n: u64) -> RootRemIncomplete<'_>;
fn gcd_u64(self, other: u64) -> Self;
fn gcd_u64_mut(&mut self, other: u64);
fn gcd_u64_ref(&self, other: u64) -> GcdUIncomplete<'_>;
fn lcm_u64(self, other: u64) -> Self;
fn lcm_u64_mut(&mut self, other: u64);
fn lcm_u64_ref(&self, other: u64) -> LcmUIncomplete<'_>;
fn remove_factor_64(self, factor: &Self) -> (Self, u64);
fn remove_factor_64_mut(&mut self, factor: &Self) -> u64;
fn remove_factor_64_ref<'a>(
&'a self,
factor: &'a Self
) -> RemoveFactorIncomplete<'a>;
fn factorial_64(n: u64) -> FactorialIncomplete;
fn factorial_2_64(n: u64) -> Factorial2Incomplete;
fn factorial_m_64(n: u64, m: u64) -> FactorialMIncomplete;
fn primorial_64(n: u64) -> PrimorialIncomplete;
fn binomial_64(self, k: u64) -> Self;
fn binomial_64_mut(&mut self, k: u64);
fn binomial_64_ref(&self, k: u64) -> BinomialIncomplete<'_>;
fn binomial_u64(n: u64, k: u64) -> BinomialUIncomplete;
fn fibonacci_64(n: u64) -> FibonacciIncomplete;
fn fibonacci_2_64(n: u64) -> Fibonacci2Incomplete;
fn lucas_64(n: u64) -> LucasIncomplete;
fn lucas_2_64(n: u64) -> Lucas2Incomplete;
fn random_bits_64(
bits: u64,
rng: &mut dyn MutRandState
) -> RandomBitsIncomplete<'_>;
}
Expand description
Integer
extension trait with 64-bit alternatives of some methods.
Various Integer
methods use 32-bit values for things like bit count or
exponents. On 64-bit platforms except Windows, alternatives of these methods
using 64-bit values are supported. This trait is only implemented on 64-bit
platforms except Windows.
This trait is sealed and is only implemented for Integer
.
Required Methods§
sourcefn to_f32_exp64(&self) -> (f32, u64)
fn to_f32_exp64(&self) -> (f32, u64)
Converts to an f32
and an exponent, rounding towards zero.
The returned f32
is in the range
0.5 ≤ x < 1. If the value is zero, (0.0, 0)
is returned.
This method is similar to to_f32_exp
but
returns the exponent as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let zero = Integer::new();
let (d0, exp0) = zero.to_f32_exp64();
assert_eq!((d0, exp0), (0.0, 0));
let fifteen = Integer::from(15);
let (d15, exp15) = fifteen.to_f32_exp64();
assert_eq!((d15, exp15), (15.0 / 16.0, 4));
sourcefn to_f64_exp64(&self) -> (f64, u64)
fn to_f64_exp64(&self) -> (f64, u64)
Converts to an f64
and an exponent, rounding towards zero.
The returned f64
is in the range
0.5 ≤ x < 1. If the value is zero, (0.0, 0)
is returned.
This method is similar to to_f64_exp
but
returns the exponent as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let zero = Integer::new();
let (d0, exp0) = zero.to_f64_exp64();
assert_eq!((d0, exp0), (0.0, 0));
let fifteen = Integer::from(15);
let (d15, exp15) = fifteen.to_f64_exp64();
assert_eq!((d15, exp15), (15.0 / 16.0, 4));
sourcefn is_divisible_u64(&self, divisor: u64) -> bool
fn is_divisible_u64(&self, divisor: u64) -> bool
Returns true
if the number is divisible by divisor
. Unlike other
division functions, divisor
can be zero.
This method is similar to is_divisible_u
but takes the divisor as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let i = Integer::from(230);
assert!(i.is_divisible_u64(23));
assert!(!i.is_divisible_u64(100));
assert!(!i.is_divisible_u64(0));
sourcefn is_divisible_2pow_64(&self, b: u64) -> bool
fn is_divisible_2pow_64(&self, b: u64) -> bool
Returns true
if the number is divisible by 2b.
This method is similar to
is_divisible_2pow
but takes b
as
u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let i = Integer::from(15 << 17);
assert!(i.is_divisible_2pow_64(16));
assert!(i.is_divisible_2pow_64(17));
assert!(!i.is_divisible_2pow_64(18));
sourcefn is_congruent_u64(&self, c: u64, divisor: u64) -> bool
fn is_congruent_u64(&self, c: u64, divisor: u64) -> bool
Returns true
if the number is congruent to c mod
divisor, that is, if there exists a q such that self
=
c + q × divisor. Unlike other division functions,
divisor
can be zero.
This method is similar to is_congruent_u
but takes c
and the divisor as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let n = Integer::from(105);
assert!(n.is_congruent_u64(3335, 10));
assert!(!n.is_congruent_u64(107, 10));
// n is congruent to itself if divisor is 0
assert!(n.is_congruent_u64(105, 0));
sourcefn is_congruent_2pow_64(&self, c: &Self, b: u64) -> bool
fn is_congruent_2pow_64(&self, c: &Self, b: u64) -> bool
Returns true
if the number is congruent to c mod
2b, that is, if there exists a q such that
self
= c + q × 2b.
This method is similar to
is_congruent_2pow
but takes b
as
u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let n = Integer::from(13 << 17 | 21);
assert!(n.is_congruent_2pow_64(&Integer::from(7 << 17 | 21), 17));
assert!(!n.is_congruent_2pow_64(&Integer::from(13 << 17 | 22), 17));
sourcefn significant_bits_64(&self) -> u64
fn significant_bits_64(&self) -> u64
Returns the number of bits required to represent the absolute value.
This method is similar to
significant_bits
but returns a u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
assert_eq!(Integer::from(0).significant_bits_64(), 0); // “”
assert_eq!(Integer::from(1).significant_bits_64(), 1); // “1”
assert_eq!(Integer::from(4).significant_bits_64(), 3); // “100”
assert_eq!(Integer::from(7).significant_bits_64(), 3); // “111”
assert_eq!(Integer::from(-1).significant_bits_64(), 1); // “1”
assert_eq!(Integer::from(-4).significant_bits_64(), 3); // “100”
assert_eq!(Integer::from(-7).significant_bits_64(), 3); // “111”
sourcefn signed_bits_64(&self) -> u64
fn signed_bits_64(&self) -> u64
Returns the number of bits required to represent the value using a two’s-complement representation.
For non-negative numbers, this method returns one more than
the significant_bits_64
method, since an extra zero is needed
before the most significant bit.
This method is similar to signed_bits
but
returns a u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
assert_eq!(Integer::from(-5).signed_bits_64(), 4); // “1011”
assert_eq!(Integer::from(-4).signed_bits_64(), 3); // “100”
assert_eq!(Integer::from(-3).signed_bits_64(), 3); // “101”
assert_eq!(Integer::from(-2).signed_bits_64(), 2); // “10”
assert_eq!(Integer::from(-1).signed_bits_64(), 1); // “1”
assert_eq!(Integer::from(0).signed_bits_64(), 1); // “0”
assert_eq!(Integer::from(1).signed_bits_64(), 2); // “01”
assert_eq!(Integer::from(2).signed_bits_64(), 3); // “010”
assert_eq!(Integer::from(3).signed_bits_64(), 3); // “011”
assert_eq!(Integer::from(4).signed_bits_64(), 4); // “0100”
sourcefn count_ones_64(&self) -> Option<u64>
fn count_ones_64(&self) -> Option<u64>
Returns the number of one bits if the value ≥ 0.
This method is similar to count_ones
but
returns a u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
assert_eq!(Integer::from(0).count_ones_64(), Some(0));
assert_eq!(Integer::from(15).count_ones_64(), Some(4));
assert_eq!(Integer::from(-1).count_ones_64(), None);
sourcefn count_zeros_64(&self) -> Option<u64>
fn count_zeros_64(&self) -> Option<u64>
Returns the number of zero bits if the value < 0.
This method is similar to count_zeros
but
returns a u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
assert_eq!(Integer::from(0).count_zeros_64(), None);
assert_eq!(Integer::from(1).count_zeros_64(), None);
assert_eq!(Integer::from(-1).count_zeros_64(), Some(0));
assert_eq!(Integer::from(-2).count_zeros_64(), Some(1));
assert_eq!(Integer::from(-7).count_zeros_64(), Some(2));
assert_eq!(Integer::from(-8).count_zeros_64(), Some(3));
sourcefn find_zero_64(&self, start: u64) -> Option<u64>
fn find_zero_64(&self, start: u64) -> Option<u64>
Returns the location of the first zero, starting at start
. If the bit
at location start
is zero, returns start
.
This method is similar to find_zero
but takes
start
as u64
and returns a u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
// -2 is ...11111110
assert_eq!(Integer::from(-2).find_zero_64(0), Some(0));
assert_eq!(Integer::from(-2).find_zero_64(1), None);
// 15 is ...00001111
assert_eq!(Integer::from(15).find_zero_64(0), Some(4));
assert_eq!(Integer::from(15).find_zero_64(20), Some(20));
sourcefn find_one_64(&self, start: u64) -> Option<u64>
fn find_one_64(&self, start: u64) -> Option<u64>
Returns the location of the first one, starting at start
. If the bit
at location start
is one, returns start
.
This method is similar to find_one
but takes
start
as u64
and returns a u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
// 1 is ...00000001
assert_eq!(Integer::from(1).find_one_64(0), Some(0));
assert_eq!(Integer::from(1).find_one_64(1), None);
// -16 is ...11110000
assert_eq!(Integer::from(-16).find_one_64(0), Some(4));
assert_eq!(Integer::from(-16).find_one_64(20), Some(20));
sourcefn set_bit_64(&mut self, index: u64, val: bool) -> &mut Self
fn set_bit_64(&mut self, index: u64, val: bool) -> &mut Self
Sets the bit at location index
to 1 if val
is true
or 0 if val
is false
.
This method is similar to set_bit
but takes
index
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::{Assign, Integer};
let mut i = Integer::from(-1);
assert_eq!(*i.set_bit_64(0, false), -2);
i.assign(0xff);
assert_eq!(*i.set_bit_64(11, true), 0x8ff);
sourcefn get_bit_64(&self, index: u64) -> bool
fn get_bit_64(&self, index: u64) -> bool
Returns true
if the bit at location index
is 1 or false
if the
bit is 0.
This method is similar to get_bit
but takes
index
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let i = Integer::from(0b100101);
assert!(i.get_bit_64(0));
assert!(!i.get_bit_64(1));
assert!(i.get_bit_64(5));
let neg = Integer::from(-1);
assert!(neg.get_bit_64(1000));
sourcefn toggle_bit_64(&mut self, index: u64) -> &mut Self
fn toggle_bit_64(&mut self, index: u64) -> &mut Self
Toggles the bit at location index
.
This method is similar to toggle_bit
but takes
index
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let mut i = Integer::from(0b100101);
i.toggle_bit_64(5);
assert_eq!(i, 0b101);
sourcefn hamming_dist_64(&self, other: &Self) -> Option<u64>
fn hamming_dist_64(&self, other: &Self) -> Option<u64>
Retuns the Hamming distance if the two numbers have the same sign.
The Hamming distance is the number of different bits.
This method is similar to hamming_dist
but
returns a u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let i = Integer::from(-1);
assert_eq!(Integer::from(0).hamming_dist_64(&i), None);
assert_eq!(Integer::from(-1).hamming_dist_64(&i), Some(0));
// -1 is ...11111111 and -13 is ...11110011
assert_eq!(Integer::from(-13).hamming_dist_64(&i), Some(2));
sourcefn keep_bits_64(self, n: u64) -> Self
fn keep_bits_64(self, n: u64) -> Self
sourcefn keep_bits_64_mut(&mut self, n: u64)
fn keep_bits_64_mut(&mut self, n: u64)
Keeps the n least significant bits only, producing a result that is greater or equal to 0.
This method is similar to keep_bits_mut
but
takes n
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let mut i = Integer::from(-1);
i.keep_bits_64_mut(8);
assert_eq!(i, 0xff);
sourcefn keep_bits_64_ref(&self, n: u64) -> KeepBitsIncomplete<'_>
fn keep_bits_64_ref(&self, n: u64) -> KeepBitsIncomplete<'_>
Keeps the n least significant bits only, producing a result that is greater or equal to 0.
The following are implemented with the returned incomplete-computation
value as Src
:
This method is similar to keep_bits_ref
but
takes n
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let i = Integer::from(-1);
let r = i.keep_bits_64_ref(8);
let eight_bits = Integer::from(r);
assert_eq!(eight_bits, 0xff);
sourcefn keep_signed_bits_64(self, n: u64) -> Self
fn keep_signed_bits_64(self, n: u64) -> Self
Keeps the n least significant bits only, producing a negative result if the nth least significant bit is one.
This method is similar to
keep_signed_bits
but takes n
as
u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let i = Integer::from(-1);
let i_keep_8 = i.keep_signed_bits_64(8);
assert_eq!(i_keep_8, -1);
let j = Integer::from(15 << 8 | 15);
let j_keep_8 = j.keep_signed_bits_64(8);
assert_eq!(j_keep_8, 15);
sourcefn keep_signed_bits_64_mut(&mut self, n: u64)
fn keep_signed_bits_64_mut(&mut self, n: u64)
Keeps the n least significant bits only, producing a negative result if the nth least significant bit is one.
This method is similar to
keep_signed_bits_mut
but takes n
as
u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let mut i = Integer::from(-1);
i.keep_signed_bits_64_mut(8);
assert_eq!(i, -1);
let mut j = Integer::from(15 << 8 | 15);
j.keep_signed_bits_64_mut(8);
assert_eq!(j, 15);
sourcefn keep_signed_bits_64_ref(&self, n: u64) -> KeepSignedBitsIncomplete<'_>
fn keep_signed_bits_64_ref(&self, n: u64) -> KeepSignedBitsIncomplete<'_>
Keeps the n least significant bits only, producing a negative result if the nth least significant bit is one.
The following are implemented with the returned
incomplete-computation value as Src
:
This method is similar to
keep_signed_bits_ref
but takes n
as
u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let i = Integer::from(-1);
let r = i.keep_signed_bits_64_ref(8);
let eight_bits = Integer::from(r);
assert_eq!(eight_bits, -1);
sourcefn mod_u64(&self, modulo: u64) -> u64
fn mod_u64(&self, modulo: u64) -> u64
Returns the modulo, or the remainder of Euclidean division by a u64
.
The result is always zero or positive.
This method is similar to mod_u
but takes modulo
as u64
and returns a u64
.
Panics
Panics if modulo
is zero.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let pos = Integer::from(23);
assert_eq!(pos.mod_u64(1), 0);
assert_eq!(pos.mod_u64(10), 3);
assert_eq!(pos.mod_u64(100), 23);
let neg = Integer::from(-23);
assert_eq!(neg.mod_u64(1), 0);
assert_eq!(neg.mod_u64(10), 7);
assert_eq!(neg.mod_u64(100), 77);
sourcefn div_exact_u64(self, divisor: u64) -> Self
fn div_exact_u64(self, divisor: u64) -> Self
Performs an exact division.
This is much faster than normal division, but produces correct results only when the division is exact.
This method is similar to div_exact_u
but
takes the divisor as u64
.
Panics
Panics if divisor
is zero.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let i = Integer::from(12345 * 54321);
let q = i.div_exact_u64(12345);
assert_eq!(q, 54321);
sourcefn div_exact_u64_mut(&mut self, divisor: u64)
fn div_exact_u64_mut(&mut self, divisor: u64)
Performs an exact division.
This is much faster than normal division, but produces correct results only when the division is exact.
This method is similar to div_exact_u_mut
but takes the divisor as u64
.
Panics
Panics if divisor
is zero.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let mut i = Integer::from(12345 * 54321);
i.div_exact_u64_mut(12345);
assert_eq!(i, 54321);
sourcefn div_exact_u64_ref(&self, divisor: u64) -> DivExactUIncomplete<'_>
fn div_exact_u64_ref(&self, divisor: u64) -> DivExactUIncomplete<'_>
Performs an exact division.
This is much faster than normal division, but produces correct results only when the division is exact.
The following are implemented with the returned incomplete-computation
value as Src
:
This method is similar to div_exact_u_ref
but takes the divisor as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let i = Integer::from(12345 * 54321);
let r = i.div_exact_u64_ref(12345);
assert_eq!(Integer::from(r), 54321);
sourcefn u64_pow_u64(base: u64, exponent: u64) -> UPowUIncomplete
fn u64_pow_u64(base: u64, exponent: u64) -> UPowUIncomplete
Raises base
to the power of exponent
.
The following are implemented with the returned incomplete-computation
value as Src
:
This method is similar to u_pow_u
but takes base
and exponent
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::{Complete, Integer};
assert_eq!(Integer::u64_pow_u64(13, 12).complete(), 13_u64.pow(12));
sourcefn i64_pow_u64(base: i64, exponent: u64) -> IPowUIncomplete
fn i64_pow_u64(base: i64, exponent: u64) -> IPowUIncomplete
Raises base
to the power of exponent
.
The following are implemented with the returned incomplete-computation
value as Src
:
This method is similar to i_pow_u
but takes base
as i64
and exponent
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::{Assign, Integer};
let mut ans = Integer::new();
ans.assign(Integer::i64_pow_u64(-13, 13));
assert_eq!(ans, (-13_i64).pow(13));
ans.assign(Integer::i64_pow_u64(13, 13));
assert_eq!(ans, (13_i64).pow(13));
sourcefn root_64(self, n: u64) -> Self
fn root_64(self, n: u64) -> Self
Computes the nth root and truncates the result.
This method is similar to root
but takes n
as
u64
.
Panics
Panics if n is zero or if n is even and the value is negative.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let i = Integer::from(1004);
let root = i.root_64(3);
assert_eq!(root, 10);
sourcefn root_64_mut(&mut self, n: u64)
fn root_64_mut(&mut self, n: u64)
Computes the nth root and truncates the result.
This method is similar to root_mut
but takes n
as u64
.
Panics
Panics if n is zero or if n is even and the value is negative.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let mut i = Integer::from(1004);
i.root_64_mut(3);
assert_eq!(i, 10);
sourcefn root_64_ref(&self, n: u64) -> RootIncomplete<'_>
fn root_64_ref(&self, n: u64) -> RootIncomplete<'_>
Computes the nth root and truncates the result.
The following are implemented with the returned incomplete-computation
value as Src
:
This method is similar to root_ref
but takes n
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let i = Integer::from(1004);
assert_eq!(Integer::from(i.root_64_ref(3)), 10);
sourcefn root_rem_64(self, remainder: Self, n: u64) -> (Self, Self)
fn root_rem_64(self, remainder: Self, n: u64) -> (Self, Self)
Computes the nth root and returns the truncated root and the remainder.
The remainder is the original number minus the truncated root raised to the power of n.
The initial value of remainder
is ignored.
This method is similar to root_rem
but takes n
as u64
.
Panics
Panics if n is zero or if n is even and the value is negative.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let i = Integer::from(1004);
let (root, rem) = i.root_rem_64(Integer::new(), 3);
assert_eq!(root, 10);
assert_eq!(rem, 4);
sourcefn root_rem_64_mut(&mut self, remainder: &mut Self, n: u64)
fn root_rem_64_mut(&mut self, remainder: &mut Self, n: u64)
Computes the nth root and returns the truncated root and the remainder.
The remainder is the original number minus the truncated root raised to the power of n.
The initial value of remainder
is ignored.
This method is similar to root_rem_mut
but
takes n
as u64
.
Panics
Panics if n is zero or if n is even and the value is negative.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let mut i = Integer::from(1004);
let mut rem = Integer::new();
i.root_rem_64_mut(&mut rem, 3);
assert_eq!(i, 10);
assert_eq!(rem, 4);
sourcefn root_rem_64_ref(&self, n: u64) -> RootRemIncomplete<'_>
fn root_rem_64_ref(&self, n: u64) -> RootRemIncomplete<'_>
Computes the nth root and returns the truncated root and the remainder.
The remainder is the original number minus the truncated root raised to the power of n.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Integer, Integer)
Assign<Src> for (&mut Integer, &mut Integer)
From<Src> for (Integer, Integer)
Complete<Completed = (Integer, Integer)> for Src
This method is similar to root_rem_ref
but
takes n
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::{Assign, Complete, Integer};
let i = Integer::from(1004);
let mut root = Integer::new();
let mut rem = Integer::new();
// 1004 = 10^3 + 5
(&mut root, &mut rem).assign(i.root_rem_64_ref(3));
assert_eq!(root, 10);
assert_eq!(rem, 4);
// 1004 = 3^6 + 275
let (other_root, other_rem) = i.root_rem_64_ref(6).complete();
assert_eq!(other_root, 3);
assert_eq!(other_rem, 275);
sourcefn gcd_u64(self, other: u64) -> Self
fn gcd_u64(self, other: u64) -> Self
Finds the greatest common divisor.
The result is always positive except when both inputs are zero.
This method is similar to gcd_u
but takes other
as
u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let i = Integer::new();
// gcd of 0, 0 is 0
let gcd1 = i.gcd_u64(0);
assert_eq!(gcd1, 0);
// gcd of 0, 10 is 10
let gcd2 = gcd1.gcd_u64(10);
assert_eq!(gcd2, 10);
// gcd of 10, 25 is 5
let gcd3 = gcd2.gcd_u64(25);
assert_eq!(gcd3, 5);
sourcefn gcd_u64_mut(&mut self, other: u64)
fn gcd_u64_mut(&mut self, other: u64)
Finds the greatest common divisor.
The result is always positive except when both inputs are zero.
This method is similar to gcd_u_mut
but takes
other
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let mut i = Integer::new();
// gcd of 0, 0 is 0
i.gcd_u64_mut(0);
assert_eq!(i, 0);
// gcd of 0, 10 is 10
i.gcd_u64_mut(10);
assert_eq!(i, 10);
// gcd of 10, 25 is 5
i.gcd_u64_mut(25);
assert_eq!(i, 5);
sourcefn gcd_u64_ref(&self, other: u64) -> GcdUIncomplete<'_>
fn gcd_u64_ref(&self, other: u64) -> GcdUIncomplete<'_>
Finds the greatest common divisor.
The result is always positive except when both inputs are zero.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Integer
From<Src> for Integer
From<Src> for Option<u64>
Complete<Completed = Integer> for Src
The implementation of From<Src> for Option<u64>
is
useful to obtain the result as a u64
if it fits. If
other
> 0 , the result always fits. If the result does not
fit, it is equal to the absolute value of self
.
This method is similar to gcd_u_ref
but takes
other
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let i = Integer::from(100);
let r = i.gcd_u64_ref(125);
// gcd of 100, 125 is 25
assert_eq!(Integer::from(r), 25);
let r = i.gcd_u64_ref(125);
assert_eq!(Option::<u64>::from(r), Some(25));
sourcefn lcm_u64(self, other: u64) -> Self
fn lcm_u64(self, other: u64) -> Self
Finds the least common multiple.
The result is always positive except when one or both inputs are zero.
This method is similar to lcm_u
but takes other
as
u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let i = Integer::from(10);
// lcm of 10, 25 is 50
let lcm1 = i.lcm_u64(25);
assert_eq!(lcm1, 50);
// lcm of 50, 0 is 0
let lcm2 = lcm1.lcm_u64(0);
assert_eq!(lcm2, 0);
sourcefn lcm_u64_mut(&mut self, other: u64)
fn lcm_u64_mut(&mut self, other: u64)
Finds the least common multiple.
The result is always positive except when one or both inputs are zero.
This method is similar to lcm_u_mut
but takes
other
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let mut i = Integer::from(10);
// lcm of 10, 25 is 50
i.lcm_u64_mut(25);
assert_eq!(i, 50);
// lcm of 50, 0 is 0
i.lcm_u64_mut(0);
assert_eq!(i, 0);
sourcefn lcm_u64_ref(&self, other: u64) -> LcmUIncomplete<'_>
fn lcm_u64_ref(&self, other: u64) -> LcmUIncomplete<'_>
Finds the least common multiple.
The result is always positive except when one or both inputs are zero.
The following are implemented with the returned incomplete-computation
value as Src
:
This method is similar to lcm_u_ref
but takes
other
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let i = Integer::from(100);
let r = i.lcm_u64_ref(125);
// lcm of 100, 125 is 500
assert_eq!(Integer::from(r), 500);
sourcefn remove_factor_64(self, factor: &Self) -> (Self, u64)
fn remove_factor_64(self, factor: &Self) -> (Self, u64)
Removes all occurrences of factor
, and returns the number of
occurrences removed.
This method is similar to remove_factor
but
returns the number of occurrences removed as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let mut i = Integer::from(Integer::u_pow_u(13, 50));
i *= 1000;
let (remove, count) = i.remove_factor_64(&Integer::from(13));
assert_eq!(remove, 1000);
assert_eq!(count, 50);
sourcefn remove_factor_64_mut(&mut self, factor: &Self) -> u64
fn remove_factor_64_mut(&mut self, factor: &Self) -> u64
Removes all occurrences of factor
, and returns the number of
occurrences removed.
This method is similar to
remove_factor_mut
but returns the number
of occurrences removed as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
let mut i = Integer::from(Integer::u_pow_u(13, 50));
i *= 1000;
let count = i.remove_factor_64_mut(&Integer::from(13));
assert_eq!(i, 1000);
assert_eq!(count, 50);
sourcefn remove_factor_64_ref<'a>(
&'a self,
factor: &'a Self
) -> RemoveFactorIncomplete<'a>
fn remove_factor_64_ref<'a>( &'a self, factor: &'a Self ) -> RemoveFactorIncomplete<'a>
Removes all occurrences of factor
, and counts the number of
occurrences removed.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Integer, u64)
Assign<Src> for (&mut Integer, &mut u64)
From<Src> for (Integer, u64)
Complete<Completed = (Integer, u64)> for Src
This method is similar to
remove_factor_ref
but returns the number
of occurrences removed as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::{Assign, Integer};
let mut i = Integer::from(Integer::u_pow_u(13, 50));
i *= 1000;
let factor = Integer::from(13);
let r = i.remove_factor_64_ref(&factor);
let (mut j, mut count) = (Integer::new(), 0);
(&mut j, &mut count).assign(r);
assert_eq!(count, 50);
assert_eq!(j, 1000);
sourcefn factorial_64(n: u64) -> FactorialIncomplete
fn factorial_64(n: u64) -> FactorialIncomplete
Computes the factorial of n.
The following are implemented with the returned incomplete-computation
value as Src
:
This method is similar to factorial
but takes
n
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::{Complete, Integer};
// 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1
assert_eq!(Integer::factorial_64(10).complete(), 3628800);
sourcefn factorial_2_64(n: u64) -> Factorial2Incomplete
fn factorial_2_64(n: u64) -> Factorial2Incomplete
Computes the double factorial of n.
The following are implemented with the returned incomplete-computation
value as Src
:
This method is similar to factorial_2
but
takes n
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::{Complete, Integer};
// 10 × 8 × 6 × 4 × 2
assert_eq!(Integer::factorial_2_64(10).complete(), 3840);
sourcefn factorial_m_64(n: u64, m: u64) -> FactorialMIncomplete
fn factorial_m_64(n: u64, m: u64) -> FactorialMIncomplete
Computes the m-multi factorial of n.
The following are implemented with the returned incomplete-computation
value as Src
:
This method is similar to factorial_m
but
takes n
and m
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::{Complete, Integer};
// 10 × 7 × 4 × 1
assert_eq!(Integer::factorial_m_64(10, 3).complete(), 280);
sourcefn primorial_64(n: u64) -> PrimorialIncomplete
fn primorial_64(n: u64) -> PrimorialIncomplete
Computes the primorial of n.
The following are implemented with the returned incomplete-computation
value as Src
:
This method is similar to primorial
but takes
n
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::{Complete, Integer};
// 7 × 5 × 3 × 2
assert_eq!(Integer::primorial_64(10).complete(), 210);
sourcefn binomial_64(self, k: u64) -> Self
fn binomial_64(self, k: u64) -> Self
sourcefn binomial_64_mut(&mut self, k: u64)
fn binomial_64_mut(&mut self, k: u64)
Computes the binomial coefficient over k.
This method is similar to binomial_mut
but
takes k
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
// 7 choose 2 is 21
let mut i = Integer::from(7);
i.binomial_64_mut(2);
assert_eq!(i, 21);
sourcefn binomial_64_ref(&self, k: u64) -> BinomialIncomplete<'_>
fn binomial_64_ref(&self, k: u64) -> BinomialIncomplete<'_>
Computes the binomial coefficient over k.
The following are implemented with the returned incomplete-computation
value as Src
:
This method is similar to binomial_ref
but
takes k
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::{Complete, Integer};
// 7 choose 2 is 21
let i = Integer::from(7);
assert_eq!(i.binomial_64_ref(2).complete(), 21);
sourcefn binomial_u64(n: u64, k: u64) -> BinomialUIncomplete
fn binomial_u64(n: u64, k: u64) -> BinomialUIncomplete
Computes the binomial coefficient n over k.
The following are implemented with the returned incomplete-computation
value as Src
:
This method is similar to binomial_u
but takes
n
and k
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::Integer;
// 7 choose 2 is 21
let b = Integer::binomial_u64(7, 2);
let i = Integer::from(b);
assert_eq!(i, 21);
sourcefn fibonacci_64(n: u64) -> FibonacciIncomplete
fn fibonacci_64(n: u64) -> FibonacciIncomplete
Computes the Fibonacci number.
The following are implemented with the returned incomplete-computation
value as Src
:
This function is meant for an isolated number. If a sequence of
Fibonacci numbers is required, the first two values of the sequence
should be computed with the fibonacci_2_64
method, then iterations should be used.
This method is similar to fibonacci
but takes
n
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::{Complete, Integer};
assert_eq!(Integer::fibonacci_64(12).complete(), 144);
sourcefn fibonacci_2_64(n: u64) -> Fibonacci2Incomplete
fn fibonacci_2_64(n: u64) -> Fibonacci2Incomplete
Computes a Fibonacci number, and the previous Fibonacci number.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Integer, Integer)
Assign<Src> for (&mut Integer, &mut Integer)
From<Src> for (Integer, Integer)
Complete<Completed = (Integer, Integer)> for Src
This function is meant to calculate isolated numbers. If a sequence of Fibonacci numbers is required, the first two values of the sequence should be computed with this function, then iterations should be used.
This method is similar to fibonacci_2
but
takes n
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::{Assign, Integer};
let f = Integer::fibonacci_2_64(12);
let mut pair = <(Integer, Integer)>::from(f);
assert_eq!(pair.0, 144);
assert_eq!(pair.1, 89);
// Fibonacci number F[-1] is 1
pair.assign(Integer::fibonacci_2_64(0));
assert_eq!(pair.0, 0);
assert_eq!(pair.1, 1);
sourcefn lucas_64(n: u64) -> LucasIncomplete
fn lucas_64(n: u64) -> LucasIncomplete
Computes the Lucas number.
The following are implemented with the returned incomplete-computation
value as Src
:
This function is meant for an isolated number. If a sequence of Lucas
numbers is required, the first two values of the sequence should be
computed with the lucas_2_64
method, then
iterations should be used.
This method is similar to lucas
but takes n
as
u64
.
Examples
use rug::integer::IntegerExt64;
use rug::{Complete, Integer};
assert_eq!(Integer::lucas_64(12).complete(), 322);
sourcefn lucas_2_64(n: u64) -> Lucas2Incomplete
fn lucas_2_64(n: u64) -> Lucas2Incomplete
Computes a Lucas number, and the previous Lucas number.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Integer, Integer)
Assign<Src> for (&mut Integer, &mut Integer)
From<Src> for (Integer, Integer)
Complete<Completed = (Integer, Integer)> for Src
This function is meant to calculate isolated numbers. If a sequence of Lucas numbers is required, the first two values of the sequence should be computed with this function, then iterations should be used.
This method is similar to lucas_2
but takes n
as
u64
.
Examples
use rug::integer::IntegerExt64;
use rug::{Assign, Integer};
let l = Integer::lucas_2_64(12);
let mut pair = <(Integer, Integer)>::from(l);
assert_eq!(pair.0, 322);
assert_eq!(pair.1, 199);
pair.assign(Integer::lucas_2_64(0));
assert_eq!(pair.0, 2);
assert_eq!(pair.1, -1);
sourcefn random_bits_64(
bits: u64,
rng: &mut dyn MutRandState
) -> RandomBitsIncomplete<'_>
fn random_bits_64( bits: u64, rng: &mut dyn MutRandState ) -> RandomBitsIncomplete<'_>
Generates a random number with a specified maximum number of bits.
The following are implemented with the returned incomplete-computation
value as Src
:
This method is similar to random_bits
but
takes bits
as u64
.
Examples
use rug::integer::IntegerExt64;
use rug::rand::RandState;
use rug::{Assign, Integer};
let mut rand = RandState::new();
let mut i = Integer::from(Integer::random_bits(0, &mut rand));
assert_eq!(i, 0);
i.assign(Integer::random_bits_64(80, &mut rand));
assert!(i.significant_bits() <= 80);