Struct boostvoronoi::extended_exp_fpt::ExtendedExponentFpt[−][src]

pub struct ExtendedExponentFpt<F> where
    F: NumCast + Float + Display + Copy + Debug + Neg<Output = F>,  { /* fields omitted */ }

Floating point type wrapper. Allows to extend exponent boundaries to the integer type range. This class does not handle division by zero, subnormal numbers or NaNs. Ported from the class extended_exponent_fpt in voronoi_ctypes.hpp

Implementations

impl ExtendedExponentFpt<f64>[src]

pub fn new2(val: f64, exp: i32) -> Self[src]

Constructor with value and exponent as arguments. The value of this number is ‘val_’ * 2^ ‘exp_’


let a = ExtendedExponentFpt::<f64>::new2(1.0, 12);
approx::assert_ulps_eq!(a.d(), 4096.0);

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

Is positive method. IMPORTANT!!!!! in the c++ boost voronoi implementation zero values can’t be positive.


let aa:f64 = 0_f64;
let a = ExtendedExponentFpt::<f64>::from(aa);
assert_eq!(a.is_pos(), false);

let aa:f64 = -0_f64;
let a = ExtendedExponentFpt::<f64>::from(aa);
assert_eq!(a.is_pos(), false);

let aa:f64 = f64::MIN_POSITIVE;
let a = ExtendedExponentFpt::<f64>::from(aa);
assert_eq!(a.is_pos(), aa.is_sign_positive());

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

Is negative method. IMPORTANT!!!!! in the c++ boost voronoi implementation zero values can’t be negative.


let aa:f64 = 0_f64;
let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(aa);
assert_eq!(a.is_neg(), aa.is_sign_negative());

let aa:f64 = -0_f64;
let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(aa);
assert_eq!(a.is_neg(), false);

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

Is zero method.


let aa:f64 = 0_f64;
let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(aa);
assert_eq!(a.is_zero(), aa.is_zero());

let aa:f64 = -0_f64;
let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(aa);
assert_eq!(a.is_zero(), aa.is_zero());

let aa:f64 = f64::MIN_POSITIVE;
let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(aa);
assert_eq!(a.is_zero(), aa.is_zero());

let aa:f64 = -f64::MIN_POSITIVE;
let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(aa);
assert_eq!(a.is_zero(), aa.is_zero());

pub fn sqrt(&self) -> Self[src]

Square root method.


let aa:f64 = f64::MAX;
let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(aa);
approx::assert_ulps_eq!(a.d(), aa);
let a = a.sqrt();
approx::assert_ulps_eq!(a.d(), aa.sqrt());

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

A to-float operation.


let aa:f64 = 1000000000.0;
let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(aa);
approx::assert_ulps_eq!(a.d(), aa);
let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(-aa);
approx::assert_ulps_eq!(a.d(), -aa);

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

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

Trait Implementations

impl Add<ExtendedExponentFpt<f64>> for ExtendedExponentFpt<f64>[src]

type Output = Self

The resulting type after applying the + operator.

fn add(self, that: Self) -> Self[src]


let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(1_f64);
let b = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(2_f64);

approx::assert_ulps_eq!(a.d(), 1_f64);
approx::assert_ulps_eq!(b.d(), 2_f64);
let c = a + b;
approx::assert_ulps_eq!(c.d(), 3_f64);
let c = c + b;
approx::assert_ulps_eq!(c.d(), 5_f64);
let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(1000000000_f64);
let b = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(2000000000_f64);
approx::assert_ulps_eq!(a.d(), 1000000000_f64);
approx::assert_ulps_eq!(b.d(), 2000000000_f64);
let c = a + b;
approx::assert_ulps_eq!(c.d(), 3000000000_f64);

impl AddAssign<ExtendedExponentFpt<f64>> for ExtendedExponentFpt<f64>[src]

fn add_assign(&mut self, that: Self)[src]


let mut a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(1_f64);
let b = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(2_f64);

approx::assert_ulps_eq!(a.d(), 1_f64);
approx::assert_ulps_eq!(b.d(), 2_f64);
a += b;
approx::assert_ulps_eq!(a.d(), 3_f64);
a += b;
approx::assert_ulps_eq!(a.d(), 5_f64);
let mut a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(1000000000_f64);
let b = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(2000000000_f64);
approx::assert_ulps_eq!(a.d(), 1000000000_f64);
approx::assert_ulps_eq!(b.d(), 2000000000_f64);
a += b;
approx::assert_ulps_eq!(a.d(), 3000000000_f64);

impl<F: Clone> Clone for ExtendedExponentFpt<F> where
    F: NumCast + Float + Display + Copy + Debug + Neg<Output = F>, [src]

impl<F: Copy> Copy for ExtendedExponentFpt<F> where
    F: NumCast + Float + Display + Copy + Debug + Neg<Output = F>, [src]

impl Debug for ExtendedExponentFpt<f64>[src]

impl Div<ExtendedExponentFpt<f64>> for ExtendedExponentFpt<f64>[src]

type Output = Self

The resulting type after applying the / operator.

fn div(self, that: Self) -> Self[src]


let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(1_f64);
let b = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(2_f64);

approx::assert_ulps_eq!(a.d(), 1_f64);
approx::assert_ulps_eq!(b.d(), 2_f64);
let c = a / b;
approx::assert_ulps_eq!(c.d(), 1.0/2.0);
let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(2000000000_f64);
let b = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(-2000000000_f64);
approx::assert_ulps_eq!(a.d(),  2000000000_f64);
approx::assert_ulps_eq!(b.d(), -2000000000_f64);
let c = a / b;
approx::assert_ulps_eq!(c.d(), -1f64);

impl DivAssign<ExtendedExponentFpt<f64>> for ExtendedExponentFpt<f64>[src]

fn div_assign(&mut self, that: Self)[src]


let mut a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(1_f64);
let b = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(2_f64);

approx::assert_ulps_eq!(a.d(), 1_f64);
approx::assert_ulps_eq!(b.d(), 2_f64);
a /= b;
approx::assert_ulps_eq!(a.d(), 1.0/2.0);
let mut a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(2000000000_f64);
let b = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(-2000000000_f64);
approx::assert_ulps_eq!(a.d(),  2000000000_f64);
approx::assert_ulps_eq!(b.d(), -2000000000_f64);
a /= b;
approx::assert_ulps_eq!(a.d(), -1f64);

impl From<&'_ ExtendedInt> for ExtendedExponentFpt<f64>[src]

fn from(that: &ExtendedInt) -> Self[src]

converts to ExtendedExponentFpt::


let aa = 41232131332_f64;
let mut a = ExtendedInt::from(aa as i64);
let e = ExtendedExponentFpt::from(&a);
approx::assert_ulps_eq!(e.d(), aa);

impl From<f64> for ExtendedExponentFpt<f64>[src]

fn from(that: f64) -> ExtendedExponentFpt<f64>[src]

converts from f64 to ExtendedExponentFpt


let f1 = 345345345453_f64;
let e = ExtendedExponentFpt::from(f1);
let f2 = f64::from(&e);
approx::assert_ulps_eq!(f1, f2);

impl Mul<ExtendedExponentFpt<f64>> for ExtendedExponentFpt<f64>[src]

type Output = Self

The resulting type after applying the * operator.

fn mul(self, that: Self) -> Self[src]


let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(1_f64);
let b = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(2_f64);

approx::assert_ulps_eq!(a.d(), 1_f64);
approx::assert_ulps_eq!(b.d(), 2_f64);
let c = a * b;
approx::assert_ulps_eq!(c.d(), 2_f64);
let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(1000000000_f64);
let b = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(2000000000_f64);
approx::assert_ulps_eq!(a.d(), 1000000000_f64);
approx::assert_ulps_eq!(b.d(), 2000000000_f64);
let c = a * b;
approx::assert_ulps_eq!(c.d(), 1000000000_f64*2000000000_f64);

impl Mul<f64> for ExtendedExponentFpt<f64>[src]

type Output = Self

The resulting type after applying the * operator.

fn mul(self, that: f64) -> Self[src]


let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(7_f64);
let b = 2_f64;

approx::assert_ulps_eq!(a.d(), 7_f64);
approx::assert_ulps_eq!(b, 2_f64);
let c = a * b;
approx::assert_ulps_eq!(c.d(), 7_f64*2_f64);
let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(1234567890_f64);
let b = 2000000000_f64;
approx::assert_ulps_eq!(a.d(), 1234567890_f64);
approx::assert_ulps_eq!(b, 2000000000_f64);
let c = a * b;
approx::assert_ulps_eq!(c.d(), 1234567890_f64*2000000000_f64);

impl MulAssign<ExtendedExponentFpt<f64>> for ExtendedExponentFpt<f64>[src]

fn mul_assign(&mut self, that: Self)[src]


let mut a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(1_f64);
let b = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(2_f64);

approx::assert_ulps_eq!(a.d(), 1_f64);
approx::assert_ulps_eq!(b.d(), 2_f64);
a *= b;
approx::assert_ulps_eq!(a.d(), 2_f64);
let mut a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(1000000000_f64);
let     b = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(2000000000_f64);
approx::assert_ulps_eq!(a.d(), 1000000000_f64);
approx::assert_ulps_eq!(b.d(), 2000000000_f64);
a *= b;
approx::assert_ulps_eq!(a.d(), 1000000000_f64*2000000000_f64);

impl Neg for ExtendedExponentFpt<f64>[src]

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self[src]


let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(1_f64);

approx::assert_ulps_eq!(a.d(), 1_f64);
let c = -a;
approx::assert_ulps_eq!(c.d(), -1_f64);
let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(1000000000_f64);
approx::assert_ulps_eq!(a.d(), 1000000000_f64);
let c = -a;
approx::assert_ulps_eq!(c.d(), -1000000000_f64);

impl Sub<ExtendedExponentFpt<f64>> for ExtendedExponentFpt<f64>[src]

type Output = Self

The resulting type after applying the - operator.

fn sub(self, that: Self) -> Self[src]


let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(1_f64);
let b = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(-2_f64);

approx::assert_ulps_eq!(a.d(), 1_f64);
approx::assert_ulps_eq!(b.d(), -2_f64);
let c = a - b;
approx::assert_ulps_eq!(c.d(), 3_f64);
let c = c - b;
approx::assert_ulps_eq!(c.d(), 5_f64);
let a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(1000000000_f64);
let b = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(-3000000000_f64);
approx::assert_ulps_eq!(a.d(), 1000000000_f64);
approx::assert_ulps_eq!(b.d(), -3000000000_f64);
let c = a - b;
approx::assert_ulps_eq!(c.d(), 1000000000_f64-(-3000000000.0));

impl SubAssign<ExtendedExponentFpt<f64>> for ExtendedExponentFpt<f64>[src]

fn sub_assign(&mut self, that: Self)[src]


let mut a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(1_f64);
let b = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(-2_f64);

approx::assert_ulps_eq!(a.d(), 1_f64);
approx::assert_ulps_eq!(b.d(), -2_f64);
a -= b;
approx::assert_ulps_eq!(a.d(), 3_f64);
a -= b;
approx::assert_ulps_eq!(a.d(), 5_f64);
let mut a = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(1000000000_f64);
let b = extended_exp_fpt::ExtendedExponentFpt::<f64>::from(-3000000000_f64);
approx::assert_ulps_eq!(a.d(), 1000000000_f64);
approx::assert_ulps_eq!(b.d(), -3000000000_f64);
a -= b;
approx::assert_ulps_eq!(a.d(), 1000000000_f64-(-3000000000.0));

Auto Trait Implementations

impl<F> RefUnwindSafe for ExtendedExponentFpt<F> where
    F: RefUnwindSafe, 

impl<F> Send for ExtendedExponentFpt<F> where
    F: Send, 

impl<F> Sync for ExtendedExponentFpt<F> where
    F: Sync, 

impl<F> Unpin for ExtendedExponentFpt<F> where
    F: Unpin, 

impl<F> UnwindSafe for ExtendedExponentFpt<F> where
    F: UnwindSafe, 

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.