Struct extendr_api::scalar::Rfloat

#[repr(C)]
pub struct Rfloat(pub f64);

Rfloat is a wrapper for f64 in the context of an R’s integer vector.

Rfloat has a special NA value, obtained from R headers via R_NaReal.

Rfloat has the same footprint as an f64 value allowing us to use it in zero copy slices.

Tuple Fields

0: f64

Implementations

impl Rfloat

pub fn inner(&self) -> f64

Get underlying value.

pub fn is_nan(&self) -> bool

pub fn is_sign_positive(&self) -> bool

pub fn is_sign_negative(&self) -> bool

pub fn is_infinite(&self) -> bool

pub fn is_subnormal(&self) -> bool

pub fn abs(&self) -> Rfloat

pub fn sqrt(&self) -> Rfloat

Trait Implementations

impl Add<Rfloat> for &Rfloat

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

Add two Rfloat values or an option of f64.

type Output = Rfloat

The resulting type after applying the + operator.

impl Add<Rfloat> for Rfloat

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

Add two Rfloat values or an option of f64.

type Output = Rfloat

The resulting type after applying the + operator.

impl Add<Rfloat> for f64

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

Add two Rfloat values or an option of f64.

type Output = Rfloat

The resulting type after applying the + operator.

impl Add<f64> for Rfloat

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

Add two Rfloat values or an option of f64.

type Output = Rfloat

The resulting type after applying the + operator.

impl AddAssign<Rfloat> for &mut Rfloat

fn add_assign(&mut self, other: Rfloat)

Add two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl AddAssign<Rfloat> for Option<f64>

fn add_assign(&mut self, other: Rfloat)

Add two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl AddAssign<Rfloat> for Rfloat

fn add_assign(&mut self, other: Rfloat)

Add two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl AddAssign<f64> for &mut Rfloat

fn add_assign(&mut self, other: f64)

Add two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl AddAssign<f64> for Rfloat

fn add_assign(&mut self, other: f64)

Add two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl<'a> AsTypedSlice<'a, Rfloat> for Robjwhere Self: 'a,

fn as_typed_slice(&self) -> Option<&'a [Rfloat]>

fn as_typed_slice_mut(&mut self) -> Option<&'a mut [Rfloat]>

impl CanBeNA for Rfloat

use extendr_api::prelude::*;
test! {
    assert!((<Rfloat>::na()).is_na());
}

fn is_na(&self) -> bool

Return true is the is a NA value.

fn na() -> Self

Construct a NA.

impl Clone for Rfloat

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Rfloat

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

Debug format.

impl Default for Rfloat

use extendr_api::prelude::*;
test! {
    assert_eq!(<Rfloat>::default(), <f64>::default());
}

fn default() -> Self

Returns the “default value” for a type.

impl Div<Rfloat> for &Rfloat

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

Divide two Rfloat values or an option of f64.

type Output = Rfloat

The resulting type after applying the / operator.

impl Div<Rfloat> for Rfloat

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

Divide two Rfloat values or an option of f64.

type Output = Rfloat

The resulting type after applying the / operator.

impl Div<Rfloat> for f64

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

Divide two Rfloat values or an option of f64.

type Output = Rfloat

The resulting type after applying the / operator.

impl Div<f64> for Rfloat

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

Divide two Rfloat values or an option of f64.

type Output = Rfloat

The resulting type after applying the / operator.

impl DivAssign<Rfloat> for &mut Rfloat

fn div_assign(&mut self, other: Rfloat)

Divide two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl DivAssign<Rfloat> for Option<f64>

fn div_assign(&mut self, other: Rfloat)

Divide two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl DivAssign<Rfloat> for Rfloat

fn div_assign(&mut self, other: Rfloat)

Divide two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl DivAssign<f64> for &mut Rfloat

fn div_assign(&mut self, other: f64)

Divide two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl DivAssign<f64> for Rfloat

fn div_assign(&mut self, other: f64)

Divide two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl From<&f64> for Rfloat

fn from(v: &f64) -> Self

Converts to this type from the input type.

impl From<Option<&f64>> for Rfloat

fn from(v: Option<&f64>) -> Self

Converts to this type from the input type.

impl From<Option<f64>> for Rfloat

fn from(v: Option<f64>) -> Self

Converts to this type from the input type.

impl From<Rfloat> for Option<f64>

fn from(v: Rfloat) -> Self

Converts to this type from the input type.

impl From<Rfloat> for Rcplx

fn from(val: Rfloat) -> Self

Converts to this type from the input type.

impl From<Rfloat> for Robj

fn from(value: Rfloat) -> Self

Converts to this type from the input type.

impl From<f64> for Rfloat

fn from(v: f64) -> Self

Converts to this type from the input type.

impl FromIterator<Rfloat> for Doubles

fn from_iter<T: IntoIterator<Item = Rfloat>>(iter: T) -> Self

A more generalised iterator collector for small vectors. Generates a non-ALTREP vector.

impl Mul<Rfloat> for &Rfloat

fn mul(self, rhs: Rfloat) -> Self::Output

Multiply two Rfloat values or an option of f64.

type Output = Rfloat

The resulting type after applying the * operator.

impl Mul<Rfloat> for Rfloat

fn mul(self, rhs: Rfloat) -> Self::Output

Multiply two Rfloat values or an option of f64.

type Output = Rfloat

The resulting type after applying the * operator.

impl Mul<Rfloat> for f64

fn mul(self, rhs: Rfloat) -> Self::Output

Multiply two Rfloat values or an option of f64.

type Output = Rfloat

The resulting type after applying the * operator.

impl Mul<f64> for Rfloat

fn mul(self, rhs: f64) -> Self::Output

Multiply two Rfloat values or an option of f64.

type Output = Rfloat

The resulting type after applying the * operator.

impl MulAssign<Rfloat> for &mut Rfloat

fn mul_assign(&mut self, other: Rfloat)

Multiply two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl MulAssign<Rfloat> for Option<f64>

fn mul_assign(&mut self, other: Rfloat)

Multiply two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl MulAssign<Rfloat> for Rfloat

fn mul_assign(&mut self, other: Rfloat)

Multiply two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl MulAssign<f64> for &mut Rfloat

fn mul_assign(&mut self, other: f64)

Multiply two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl MulAssign<f64> for Rfloat

fn mul_assign(&mut self, other: f64)

Multiply two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl Neg for &Rfloat

fn neg(self) -> Self::Output

Negate a Rfloat value.

type Output = Rfloat

The resulting type after applying the - operator.

impl Neg for Rfloat

fn neg(self) -> Self::Output

Negate a Rfloat value.

type Output = Rfloat

The resulting type after applying the - operator.

impl PartialEq<Rfloat> for Rfloat

use extendr_api::prelude::*;
test! {
    assert!(<Rfloat>::default().eq(&<Rfloat>::default()));
    assert!(!<Rfloat>::na().eq(&<Rfloat>::na()));
}

fn eq(&self, other: &Rfloat) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<f64> for &Rfloat

use extendr_api::prelude::*;
test! {
    assert!(<Rfloat>::default().eq(&<f64>::default()));
}

fn eq(&self, other: &f64) -> bool

NA always fails.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<f64> for Rfloat

use extendr_api::prelude::*;
test! {
    assert!(<Rfloat>::default().eq(&<f64>::default()));
}

fn eq(&self, other: &f64) -> bool

NA always fails.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sub<Rfloat> for &Rfloat

fn sub(self, rhs: Rfloat) -> Self::Output

Subtract two Rfloat values or an option of f64.

type Output = Rfloat

The resulting type after applying the - operator.

impl Sub<Rfloat> for Rfloat

fn sub(self, rhs: Rfloat) -> Self::Output

Subtract two Rfloat values or an option of f64.

type Output = Rfloat

The resulting type after applying the - operator.

impl Sub<Rfloat> for f64

fn sub(self, rhs: Rfloat) -> Self::Output

Subtract two Rfloat values or an option of f64.

type Output = Rfloat

The resulting type after applying the - operator.

impl Sub<f64> for Rfloat

fn sub(self, rhs: f64) -> Self::Output

Subtract two Rfloat values or an option of f64.

type Output = Rfloat

The resulting type after applying the - operator.

impl SubAssign<Rfloat> for &mut Rfloat

fn sub_assign(&mut self, other: Rfloat)

Subtract two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl SubAssign<Rfloat> for Option<f64>

fn sub_assign(&mut self, other: Rfloat)

Subtract two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl SubAssign<Rfloat> for Rfloat

fn sub_assign(&mut self, other: Rfloat)

Subtract two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl SubAssign<f64> for &mut Rfloat

fn sub_assign(&mut self, other: f64)

Subtract two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl SubAssign<f64> for Rfloat

fn sub_assign(&mut self, other: f64)

Subtract two Rfloat values or an option of f64, modifying the left-hand side in place. Overflows to NA.

impl<'a> Sum<&'a Rfloat> for Rfloat

fn sum<I: Iterator<Item = &'a Rfloat>>(iter: I) -> Rfloat

Yields NA on overflow if NAs present.

use extendr_api::prelude::*;
use std::iter::Sum;
test! {
    let z =Rfloat::default();
    let x = (0..100).map(|_| &z);
    assert_eq!(<Rfloat as Sum<& Rfloat>>::sum(x), <Rfloat>::default());
}

impl Sum<Rfloat> for Rfloat

fn sum<I: Iterator<Item = Rfloat>>(iter: I) -> Rfloat

Yields NA on overflow if NAs present.

use extendr_api::prelude::*;
use std::iter::Sum;
test! {
    let x = (0..100).map(|x| Rfloat::default());
    assert_eq!(<Rfloat as Sum>::sum(x), <Rfloat>::default());
}

impl TryFrom<&Robj> for Rfloat

type Error = Error

The type returned in the event of a conversion error.

fn try_from(robj: &Robj) -> Result<Self>

Performs the conversion.

impl TryFrom<Robj> for Rfloat

type Error = Error

The type returned in the event of a conversion error.

fn try_from(robj: Robj) -> Result<Self>

Performs the conversion.

impl Copy for Rfloat