Type Alias RColumn

pub type RColumn<T> = RArray<T, 1>;

Aliased Type

struct RColumn<T> {
    robj: Robj,
    _data: PhantomData<T>,
}

Fields

robj: Robj

Owning Robj (probably should be a Pin).

_data: PhantomData<T>

Data type of the n-array

Implementations

impl<T> RColumn<T>

where T: ToVectorValue, Robj: for<'a> AsTypedSlice<'a, T>,

pub fn new_column<F: FnMut(usize) -> T>(nrows: usize, f: F) -> Self

Make a new column type.

pub fn nrows(&self) -> usize

Get the number of rows.

impl<T, const NDIM: usize> RArray<T, NDIM>

where Robj: for<'a> AsTypedSlice<'a, T>,

pub fn from_parts(robj: Robj) -> Self

pub fn data(&self) -> &[T]

Returns a flat representation of the array in col-major.

pub fn data_mut(&mut self) -> &mut [T]

Returns a flat, mutable representation of the array in col-major.

pub fn ndim(&self) -> usize

Returns the number of dimensions.

pub fn dim(&self) -> Vec<usize>

Returns the dimensions of the array.

impl<T, const NDIM: usize> RArray<T, NDIM>

pub fn get_dimnames(&self) -> List

pub fn get_dim(&self) -> Vec<usize>

Get the dimension vector of the array.

Equivalent to dim() in R

pub fn set_names(&mut self, names: Strings)

Set the names of the elements of an array.

Equivalent to names<- in R

pub fn set_dimnames(&mut self, dimnames: List)

Set the dimension names of an array.

For RMatrix a list of length 2 is required, as that would entail column-names and row-names. If you only wish to set one, but not the other, then the unset element must be R NULL

Equivalent to dimnames<- in R

pub fn set_dim(&mut self, dim: Robj)

Set the dimensions of an array.

Equivalent to dim<-

impl<T, const NDIM: usize> RArray<T, NDIM>

where T: ToVectorValue, Robj: for<'a> AsTypedSlice<'a, T>,

pub fn new_array(dim: [usize; NDIM]) -> Self

Trait Implementations

impl<T> TryFrom<&Robj> for RColumn<T>

where Robj: for<'a> AsTypedSlice<'a, T>,

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<T> TryFrom<Robj> for RColumn<T>

where Robj: for<'a> AsTypedSlice<'a, T>,

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<T: Debug, const NDIM: usize> Debug for RArray<T, NDIM>

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

Formats the value using the given formatter.

impl<T, const NDIM: usize> Deref for RArray<T, NDIM>

type Target = Robj

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, const NDIM: usize> DerefMut for RArray<T, NDIM>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, const NDIM: usize> Index<[usize; NDIM]> for RArray<T, NDIM>

where Robj: for<'a> AsTypedSlice<'a, T>,

fn index(&self, index: [usize; NDIM]) -> &Self::Output

Zero-based indexing for DIM-dimensional arrays.

Panics if out of bounds. Zero-based indexing in row, column order.

Panics if out of bounds.

use extendr_api::prelude::*;
test! {
    let matrix = RArray::new_matrix(3, 2, |r, c| [
        [1., 2., 3.],
        [4., 5., 6.]][c][r]);
    assert_eq!(matrix[[0, 0]], 1.);
    assert_eq!(matrix[[1, 0]], 2.);
    assert_eq!(matrix[[2, 1]], 6.);

    let matrix = RArray::new_matrix3d(3, 2, 2, |r, c, d| (r + c + d) as f64);
    assert_eq!(matrix[[0, 0, 0]], 0.);
    assert_eq!(matrix[[1, 0, 1]], 2.);
    assert_eq!(matrix[[2, 1, 1]], 4.);
}

type Output = T

The returned type after indexing.

impl<T, const NDIM: usize> IndexMut<[usize; NDIM]> for RArray<T, NDIM>

where Robj: for<'a> AsTypedSlice<'a, T>,

fn index_mut(&mut self, index: [usize; NDIM]) -> &mut Self::Output

Zero-based mutable indexing for DIM-dimensional arrays.

Panics if out of bounds.

use extendr_api::prelude::*;
test! {
    let mut matrix = RMatrix::new_matrix(3, 2, |_, _| 0.);
    matrix[[0, 0]] = 1.;
    matrix[[1, 0]] = 2.;
    matrix[[2, 0]] = 3.;
    matrix[[0, 1]] = 4.;
    assert_eq!(matrix.as_real_slice().unwrap(), &[1., 2., 3., 4., 0., 0.]);

   let mut matrix = RMatrix3D::new_matrix3d(3, 2, 2, |_, _, _| 0.);
   matrix[[0, 0, 0]] = 1.;
   matrix[[1, 0, 0]] = 2.;
   matrix[[2, 0, 0]] = 3.;
   matrix[[0, 1, 0]] = 4.;
   assert_eq!(matrix.as_real_slice().unwrap(),
       &[1., 2., 3., 4., 0., 0., 0., 0., 0., 0., 0., 0.]);
}

impl<T, const NDIM: usize> Offset<[usize; NDIM]> for RArray<T, NDIM>

fn offset(&self, index: [usize; NDIM]) -> usize

Get the offset into the array for a given index.

impl<T: PartialEq, const NDIM: usize> PartialEq for RArray<T, NDIM>

fn eq(&self, other: &RArray<T, NDIM>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T, const NDIM: usize> StructuralPartialEq for RArray<T, NDIM>