Struct ArrayColumn 

pub struct ArrayColumn { /* private fields */ }

A column of arrays (pond-ts kind: 'array'): each row holds a list of numbers, text and true/false values, mixed freely, or is a gap. An empty list is a value, not a gap. Numbers must be finite.

let tags = ArrayColumn::from_options([
    Some(vec!["a".into(), "b".into()]),
    Some(vec![]),
    None,
    Some(vec![Scalar::from(1.0), true.into()]),
]);
let s = TimeSeries::new("s", vec![0, 1, 2, 3], vec![Column::optional("tags", tags)])?;
let tags = s.column("tags")?.arrays()?;
assert_eq!(tags.get(0), Some(&[Scalar::from("a"), "b".into()][..]));
assert_eq!(tags.get(1), Some(&[][..])); // empty, not a gap
assert_eq!(tags.get(2), None);

In Arrow an array column is a list: TimeSeries::to_arrow writes one when every element in the column is the same kind, and TimeSeries::from_arrow reads lists of numbers, text or true/false values. pond-ts has no Arrow form for arrays.

Implementations

impl ArrayColumn

pub fn from_options( values: impl IntoIterator<Item = Option<Vec<Scalar>>>, ) -> Self

Build from optional lists; None is a gap.

pub fn len(&self) -> usize

Number of values.

pub fn is_empty(&self) -> bool

true when there are no values.

pub fn get(&self, i: usize) -> Option<&[Scalar]>

The list at i, or None for a gap. Panics if i is out of range.

pub fn iter(&self) -> impl Iterator<Item = Option<&[Scalar]>> + '_

Iterate as Option<&[Scalar]>.

pub fn missing_count(&self) -> usize

Number of gaps.

Trait Implementations

impl Clone for ArrayColumn

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ArrayColumn

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

Formats the value using the given formatter.

impl From<ArrayColumn> for ColumnData

fn from(c: ArrayColumn) -> Self

Converts to this type from the input type.

impl PartialEq for ArrayColumn

Equal when the same rows are gaps and the lists hold the same elements bit for bit (so -0.0 and 0.0 differ, as in number columns).

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

Equality operator ==.

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

Inequality operator !=.