Struct ramp::int::Int

source · [−]

pub struct Int { /* private fields */ }

Expand description

An arbitrary-precision signed integer.

This type grows to the size it needs to in order to store the result of any operation.

Creation

An Int can be constructed in a number of ways:

Int::zero and Int::one construct a zero- and one-valued Int respectively.
Int::from will convert from any primitive integer type to an Int of the same value
```
let four = Int::from(4);
```
Int::from_str (or str::parse) will attempt to convert from a string to an Int
```
let i = Int::from_str("123456789").unwrap();
```

Int supports all the formatting traits, allowing it to be used just like a regular integer when used in format! and similar macros. Int also supports conversion to primitive integer types, truncating if the Int cannot fit into the target type. Conversion to primtive integers is done with the From trait:

let big_i   = Int::from(123456789);
let i = i32::from(&big_i);
assert_eq!(123456789, i);

Usage

Int has a number of operator overloads to make working with them as painless as possible.

The most basic usage is simply a + b or similar. Assuming a and b are of type Int, this operation will consume both operands, reusing the storage from one of them. If you do not wish your operands to be moved, one or both of them can be references: &a + &b works as well, but requires an entire new Int to be allocated for the return value.

There are also a overloads for a small number of primitive integer types, namely i32 and usize. While automatic type widening isn’t done in Rust in general, many operations are much more efficient when working with a single integer. This means you can do a + 1 knowing that it will be performed as efficiently as possible. Comparison with these integer types is also possible, allowing checks for small constant values to be done easily:

let big_i   = Int::from(123456789);
assert!(big_i == 123456789);

Semantics

Addition, subtraction and multiplication follow the expected rules for integers. Division of two integers, N / D is defined as producing two values: a quotient, Q, and a remainder, R, such that the following equation holds: N = Q*D + R. The division operator itself returns Q while the remainder/modulo operator returns R. The sign of R is the same as the sign of Q.

The “bit-shift” operations are defined as being multiplication and division by a power-of-two for shift-left and shift-right respectively. The sign of the number is unaffected.

The remaining bitwise operands act as if the numbers are stored in two’s complement format and as if the two inputs have the same number of bits.

Struct ramp::int::Int

Implementations

impl Int

pub fn zero() -> Int

pub fn one() -> Int

pub fn from_single_limb(limb: Limb) -> Int

pub fn sign(&self) -> i32

pub fn abs(self) -> Int

pub fn to_single_limb(&self) -> Limb

pub fn abs_cmp(&self, other: &Int) -> Ordering

pub fn abs_eq(&self, other: &Int) -> bool

pub fn abs_hash<H>(&self, state: &mut H) where H: Hasher,

pub fn shrink_to_fit(&mut self)

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

pub fn write_radix<W: Write>( &self, w: &mut W, base: u8, upper: bool) -> Result<()>

pub fn from_str_radix(src: &str, base: u8) -> Result<Int, ParseIntError>

pub fn divmod(&self, other: &Int) -> (Int, Int)

pub fn pow(&self, exp: usize) -> Int

pub fn pow_mod(&self, exp: &Int, modulus: &Int) -> Int

pub fn square(&self) -> Int

pub fn dsquare(self) -> Int

pub fn sqrt_rem(self) -> Option<(Int, Int)>

pub fn negate(&mut self)

pub fn is_even(&self) -> bool

pub fn trailing_zeros(&self) -> u32

pub fn count_ones(&self) -> usize

pub fn bit_length(&self) -> u32

pub fn bit(&self, bit: u32) -> bool

pub fn set_bit(&mut self, bit: u32, bit_val: bool)

pub fn gcd(&self, other: &Int) -> Int

pub fn lcm(&self, other: &Int) -> Int

pub fn to_f64(&self) -> f64

Trait Implementations

impl<'a> Add<&'a Int> for Int

type Output = Int

fn add(self, other: &'a Int) -> Int

impl<'a, 'b> Add<&'a Int> for &'b Int

type Output = Int

fn add(self, other: &'a Int) -> Int

impl<'a> Add<&'a Int> for i32

type Output = Int

fn add(self, other: &'a Int) -> Int

impl<'a> Add<&'a Int> for usize

type Output = Int

fn add(self, other: &'a Int) -> Int

impl<'a> Add<&'a Int> for BaseInt

type Output = Int

fn add(self, other: &'a Int) -> Int

impl<'a> Add<&'a Int> for Rational

type Output = Rational

fn add(self, other: &'a Int) -> Rational

impl<'a, 'b> Add<&'a Int> for &'b Rational

type Output = Rational

fn add(self, other: &'a Int) -> Rational

impl<'a> Add<&'a Rational> for Int

type Output = Rational

fn add(self, other: &'a Rational) -> Rational

impl<'a, 'b> Add<&'a Rational> for &'b Int

type Output = Rational

fn add(self, other: &'a Rational) -> Rational

impl<'a> Add<Int> for &'a Int

type Output = Int

fn add(self, other: Int) -> Int

impl Add<Int> for Int

type Output = Int

fn add(self, other: Int) -> Int

impl Add<Int> for i32

type Output = Int

fn add(self, other: Int) -> Int

impl Add<Int> for usize

type Output = Int

fn add(self, other: Int) -> Int

impl Add<Int> for BaseInt

type Output = Int

fn add(self, other: Int) -> Int

impl Add<Int> for Rational

type Output = Rational

fn add(self, other: Int) -> Rational

impl<'a> Add<Int> for &'a Rational

type Output = Rational

pub fn abs_hash<H>(&self, state: &mut H) where
H: Hasher,

pub fn write_radix<W: Write>(
&self,
w: &mut W,
base: u8,
upper: bool
) -> Result<()>

pub fn divmod(&self, other: &Int) -> (Int, Int )

pub fn sqrt_rem(self) -> Option<(Int, Int )>