Struct rug::float::SmallFloat[−][src]

pub struct SmallFloat { /* fields omitted */ }

A small float that does not require any memory allocation.

This can be useful when you have a primitive number type but need a reference to a Float. The SmallFloat will have a precision according to the type of the primitive used to set its value.

i8, u8: the SmallFloat will have eight bits of precision.
i16, u16: the SmallFloat will have 16 bits of precision.
i32, u32: the SmallFloat will have 32 bits of precision.
i64, u64: the SmallFloat will have 64 bits of precision.
i128, u128: the SmallFloat will have 128 bits of precision.
isize, usize: the SmallFloat will have 32 or 64 bits of precision, depending on the platform.
f32: the SmallFloat will have 24 bits of precision.
f64: the SmallFloat will have 53 bits of precision.
Special: the SmallFloat will have the minimum possible precision.

The SmallFloat type can be coerced to a Float, as it implements Deref<Target = Float>.

Examples

use rug::{float::SmallFloat, Float};
// `a` requires a heap allocation, has 53-bit precision
let mut a = Float::with_val(53, 250);
// `b` can reside on the stack
let b = SmallFloat::from(-100f64);
a += &*b;
assert_eq!(a, 150);
// another computation:
a *= &*b;
assert_eq!(a, -15000);

Implementations

`impl SmallFloat`[src]

`pub const fn new() -> Self`[src]

Creates a SmallFloat with value 0 and the minimum possible precision.

Examples

use rug::float::SmallFloat;
let f = SmallFloat::new();
// Borrow f as if it were Float.
assert_eq!(*f, 0);

`pub unsafe fn as_nonreallocating_float(&mut self) -> &mut Float`[src]

Returns a mutable reference to a Float for simple operations that do not need to change the precision of the number.

Safety

It is undefined behaviour to modify the precision of the referenced Float or to swap it with another number.

Examples

use rug::float::SmallFloat;
let mut f = SmallFloat::from(1.0f32);
// addition does not change the precision
unsafe {
    *f.as_nonreallocating_float() += 2.0;
}
assert_eq!(*f, 3.0);

Methods from Deref<Target = Float>

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

Returns the precision.

Examples

use rug::Float;
let f = Float::new(53);
assert_eq!(f.prec(), 53);

`pub fn as_raw(&self) -> *const mpfr_t`[src]

Returns a pointer to the inner MPFR floating-point number.

The returned pointer will be valid for as long as self is valid.

Examples

use gmp_mpfr_sys::mpfr::{self, rnd_t};
use rug::Float;
let f = Float::with_val(53, -14.5);
let m_ptr = f.as_raw();
unsafe {
    let d = mpfr::get_d(m_ptr, rnd_t::RNDN);
    assert_eq!(d, -14.5);
}
// f is still valid
assert_eq!(f, -14.5);

`pub fn to_integer(&self) -> Option<Integer>`[src]

If the value is a finite number, converts it to an Integer rounding to the nearest.

This conversion can also be performed using

(&float).checked_as::<Integer>()
float.borrow().checked_as::<Integer>()

Examples

use rug::Float;
let f = Float::with_val(53, 13.7);
let i = match f.to_integer() {
    Some(i) => i,
    None => unreachable!(),
};
assert_eq!(i, 14);

`pub fn to_integer_round(&self, round: Round) -> Option<(Integer, Ordering)>`[src]

If the value is a finite number, converts it to an Integer applying the specified rounding method.

Examples

use core::cmp::Ordering;
use rug::{float::Round, Float};
let f = Float::with_val(53, 13.7);
let (i, dir) = match f.to_integer_round(Round::Down) {
    Some(i_dir) => i_dir,
    None => unreachable!(),
};
assert_eq!(i, 13);
assert_eq!(dir, Ordering::Less);

`pub fn to_integer_exp(&self) -> Option<(Integer, i32)>`[src]

If the value is a finite number, returns an Integer and exponent such that it is exactly equal to the integer multiplied by two raised to the power of the exponent.

Examples

use rug::{float::Special, Assign, Float};
let mut float = Float::with_val(16, 6.5);
// 6.5 in binary is 110.1
// Since the precision is 16 bits, this becomes
// 1101_0000_0000_0000 times two to the power of −12
let (int, exp) = float.to_integer_exp().unwrap();
assert_eq!(int, 0b1101_0000_0000_0000);
assert_eq!(exp, -13);

float.assign(0);
let (zero, _) = float.to_integer_exp().unwrap();
assert_eq!(zero, 0);

float.assign(Special::Infinity);
assert!(float.to_integer_exp().is_none());

`pub fn to_i32_saturating(&self) -> Option<i32>`[src]

Converts to an i32, rounding to the nearest.

If the value is too small or too large for the target type, the minimum or maximum value allowed is returned. If the value is a NaN, None is returned.

Examples

use core::{i32, u32};
use rug::{Assign, Float};
let mut f = Float::with_val(53, -13.7);
assert_eq!(f.to_i32_saturating(), Some(-14));
f.assign(-1e40);
assert_eq!(f.to_i32_saturating(), Some(i32::MIN));
f.assign(u32::MAX);
assert_eq!(f.to_i32_saturating(), Some(i32::MAX));

`pub fn to_i32_saturating_round(&self, round: Round) -> Option<i32>`[src]

Converts to an i32, applying the specified rounding method.

If the value is too small or too large for the target type, the minimum or maximum value allowed is returned. If the value is a NaN, None is returned.

Examples

use rug::{float::Round, Float};
let f = Float::with_val(53, -13.7);
assert_eq!(f.to_i32_saturating_round(Round::Up), Some(-13));

`pub fn to_u32_saturating(&self) -> Option<u32>`[src]

Converts to a u32, rounding to the nearest.

If the value is too small or too large for the target type, the minimum or maximum value allowed is returned. If the value is a NaN, None is returned.

Examples

use core::u32;
use rug::{Assign, Float};
let mut f = Float::with_val(53, 13.7);
assert_eq!(f.to_u32_saturating(), Some(14));
f.assign(-1);
assert_eq!(f.to_u32_saturating(), Some(0));
f.assign(1e40);
assert_eq!(f.to_u32_saturating(), Some(u32::MAX));

`pub fn to_u32_saturating_round(&self, round: Round) -> Option<u32>`[src]

Converts to a u32, applying the specified rounding method.

If the value is too small or too large for the target type, the minimum or maximum value allowed is returned. If the value is a NaN, None is returned.

Examples

use rug::{float::Round, Float};
let f = Float::with_val(53, 13.7);
assert_eq!(f.to_u32_saturating_round(Round::Down), Some(13));