Struct numeric_float::n32f [] [src]

pub struct n32f(_);

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

Operations which would normally produce Not-a-Number instead result in f32.

Methods

impl n32f

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

unsafe fn from_float_unchecked(v: f32) -> n32f

fn into_float(self) -> f32

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

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

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

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

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

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

impl n32f

fn is_infinite(self) -> bool

impl n32f

fn is_finite(self) -> bool

impl n32f

fn is_normal(self) -> bool

impl n32f

fn classify(self) -> FpCategory

impl n32f

fn floor(self) -> n32f

impl n32f

fn ceil(self) -> n32f

impl n32f

fn round(self) -> n32f

impl n32f

fn trunc(self) -> n32f

impl n32f

fn fract(self) -> f32

impl n32f

fn abs(self) -> n32f

impl n32f

fn signum(self) -> n32f

impl n32f

fn is_sign_positive(self) -> bool

impl n32f

fn is_sign_negative(self) -> bool

impl n32f

fn recip(self) -> n32f

impl n32f

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

impl n32f

fn sqrt(self) -> f32

impl n32f

fn exp(self) -> n32f

impl n32f

fn exp2(self) -> n32f

impl n32f

fn ln(self) -> f32

impl n32f

fn log2(self) -> f32

impl n32f

fn log10(self) -> f32

impl n32f

fn cbrt(self) -> n32f

impl n32f

fn sin(self) -> f32

impl n32f

fn cos(self) -> f32

impl n32f

fn tan(self) -> f32

impl n32f

fn asin(self) -> f32

impl n32f

fn acos(self) -> f32

impl n32f

fn atan(self) -> f32

impl n32f

fn exp_m1(self) -> n32f

impl n32f

fn ln_1p(self) -> f32

impl n32f

fn sinh(self) -> f32

impl n32f

fn cosh(self) -> f32

impl n32f

fn tanh(self) -> f32

impl n32f

fn asinh(self) -> n32f

impl n32f

fn acosh(self) -> f32

impl n32f

fn atanh(self) -> f32

impl n32f

fn mul_add(self, a: n32f, b: n32f) -> f32

fn log(self, base: n32f) -> f32

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

Trait Implementations

impl Add<n32f> for n32f

type Output = f32

fn add(self, rhs: n32f) -> f32

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

type Output = f32

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

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

type Output = f32

fn add(self, rhs: n32f) -> f32

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

type Output = f32

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

impl Sub<n32f> for n32f

type Output = f32

fn sub(self, rhs: n32f) -> f32

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

type Output = f32

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

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

type Output = f32

fn sub(self, rhs: n32f) -> f32

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

type Output = f32

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

impl Mul<n32f> for n32f

type Output = f32

fn mul(self, rhs: n32f) -> f32

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

type Output = f32

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

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

type Output = f32

fn mul(self, rhs: n32f) -> f32

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

type Output = f32

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

impl Div<n32f> for n32f

type Output = f32

fn div(self, rhs: n32f) -> f32

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

type Output = f32

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

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

type Output = f32

fn div(self, rhs: n32f) -> f32

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

type Output = f32

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

impl Rem<n32f> for n32f

type Output = f32

fn rem(self, rhs: n32f) -> f32

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

type Output = f32

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

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

type Output = f32

fn rem(self, rhs: n32f) -> f32

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

type Output = f32

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

impl Neg for n32f

type Output = n32f

fn neg(self) -> n32f

impl<'a> Neg for &'a n32f

type Output = n32f

fn neg(self) -> n32f

impl Debug for n32f

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

impl Display for n32f

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

impl LowerExp for n32f

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

impl UpperExp for n32f

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

impl Numeric for n32f

type Float = f32

impl Eq for n32f

impl Into<f32> for n32f

fn into(self) -> f32

impl Ord for n32f

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

impl FromStr for n32f

type Err = ParseNumericError

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

impl Hash for n32f

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 n32f

type Err = Unrepresentable<f32>

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

impl TryInto<f32> for n32f

type Err = NoError

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

impl ValueFrom<f32> for n32f

type Err = Unrepresentable<f32>

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

impl ValueInto<f32> for n32f

type Err = NoError

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

impl Bounded for n32f

fn min_value() -> n32f

fn max_value() -> n32f

impl FromPrimitive for n32f

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

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

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

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

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

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

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

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

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

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

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

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

impl NumCast for n32f

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

impl ToPrimitive for n32f

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 Decodable for n32f

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

impl Encodable for n32f

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

impl Deserialize for n32f

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

impl Serialize for n32f

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

impl From<n32p> for n32f

fn from(v: n32p) -> Self

Derived Implementations

impl PartialOrd for n32f

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

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

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

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

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

impl PartialEq for n32f

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

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

impl Default for n32f

fn default() -> n32f

impl Clone for n32f

fn clone(&self) -> n32f

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

impl Copy for n32f