Struct Denormal

Source

pub struct Denormal<const BASE: usize, B: BigInt<BASE>>(/* private fields */);

Expand description

Represents a denormalized number.

A denormalized number may not be in a consistent form, and may behave in unexpected ways while performing mathematical operations. It is typically best practice to normalize a denormalized number before using it in other contexts.

Sometimes, however, maintaining a number in a denormalized state is desirable for one reason or another; for example, performing normalization is a nonzero performance cost; you may save some computation by performing several consecutive operations in a row on a denormalized number before finally normalizing it at the end. Additionally, trailing zeros may be desirable to maintain, for data manipulation purposes.

use big_int::prelude::*;

let a: Tight<10> = 194.into();
let a: DenormalTight<10> = a.sub_inner::<Tight<10>, Tight<10>>(100.into());
assert_eq!(format!("{a}"), "094".to_string());
let a: Tight<10> = a.unwrap();
assert_eq!(format!("{a}"), "94".to_string());

Denormal

Struct Denormal Copy item path

Trait Implementations§

impl<const BASE: usize, B: BigInt<BASE>> Add for Denormal<BASE, B>

type Output = Denormal<BASE, B>

fn add(self, rhs: Self) -> Self::Output

impl<const BASE: usize, B: BigInt<BASE>> AddAssign for Denormal<BASE, B>

fn add_assign(&mut self, rhs: Self)

impl<const BASE: usize, B: BigInt<BASE>> BigInt<BASE> for Denormal<BASE, B>

type Builder = DenormalBuilder<BASE, <B as BigInt<BASE>>::Builder>

type Denormal = Denormal<BASE, B>

fn len(&self) -> usize

fn get_digit(&self, digit: usize) -> Option<Digit>

fn set_digit(&mut self, digit: usize, value: Digit)

fn zero() -> Self

fn sign(&self) -> Sign

fn with_sign(self, sign: Sign) -> Self

fn set_sign(&mut self, sign: Sign)

fn push_back(&mut self, digit: Digit)

unsafe fn push_front(&mut self, digit: Digit)

unsafe fn pop_back(&mut self) -> Option<Digit>

unsafe fn pop_front(&mut self) -> Option<Digit>

fn is_zero(&self) -> bool

fn normalized(self) -> Self

fn normalize(&mut self)

unsafe fn shl_assign_inner(&mut self, amount: usize)

fn shl_inner(self, amount: usize) -> Self::Denormal

unsafe fn shr_assign_inner(&mut self, amount: usize)

fn shr_inner(self, amount: usize) -> Self::Denormal

fn div_rem<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> Result<(OUT, OUT), BigIntError>

fn exp<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> Result<OUT, BigIntError>

fn log<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> Result<OUT, BigIntError>

fn root<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> Result<OUT, BigIntError>

fn convert<const TO: usize, OUT: BigInt<TO>>(self) -> OUT

fn get_back_inner(&self, index: usize) -> Option<Digit>

fn default_inner() -> Self

fn fmt_inner(&self, f: &mut Formatter<'_>) -> Result

fn partial_cmp_inner<RHS: BigInt<BASE>>(&self, other: &RHS) -> Option<Ordering>

fn cmp_inner<RHS: BigInt<BASE>>(&self, other: &RHS) -> Ordering

fn eq_inner<RHS: BigInt<BASE>>(&self, other: &RHS) -> bool

fn neg_inner(self) -> Self::Denormal

fn add_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> OUT::Denormal

unsafe fn add_assign_inner<RHS: BigInt<BASE>>(&mut self, rhs: RHS)

fn sub_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> OUT::Denormal

unsafe fn sub_assign_inner<RHS: BigInt<BASE>>(&mut self, rhs: RHS)

fn mul_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> OUT::Denormal

unsafe fn mul_assign_inner<RHS: BigInt<BASE>>(&mut self, rhs: RHS)

fn div_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> OUT::Denormal

unsafe fn div_assign_inner<RHS: BigInt<BASE>>(&mut self, rhs: RHS)

fn from_str_inner(s: &str) -> Result<Self::Denormal, BigIntError>

fn from_iter_inner<T: IntoIterator<Item = Digit>>(iter: T) -> Self::Denormal

fn from_u128_inner(value: u128) -> Self::Denormal

fn from_i128_inner(value: i128) -> Self::Denormal

fn into_u128_inner(self) -> u128

fn into_i128_inner(self) -> i128

fn div_rem_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> Result<(OUT::Denormal, OUT::Denormal), BigIntError>

fn exp_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> Result<OUT::Denormal, BigIntError>

fn log_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> Result<OUT::Denormal, BigIntError>

fn root_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> Result<OUT::Denormal, BigIntError>

fn is_even(&self) -> bool

fn iter<'a>(&'a self) -> BigIntIter<'a, BASE, Self> ⓘ

fn display(&self, alphabet: &str) -> Result<String, BigIntError>

fn parse(value: &str, alphabet: &str) -> Result<Self::Denormal, ParseError>

fn convert_inner<const TO: usize, OUT: BigInt<TO>>(self) -> OUT::Denormal

fn cmp_magnitude<RHS: BigInt<BASE>>(&self, rhs: &RHS) -> Ordering

const BITS_PER_DIGIT: usize = _

fn abs(self) -> Self

impl<const BASE: usize, B: Clone + BigInt<BASE>> Clone for Denormal<BASE, B>

fn clone(&self) -> Denormal<BASE, B>

fn clone_from(&mut self, source: &Self)

impl<const BASE: usize, B: Debug + BigInt<BASE>> Debug for Denormal<BASE, B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<const BASE: usize, B: BigInt<BASE>> Default for Denormal<BASE, B>

fn default() -> Self

impl<const BASE: usize, B: BigInt<BASE>> Display for Denormal<BASE, B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<const BASE: usize, B: BigInt<BASE>> Div for Denormal<BASE, B>

type Output = Denormal<BASE, B>

fn div(self, rhs: Self) -> Self::Output

impl<const BASE: usize, B: BigInt<BASE>> DivAssign for Denormal<BASE, B>

Struct Denormal