[−][src]Struct ramp::int::Int

pub struct Int { /* fields omitted */ }

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.

Implementations

`impl Int`[src]

`pub fn zero() -> Int`[src]

Creates the Int that represents zero.

`pub fn one() -> Int`[src]

Creates the Int that represents one.

`pub fn from_single_limb(limb: Limb) -> Int`[src]

Creates an Int from a single Limb

`pub fn sign(&self) -> i32`[src]

Returns the sign of this Int as either -1, 0 or 1 depending on whether it is negative, zero, or positive, respectively.

`pub fn abs(self) -> Int`[src]

Consumes this Int and returns its absolute value.

`pub fn to_single_limb(&self) -> Limb`[src]

Returns the least-significant Limb of this Int.

`pub fn abs_cmp(&self, other: &Int) -> Ordering`[src]

Compares the absolute value of this Int with the absolute value of another.

`pub fn abs_eq(&self, other: &Int) -> bool`[src]

Returns whether this Int has the same absolute value as another.

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

Hashes the value without including the sign.

This is useful for when the sign is handled elsewhere and making a copy just to change the sign is wasteful.

`pub fn shrink_to_fit(&mut self)`[src]

Shrinks the allocated data for this Int, attempting to remove excess capacity.

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

Creates a string containing the value of this Int in base base.

For bases greater than ten, if upper is true, upper-case letters are used; otherwise, lower-case letters are used.

Panics

Panics if base is less than two or greater than 36.

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

Similar to to_str_radix, writing to something that implements io::Write instead.

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

Creates a new Int from the given string in base base.

`pub fn divmod(&self, other: &Int) -> (Int, Int)`[src]

Divides this Int by other, returning the quotient q and the remainder r as (q, r).

This satisfies self = q * other + r, ensuring that q and r have the same sign.

Panics

Panics if other is zero.

`pub fn pow(&self, exp: usize) -> Int`[src]

Raises this Int to the power of exp. 0^0 = 1.

`pub fn pow_mod(&self, exp: &Int, modulus: &Int) -> Int`[src]

Raises this Int to the power exp, all modulo modulus. 0^0 mod m = 1 mod m

Panics

Panics if exp is negative or modulus is zero.

`pub fn square(&self) -> Int`[src]

Squares this Int.

`pub fn dsquare(self) -> Int`[src]

Consumes this Int and returns its square.

TODO: Is there a more idiomatic way of doing this?

`pub fn sqrt_rem(self) -> Option<(Int, Int)>`[src]

Computes the nearest square root s of this number and its remainder r as Some((s, r)), or None if this Int is negative.

s and r are both positive and satisfy self = s * s + r.

`pub fn negate(&mut self)`[src]

Negates this Int in place.

`pub fn is_even(&self) -> bool`[src]

Returns whether this Int is even.

`pub fn trailing_zeros(&self) -> u32`[src]

Returns the number of trailing zero bits for this Int, or zero if this Int is zero.

`pub fn count_ones(&self) -> usize`[src]

Returns the number of trailing one bits (i.e. the population count) for this Int

If this number is negative, it has infinitely many ones (in two's complement). Therefore, this method returns usize::MAX for negative numbers.

`pub fn bit_length(&self) -> u32`[src]

Returns the number of bits required to represent the absolute value of this Int, i.e., floor(log2(abs(self))) + 1.

Returns one if this number is zero.

`pub fn bit(&self, bit: u32) -> bool`[src]

Returns the value of the bitth bit in this Int, as if it were represented in two's complement.

`pub fn set_bit(&mut self, bit: u32, bit_val: bool)`[src]

Sets the bitth bit of this number to bit_val, treating negative numbers as if they're stored in two's complement.

`pub fn gcd(&self, other: &Int) -> Int`[src]

Computes the greates common divisor (GCD) of this Int and other.

The result is always positive.

`pub fn lcm(&self, other: &Int) -> Int`[src]

Computes the lowest common multiple (LCM) of this Int and other.

`pub fn to_f64(&self) -> f64`[src]

Converts this Int into an f64.

This is not an exact conversion, because this Int may be more precise than an f64 can account for.