Struct numeric_float::n32p [] [src]

pub struct n32p(_);

A 32-bit floating point type which excludes Not-a-Number.

Operations which would normally produce Not-a-Number instead panic.

Methods

impl n32p

fn from_float(v: f32) -> Option<n32p>

unsafe fn from_float_unchecked(v: f32) -> n32p

fn into_float(self) -> f32

fn powf(self, n: n32p) -> n32p

fn max(self, other: n32p) -> n32p

fn min(self, other: n32p) -> n32p

fn abs_sub(self, other: n32p) -> n32p

fn hypot(self, other: n32p) -> n32p

fn atan2(self, other: n32p) -> n32p

impl n32p

fn is_infinite(self) -> bool

impl n32p

fn is_finite(self) -> bool

impl n32p

fn is_normal(self) -> bool

impl n32p

fn classify(self) -> FpCategory

impl n32p

fn floor(self) -> n32p

impl n32p

fn ceil(self) -> n32p

impl n32p

fn round(self) -> n32p

impl n32p

fn trunc(self) -> n32p

impl n32p

fn fract(self) -> n32p

fn try_fract(self) -> Option<n32p>

impl n32p

fn abs(self) -> n32p

impl n32p

fn signum(self) -> n32p

impl n32p

fn is_sign_positive(self) -> bool

impl n32p

fn is_sign_negative(self) -> bool

impl n32p

fn recip(self) -> n32p

impl n32p

fn powi(self, n: i32) -> n32p

impl n32p

fn sqrt(self) -> n32p

fn try_sqrt(self) -> Option<n32p>

impl n32p

fn exp(self) -> n32p

impl n32p

fn exp2(self) -> n32p

impl n32p

fn ln(self) -> n32p

fn try_ln(self) -> Option<n32p>

impl n32p

fn log2(self) -> n32p

fn try_log2(self) -> Option<n32p>

impl n32p

fn log10(self) -> n32p

fn try_log10(self) -> Option<n32p>

impl n32p

fn cbrt(self) -> n32p

impl n32p

fn sin(self) -> n32p

fn try_sin(self) -> Option<n32p>

impl n32p

fn cos(self) -> n32p

fn try_cos(self) -> Option<n32p>

impl n32p

fn tan(self) -> n32p

fn try_tan(self) -> Option<n32p>

impl n32p

fn asin(self) -> n32p

fn try_asin(self) -> Option<n32p>

impl n32p

fn acos(self) -> n32p

fn try_acos(self) -> Option<n32p>

impl n32p

fn atan(self) -> n32p

fn try_atan(self) -> Option<n32p>

impl n32p

fn exp_m1(self) -> n32p

impl n32p

fn ln_1p(self) -> n32p

fn try_ln_1p(self) -> Option<n32p>

impl n32p

fn sinh(self) -> n32p

fn try_sinh(self) -> Option<n32p>

impl n32p

fn cosh(self) -> n32p

fn try_cosh(self) -> Option<n32p>

impl n32p

fn tanh(self) -> n32p

fn try_tanh(self) -> Option<n32p>

impl n32p

fn asinh(self) -> n32p

impl n32p

fn acosh(self) -> n32p

fn try_acosh(self) -> Option<n32p>

impl n32p

fn atanh(self) -> n32p

fn try_atanh(self) -> Option<n32p>

impl n32p

fn mul_add(self, a: n32p, b: n32p) -> n32p

fn try_mul_add(self, a: n32p, b: n32p) -> Option<n32p>

fn log(self, base: n32p) -> n32p

fn try_log(self, base: n32p) -> Option<n32p>

fn sin_cos(self) -> (n32p, n32p)

fn try_sin_cos(self) -> Option<(n32p, n32p)>

Trait Implementations

impl Add<n32p> for n32p

type Output = n32p

fn add(self, rhs: n32p) -> n32p

impl<'a> Add<&'a n32p> for &'a n32p

type Output = n32p

fn add(self, rhs: &'a n32p) -> n32p

impl<'a> Add<n32p> for &'a n32p

type Output = n32p

fn add(self, rhs: n32p) -> n32p

impl<'a> Add<&'a n32p> for n32p

type Output = n32p

fn add(self, rhs: &'a n32p) -> n32p

impl Sub<n32p> for n32p

type Output = n32p

fn sub(self, rhs: n32p) -> n32p

impl<'a> Sub<&'a n32p> for &'a n32p

type Output = n32p

fn sub(self, rhs: &'a n32p) -> n32p

impl<'a> Sub<n32p> for &'a n32p

type Output = n32p

fn sub(self, rhs: n32p) -> n32p

impl<'a> Sub<&'a n32p> for n32p

type Output = n32p

fn sub(self, rhs: &'a n32p) -> n32p

impl Mul<n32p> for n32p

type Output = n32p

fn mul(self, rhs: n32p) -> n32p

impl<'a> Mul<&'a n32p> for &'a n32p

type Output = n32p

fn mul(self, rhs: &'a n32p) -> n32p

impl<'a> Mul<n32p> for &'a n32p

type Output = n32p

fn mul(self, rhs: n32p) -> n32p

impl<'a> Mul<&'a n32p> for n32p

type Output = n32p

fn mul(self, rhs: &'a n32p) -> n32p

impl Div<n32p> for n32p

type Output = n32p

fn div(self, rhs: n32p) -> n32p

impl<'a> Div<&'a n32p> for &'a n32p

type Output = n32p

fn div(self, rhs: &'a n32p) -> n32p

impl<'a> Div<n32p> for &'a n32p

type Output = n32p

fn div(self, rhs: n32p) -> n32p

impl<'a> Div<&'a n32p> for n32p

type Output = n32p

fn div(self, rhs: &'a n32p) -> n32p

impl Rem<n32p> for n32p

type Output = n32p

fn rem(self, rhs: n32p) -> n32p

impl<'a> Rem<&'a n32p> for &'a n32p

type Output = n32p

fn rem(self, rhs: &'a n32p) -> n32p

impl<'a> Rem<n32p> for &'a n32p

type Output = n32p

fn rem(self, rhs: n32p) -> n32p

impl<'a> Rem<&'a n32p> for n32p

type Output = n32p

fn rem(self, rhs: &'a n32p) -> n32p

impl Neg for n32p

type Output = n32p

fn neg(self) -> n32p

impl<'a> Neg for &'a n32p

type Output = n32p

fn neg(self) -> n32p

impl Debug for n32p

fn fmt(&self, fmt: &mut Formatter) -> Result

impl Display for n32p

fn fmt(&self, fmt: &mut Formatter) -> Result

impl LowerExp for n32p

fn fmt(&self, fmt: &mut Formatter) -> Result

impl UpperExp for n32p

fn fmt(&self, fmt: &mut Formatter) -> Result

impl Numeric for n32p

type Float = f32

impl Eq for n32p

impl Into<f32> for n32p

fn into(self) -> f32

impl Ord for n32p

fn cmp(&self, other: &n32p) -> Ordering

impl FromStr for n32p

type Err = ParseNumericError

fn from_str(src: &str) -> Result<n32p, Self::Err>

impl Hash for n32p

fn hash<H>(&self, state: &mut H) where H: Hasher

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

impl TryFrom<f32> for n32p

type Err = Unrepresentable<f32>

fn try_from(v: f32) -> Result<n32p, Self::Err>

impl TryInto<f32> for n32p

type Err = NoError

fn try_into(self) -> Result<f32, Self::Err>

impl ValueFrom<f32> for n32p

type Err = Unrepresentable<f32>

fn value_from(v: f32) -> Result<n32p, Self::Err>

impl ValueInto<f32> for n32p

type Err = NoError

fn value_into(self) -> Result<f32, Self::Err>

impl Bounded for n32p

fn min_value() -> n32p

fn max_value() -> n32p

impl Float for n32p

fn nan() -> n32p

fn infinity() -> n32p

fn neg_infinity() -> n32p

fn neg_zero() -> n32p

fn min_value() -> n32p

fn min_positive_value() -> n32p

fn max_value() -> n32p

fn is_nan(self) -> bool

fn is_infinite(self) -> bool

fn is_finite(self) -> bool

fn is_normal(self) -> bool

fn classify(self) -> FpCategory

fn floor(self) -> n32p

fn ceil(self) -> n32p

fn round(self) -> n32p

fn trunc(self) -> n32p

fn fract(self) -> n32p

fn abs(self) -> n32p

fn signum(self) -> n32p

fn is_sign_positive(self) -> bool

fn is_sign_negative(self) -> bool

fn mul_add(self, a: n32p, b: n32p) -> n32p

fn recip(self) -> n32p

fn powi(self, n: i32) -> n32p

fn powf(self, n: n32p) -> n32p

fn sqrt(self) -> n32p

fn exp(self) -> n32p

fn exp2(self) -> n32p

fn ln(self) -> n32p

fn log(self, base: n32p) -> n32p

fn log2(self) -> n32p

fn log10(self) -> n32p

fn max(self, other: n32p) -> n32p

fn min(self, other: n32p) -> n32p

fn abs_sub(self, other: n32p) -> n32p

fn cbrt(self) -> n32p

fn hypot(self, other: n32p) -> n32p

fn sin(self) -> n32p

fn cos(self) -> n32p

fn tan(self) -> n32p

fn asin(self) -> n32p

fn acos(self) -> n32p

fn atan(self) -> n32p

fn atan2(self, other: n32p) -> n32p

fn sin_cos(self) -> (n32p, n32p)

fn exp_m1(self) -> n32p

fn ln_1p(self) -> n32p

fn sinh(self) -> n32p

fn cosh(self) -> n32p

fn tanh(self) -> n32p

fn asinh(self) -> n32p

fn acosh(self) -> n32p

fn atanh(self) -> n32p

fn integer_decode(self) -> (u64, i16, i8)

impl FromPrimitive for n32p

fn from_i64(n: i64) -> Option<n32p>

fn from_u64(n: u64) -> Option<n32p>

fn from_isize(n: isize) -> Option<n32p>

fn from_i8(n: i8) -> Option<n32p>

fn from_i16(n: i16) -> Option<n32p>

fn from_i32(n: i32) -> Option<n32p>

fn from_usize(n: usize) -> Option<n32p>

fn from_u8(n: u8) -> Option<n32p>

fn from_u16(n: u16) -> Option<n32p>

fn from_u32(n: u32) -> Option<n32p>

fn from_f32(n: f32) -> Option<n32p>

fn from_f64(n: f64) -> Option<n32p>

impl Num for n32p

type FromStrRadixErr = ParseFloatError

fn from_str_radix(s: &str, radix: u32) -> Result<n32p, Self::FromStrRadixErr>

impl NumCast for n32p

fn from<T: ToPrimitive>(n: T) -> Option<n32p>

impl One for n32p

fn one() -> n32p

impl Signed for n32p

fn abs(&self) -> n32p

fn abs_sub(&self, other: &n32p) -> n32p

fn signum(&self) -> n32p

fn is_positive(&self) -> bool

fn is_negative(&self) -> bool

impl ToPrimitive for n32p

fn to_i64(&self) -> Option<i64>

fn to_u64(&self) -> Option<u64>

fn to_isize(&self) -> Option<isize>

fn to_i8(&self) -> Option<i8>

fn to_i16(&self) -> Option<i16>

fn to_i32(&self) -> Option<i32>

fn to_usize(&self) -> Option<usize>

fn to_u8(&self) -> Option<u8>

fn to_u16(&self) -> Option<u16>

fn to_u32(&self) -> Option<u32>

fn to_f32(&self) -> Option<f32>

fn to_f64(&self) -> Option<f64>

impl Zero for n32p

fn zero() -> n32p

fn is_zero(&self) -> bool

impl Decodable for n32p

fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error>

impl Encodable for n32p

fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error>

impl Deserialize for n32p

fn deserialize<D: Deserializer>(d: &mut D) -> Result<Self, D::Error>

impl Serialize for n32p

fn serialize<S: Serializer>(&self, s: &mut S) -> Result<(), S::Error>

impl From<n32f> for n32p

fn from(v: n32f) -> Self

Derived Implementations

impl PartialOrd for n32p

fn partial_cmp(&self, __arg_0: &n32p) -> Option<Ordering>

fn lt(&self, __arg_0: &n32p) -> bool

fn le(&self, __arg_0: &n32p) -> bool

fn gt(&self, __arg_0: &n32p) -> bool

fn ge(&self, __arg_0: &n32p) -> bool

impl PartialEq for n32p

fn eq(&self, __arg_0: &n32p) -> bool

fn ne(&self, __arg_0: &n32p) -> bool

impl Default for n32p

fn default() -> n32p

impl Clone for n32p

fn clone(&self) -> n32p

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

impl Copy for n32p