Struct magnus::RBignum

source ·

pub struct RBignum(/* private fields */);

Expand description

A Value pointer to a RBignum struct, Ruby’s internal representation of large integers.

Implementations§

source §

impl RBignum

source

pub fn from_value(val: Value) -> Option<Self>

Return Some(RBignum) if val is a RBignum, None otherwise.

§Examples

use magnus::{eval, RBignum};

assert!(RBignum::from_value(eval("9223372036854775807").unwrap()).is_some());
// too small
assert!(RBignum::from_value(eval("0").unwrap()).is_none());
// not an int
assert!(RBignum::from_value(eval("1.23").unwrap()).is_none());

source

pub fn from_i64(n: i64) -> Result<Self, Fixnum>

Create a new RBignum from an i64.

Returns Ok(RBignum) if n is large enough to require a bignum, otherwise returns Err(Fixnum).

§Panics

Panics if called from a non-Ruby thread. See Ruby::bignum_from_i64 for the non-panicking version.

§Examples

use magnus::RBignum;

assert!(RBignum::from_i64(4611686018427387904).is_ok());
assert!(RBignum::from_i64(-4611686018427387905).is_ok());
// too small
assert!(RBignum::from_i64(0).is_err());

source

pub fn from_u64(n: u64) -> Result<Self, Fixnum>

Create a new RBignum from an u64.

Returns Ok(RBignum) if n is large enough to require a bignum, otherwise returns Err(Fixnum).

§Panics

Panics if called from a non-Ruby thread. See Ruby::bignum_from_u64 for the non-panicking version.

§Examples

use magnus::RBignum;

assert!(RBignum::from_u64(4611686018427387904).is_ok());
// too small
assert!(RBignum::from_u64(0).is_err());

source

pub fn to_i64(self) -> Result<i64, Error>

Convert self to an i64. Returns Err if self is out of range for i64.

§Examples

use magnus::{eval, RBignum};

assert_eq!(
    eval::<RBignum>("4611686018427387904")
        .unwrap()
        .to_i64()
        .unwrap(),
    4611686018427387904
);
assert_eq!(
    eval::<RBignum>("-4611686018427387905")
        .unwrap()
        .to_i64()
        .unwrap(),
    -4611686018427387905
);
assert!(eval::<RBignum>("9223372036854775808")
    .unwrap()
    .to_i64()
    .is_err());
assert!(eval::<RBignum>("-9223372036854775809")
    .unwrap()
    .to_i64()
    .is_err());

source

pub fn to_isize(self) -> Result<isize, Error>

Convert self to an isize. Returns Err if self is out of range for isize.

§Examples

use magnus::{eval, RBignum};

assert_eq!(
    eval::<RBignum>("4611686018427387904")
        .unwrap()
        .to_isize()
        .unwrap(),
    4611686018427387904
);
assert_eq!(
    eval::<RBignum>("-4611686018427387905")
        .unwrap()
        .to_isize()
        .unwrap(),
    -4611686018427387905
);

source

pub fn to_u64(self) -> Result<u64, Error>

Convert self to a u64. Returns Err if self is negative or out of range for u64.

§Examples

use magnus::{eval, RBignum};

assert_eq!(
    eval::<RBignum>("4611686018427387904")
        .unwrap()
        .to_u64()
        .unwrap(),
    4611686018427387904
);
assert!(eval::<RBignum>("18446744073709551616")
    .unwrap()
    .to_u64()
    .is_err());

source

pub fn to_usize(self) -> Result<usize, Error>

Convert self to a usize. Returns Err if self is negative or out of range for usize.

§Examples

use magnus::{eval, RBignum};

assert_eq!(
    eval::<RBignum>("4611686018427387904")
        .unwrap()
        .to_usize()
        .unwrap(),
    4611686018427387904
);
assert!(eval::<RBignum>("18446744073709551616")
    .unwrap()
    .to_usize()
    .is_err());

source

pub fn is_positive(self) -> bool

Check if self is positive.

§Examples

use magnus::RBignum;

let num = RBignum::from_u64(4611686018427387904).unwrap();
assert!(num.is_positive());

let num = RBignum::from_i64(-4611686018427387905).unwrap();
assert!(!num.is_positive());

source

pub fn is_negative(self) -> bool

Check if self is negative.

§Examples

use magnus::RBignum;

let num = RBignum::from_i64(-4611686018427387905).unwrap();
assert!(num.is_negative());

let num = RBignum::from_u64(4611686018427387904).unwrap();
assert!(!num.is_negative());