Struct dashu_int::IBig

source ·

#[repr(transparent)]
pub struct IBig(_);

Expand description

An signed arbitrary precision integer.

This struct represents an arbitrarily large signed integer. Technically the size of the integer is bounded by the memory size, but it’s enough for practical use on modern devices.

Parsing and printing

There are four ways to create an IBig instance:

Use predifined constants (e.g. IBig::ZERO, IBig::NEG_ONE).
Use the literal macro ibig! defined in the dashu-macro crate.
Construct from a Sign and a UBig instance.
Parse from a string.

Parsing from either literal or string supports representation with base 2~36.

For printing, the IBig type supports common formatting traits (Display, Debug, LowerHex, etc.). Specially, printing huge number using Debug will conveniently omit the middle digits of the number, only print the least and most significant (decimal) digits.

// parsing
let a = IBig::from(408580953453092208335085386466371u128);
let b = IBig::from(-0x1231abcd4134i64);
let c = IBig::from_str_radix("a2a123bbb127779cccc123", 32)?;
let d = IBig::from_str_radix("-1231abcd4134", 16)?;
assert_eq!(a, c);
assert_eq!(b, d);

// printing
assert_eq!(format!("{}", IBig::from(12)), "12");
assert_eq!(format!("{:#X}", IBig::from(-0xabcd)), "-0xABCD");
if Word::BITS == 64 {
    // number of digits to display depends on the word size
    assert_eq!(
        format!("{:?}", IBig::NEG_ONE << 1000),
        "-1071508607186267320..4386837205668069376"
    );
}

Memory

The internal representation of IBig is exactly the same as UBig. It just use a small trick to store the sign bit without additional memory allocation. This means that IBig also has the small integer optimization and the niche bit to use with simple enums.

use core::mem::size_of;
assert_eq!(size_of::<IBig>(), size_of::<UBig>());
assert_eq!(size_of::<IBig>(), size_of::<Option<IBig>>());

Struct dashu_int::IBig

Implementations§

impl IBig

pub fn trailing_zeros(&self) -> Option<usize>

pub fn trailing_ones(&self) -> Option<usize>

impl IBig

pub fn to_f32(&self) -> Approximation<f32, Sign>

pub fn to_f64(&self) -> Approximation<f64, Sign>

impl IBig

pub fn in_radix(&self, radix: u32) -> InRadix<'_>

impl IBig

pub fn as_sign_words(&self) -> (Sign, &[Word])

pub const fn sign(&self) -> Sign

pub fn into_parts(self) -> (Sign, UBig)

pub fn from_parts(sign: Sign, magnitude: UBig) -> Self

pub const fn from_parts_const(sign: Sign, dword: DoubleWord) -> Self

pub const ZERO: Self = _

pub const ONE: Self = _

pub const NEG_ONE: Self = _

pub const fn is_zero(&self) -> bool

pub const fn is_one(&self) -> bool

impl IBig

pub fn ilog(&self, base: &UBig) -> usize

impl IBig

pub fn square(&self) -> UBig

pub fn cubic(&self) -> IBig

impl IBig

pub fn from_str_radix(src: &str, radix: u32) -> Result<IBig, ParseError>

pub fn from_str_with_radix_prefix(src: &str) -> Result<(IBig, u32), ParseError>

impl IBig

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

impl IBig

pub fn nth_root(&self, n: usize) -> IBig

impl IBig

pub const fn signum(&self) -> IBig

Trait Implementations§

impl Abs for &IBig

type Output = IBig

fn abs(self) -> IBig

impl Abs for IBig

type Output = IBig

fn abs(self) -> IBig

impl AbsCmp<IBig> for IBig

fn abs_cmp(&self, rhs: &Self) -> Ordering

impl AbsCmp<IBig> for UBig

fn abs_cmp(&self, rhs: &IBig) -> Ordering

impl AbsCmp<UBig> for IBig

fn abs_cmp(&self, rhs: &UBig) -> Ordering

impl AbsEq<IBig> for IBig

fn abs_eq(&self, rhs: &Self) -> bool

impl AbsEq<IBig> for UBig

fn abs_eq(&self, rhs: &IBig) -> bool

impl AbsEq<UBig> for IBig

fn abs_eq(&self, rhs: &UBig) -> bool

impl<'l, 'r> Add<&'r IBig> for &'l IBig

type Output = IBig

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

impl<'l, 'r> Add<&'r IBig> for &'l UBig

type Output = IBig

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

impl<'l, 'r> Add<&'r IBig> for &'l i128

type Output = IBig

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

impl<'l, 'r> Add<&'r IBig> for &'l i16

type Output = IBig

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

impl<'l, 'r> Add<&'r IBig> for &'l i32

type Output = IBig

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

impl<'l, 'r> Add<&'r IBig> for &'l i64

type Output = IBig

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

impl<'l, 'r> Add<&'r IBig> for &'l i8

type Output = IBig

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

impl<'l, 'r> Add<&'r IBig> for &'l isize

type Output = IBig

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

impl<'l, 'r> Add<&'r IBig> for &'l u128

type Output = IBig