Struct tsxlib::timeseries::TimeSeries

pub struct TimeSeries<TDate: Serialize + Hash + Clone + Eq + Ord, T: Clone> {
    pub timeindicies: HashableIndex<TDate>,
    pub values: Vec<T>,
}

timeseries base struct of an index and a Vec of values

Fields

timeindicies: HashableIndex<TDate>

values: Vec<T>

Implementations

impl<TDate: Serialize + Hash + Clone + Eq + Ord, T: Clone> TimeSeries<TDate, T>

pub fn empty() -> TimeSeries<TDate, T>

create an empty series with Types TDate for the index and T for the value

Example

use tsxlib::timeseries::TimeSeries;
use chrono::NaiveDateTime;
 
let ts = TimeSeries::<NaiveDateTime,f64>::empty();
assert_eq!(ts.len(), 0);

pub fn from_vecs(
    timeindicies: Vec<TDate>,
    values: Vec<T>
) -> Result<TimeSeries<TDate, T>, Error>

Create a series by giving a vector of indicies and values

Example

use tsxlib::timeseries::TimeSeries;
 
let index = vec![1, 2, 3, 4, 5];
let vals = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let ts = TimeSeries::from_vecs(index, vals).unwrap();
assert_eq!(ts.len(), 5);

pub fn from_vecs_minimal_checks(
    timeindicies: HashableIndex<TDate>,
    values: Vec<T>
) -> Result<TimeSeries<TDate, T>, Error>

pub fn from_vecs_unchecked(
    timeindicies: HashableIndex<TDate>,
    values: Vec<T>
) -> TimeSeries<TDate, T>

pub fn from_tsdatapoints(
    tsdatapoints: Vec<TimeSeriesDataPoint<TDate, T>>
) -> Result<TimeSeries<TDate, T>, Error>

Create a new series from a set of TimeSeriesDataPoints

Example

use tsxlib::timeseries::TimeSeries;
use tsxlib::data_elements::TimeSeriesDataPoint;

let data = vec![TimeSeriesDataPoint::new(1, 1.0),
                TimeSeriesDataPoint::new(2, 2.0),
                TimeSeriesDataPoint::new(3, 3.0),
                TimeSeriesDataPoint::new(4, 4.0),
                TimeSeriesDataPoint::new(5, 5.0)];
let ts = TimeSeries::from_tsdatapoints(data);
assert_eq!(ts.unwrap().len(), 5);

pub fn from_tsdatapoints_unchecked(
    tsdatapoints: Vec<TimeSeriesDataPoint<TDate, T>>
) -> TimeSeries<TDate, T>

pub fn len(&self) -> usize

Get the length of a series

Example

use tsxlib::timeseries::TimeSeries;

let index = vec![1, 2, 3, 4, 5];
let data = vec![1.0, 2.0, 3.0, 4.0, 3.0];
let ts = TimeSeries::from_vecs(index, data).unwrap();
assert_eq!(ts.len(), 5);

pub fn is_empty(&self) -> bool

pub fn at_idx_of(&self, pos: usize) -> Option<TimeSeriesDataPoint<TDate, T>>

index into the series by position, returns None if not found

Example

use tsxlib::timeseries::TimeSeries;
use tsxlib::data_elements::TimeSeriesDataPoint;

let index = vec![1, 2, 3, 4, 5];
let data = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let ts = TimeSeries::from_vecs(index, data).unwrap();
assert_eq!(ts.at_idx_of(1), Some(TimeSeriesDataPoint::new(2, 2.0)));
assert_eq!(ts.at_idx_of(10), None);

pub fn at(&self, timestamp: TDate) -> Option<T>

Return element by its timestamp index or none

Example

use tsxlib::timeseries::TimeSeries;
use chrono::{NaiveDateTime};

let index = vec![NaiveDateTime::from_timestamp(1,0), NaiveDateTime::from_timestamp(5,0), NaiveDateTime::from_timestamp(10,0)];
let data = vec![1.0, 2.0, 3.0];
let ts = TimeSeries::from_vecs(index, data).unwrap();
assert_eq!(ts.at(NaiveDateTime::from_timestamp(0,0)), None);
assert_eq!(ts.at(NaiveDateTime::from_timestamp(1,0)), Some(1.0));
assert_eq!(ts.at(NaiveDateTime::from_timestamp(4,0)), None);
assert_eq!(ts.at(NaiveDateTime::from_timestamp(6,0)), None);
assert_eq!(ts.at(NaiveDateTime::from_timestamp(20,0)), None);

pub fn at_or_first_prior(&self, timestamp: TDate) -> Option<T>

Return element by its timestamp index or the first prior if out of range return none

Example

use tsxlib::timeseries::TimeSeries;
use chrono::{NaiveDateTime};

let index = vec![NaiveDateTime::from_timestamp(1,0), NaiveDateTime::from_timestamp(5,0), NaiveDateTime::from_timestamp(10,0)];
let data = vec![1.0, 2.0, 3.0];
let ts = TimeSeries::from_vecs(index, data).unwrap();
assert_eq!(ts.at_or_first_prior(NaiveDateTime::from_timestamp(0,0)), None);
assert_eq!(ts.at_or_first_prior(NaiveDateTime::from_timestamp(1,0)), Some(1.0));
assert_eq!(ts.at_or_first_prior(NaiveDateTime::from_timestamp(4,0)), Some(1.0));
assert_eq!(ts.at_or_first_prior(NaiveDateTime::from_timestamp(6,0)), Some(2.0));
assert_eq!(ts.at_or_first_prior(NaiveDateTime::from_timestamp(20,0)), None);

pub fn into_ordered_iter(&self) -> OrderedTimeSeriesIter<'_, TDate, T>

pub fn ordered_iter(&self) -> OrderedTimeSeriesRefIter<'_, TDate, T>

pub fn into_iter(&self) -> TimeSeriesIter<'_, TDate, T>

Convert the series to an iterator

Example

use tsxlib::timeseries::TimeSeries;

let values = vec![1.0, 2.0];
let index = (0..values.len()).map(|i| i as i64).collect();        
let ts = TimeSeries::from_vecs(index, values).unwrap();
assert_eq!(ts.into_iter().count(), 2);

pub fn iter(&self) -> TimeSeriesRefIter<'_, TDate, T>

Convert the series to an iterator where the TDate and T are references rather than values

Example

use tsxlib::timeseries::TimeSeries;

let values = vec![1.0, 2.0];
let index = (0..values.len()).map(|i| i as i64).collect();        
let ts = TimeSeries::from_vecs(index, values).unwrap();
assert_eq!(ts.iter().count(), 2);

pub fn between(&self, start: TDate, end: TDate) -> TimeSeries<TDate, T>

Get the values of a series between the start and end index (inclusive)

Example

use tsxlib::timeseries::TimeSeries;
use chrono::NaiveDateTime;

let values = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let index = (0..values.len()).map(|i| NaiveDateTime::from_timestamp(60 * i as i64,0)).collect();
let ts = TimeSeries::from_vecs(index, values).unwrap();
let tsres = ts.between(NaiveDateTime::from_timestamp(60 * 2 as i64,0), NaiveDateTime::from_timestamp(60 * 4 as i64,0));
assert_eq!(tsres.len(), 3);

pub fn resample_and_agg<TRes, TDuration>(
    &self,
    sample_size: TDuration,
    group_func: fn(_: &TDate, _: &TDuration) -> TDate,
    agg_func: fn(_: &Vec<TimeSeriesDataPoint<&TDate, &T>>) -> TRes
) -> TimeSeries<TDate, TRes> where
    TRes: Copy, 

Resample a Timeseries to the target duration, taking values according to the specified agg function

Example

use tsxlib::timeseries::TimeSeries;
use tsxlib::data_elements::TimeSeriesDataPoint;
use tsxlib::timeutils;
use chrono::{Duration,NaiveDateTime};
let data = vec![
    TimeSeriesDataPoint::new(NaiveDateTime::from_timestamp(60 * 1 as i64,0), 2.0),
    TimeSeriesDataPoint::new(NaiveDateTime::from_timestamp(60 * 2 as i64,0), 2.0),
    TimeSeriesDataPoint::new(NaiveDateTime::from_timestamp(60 * 3 as i64,0), 5.0),
    TimeSeriesDataPoint::new(NaiveDateTime::from_timestamp(60 * 16 as i64,0), 99.0),
];
let tsin = TimeSeries::from_tsdatapoints(data).unwrap();
 
let ts_rounded_up = tsin
    .resample_and_agg(Duration::minutes(15),
                     |dt,dur| timeutils::round_up_to_nearest_duration(dt, dur), 
                     |x| *x.last().unwrap().value);
let expected = vec![
    TimeSeriesDataPoint::new(NaiveDateTime::from_timestamp(60 * 15 as i64,0), 5.0),
    TimeSeriesDataPoint::new(NaiveDateTime::from_timestamp(60 * 30 as i64,0), 99.0),
];
let ts_expected = TimeSeries::from_tsdatapoints(expected).unwrap();
assert_eq!(ts_rounded_up, ts_expected);

pub fn shift(&self, shift: isize) -> ShiftedTimeSeriesIter<'_, TDate, T>

Shift a series by a given index, i.e. a "shift" of 1 will lag the series by 1 obs while a "shift" of 1 will nudge it fwd by 1

Example

use tsxlib::timeseries::TimeSeries;
use chrono::NaiveDateTime;

let values = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let index = (0..values.len()).map(|i| NaiveDateTime::from_timestamp(60 * i as i64,0)).collect();
let ts = TimeSeries::from_vecs(index, values).unwrap();
let tsres = ts.between(NaiveDateTime::from_timestamp(60 * 2 as i64,0), NaiveDateTime::from_timestamp(60 * 4 as i64,0));
assert_eq!(tsres.len(), 3);

pub fn apply_rolling<TRes>(
    &self,
    window_size: usize,
    transform_func: fn(_: &Vec<T>) -> TRes
) -> RollingTimeSeriesIter<'_, TDate, T, TRes> where
    TRes: Clone, 

pub fn apply_updating_rolling<TRes>(
    &self,
    window_size: usize,
    update_func: fn(_: Option<TRes>, _: &T) -> Option<TRes>,
    decrement_func: fn(_: Option<TRes>, _: &T) -> Option<TRes>
) -> RollingTimeSeriesIterWithUpdate<'_, TDate, T, TRes> where
    TRes: Clone, 

pub fn map<TRes>(&self, func: fn(_: &T) -> TRes) -> TimeSeries<TDate, TRes> where
    TRes: Clone + Default, 

Map the desired UDF over elements of a series

Example

use tsxlib::timeseries::TimeSeries;
use chrono::NaiveDateTime;

let values = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let index = (0..values.len()).map(|i| NaiveDateTime::from_timestamp(60 * i as i64,0)).collect();
let ts = TimeSeries::from_vecs(index, values).unwrap();
let result = ts.map(|x| x * 2.0);
assert_eq!(result.len(), 5);

pub fn map_with_date<TRes>(
    &self,
    func: fn(_: &TDate, _: &T) -> TRes
) -> TimeSeries<TDate, TRes> where
    TRes: Clone + Default, 

Map the desired UDF over elements of a series, keeping track of the date in addition to the value

Example

use tsxlib::timeseries::TimeSeries;
use chrono::NaiveDateTime;

let values = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let index = (0..values.len()).map(|i| NaiveDateTime::from_timestamp(60 * i as i64,0)).collect();
let ts = TimeSeries::from_vecs(index, values).unwrap();
let result = ts.map_with_date(|_dt,x| x * 2.0);
assert_eq!(result.len(), 5);

pub fn skip_apply<TRes>(
    &self,
    skip_span: usize,
    transform_func: fn(_: &T, _: &T) -> TRes
) -> SkipApplyTimeSeriesIter<'_, TDate, T, TRes> where
    TRes: Copy, 

Apply a function that calculates its resultant value based on the begining and end of the specified skip span

Example

use tsxlib::timeseries::TimeSeries;
use chrono::NaiveDateTime;

let values = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let index = (0..values.len()).map(|i| NaiveDateTime::from_timestamp(60 * i as i64,0)).collect();
let ts = TimeSeries::from_vecs(index, values).unwrap();
fn change_func(prior: &f64, curr: &f64) -> f64{
    curr - prior
};
let ts_difference: TimeSeries<NaiveDateTime,f64> = ts.skip_apply(1, change_func).collect();
fn perc_change_func(prior: &f64, curr: &f64) -> f64{
    (curr - prior)/prior
};
let ts_percent_change: TimeSeries<NaiveDateTime,f64> = ts.skip_apply(1, perc_change_func).collect();
 

pub fn cross_apply_inner<T2, T3>(
    &self,
    other: &TimeSeries<TDate, T2>,
    apply_func: fn(_: &T, _: &T2) -> T3
) -> TimeSeries<TDate, T3> where
    T2: Clone,
    T3: Clone, 

inner join two series and apply the desired UDF

Example

use tsxlib::timeseries::TimeSeries;
use tsxlib::data_elements::TimeSeriesDataPoint;

let values : Vec<f64> = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let values2 : Vec<f64> = vec![1.0, 2.0, 4.0];
let index: Vec<i32> = (0..values.len()).map(|i| i as i32).collect();
let index2: Vec<i32> = (0..values2.len()).map(|i| i as i32).collect();
let ts = TimeSeries::from_vecs(index, values).unwrap();
let ts1 = TimeSeries::from_vecs(index2, values2).unwrap();
let tsres = ts.cross_apply_inner(&ts1,|a,b| (*a,*b));
let expected = vec![
    TimeSeriesDataPoint { timestamp: 0, value: (1.00, 1.00) },
    TimeSeriesDataPoint { timestamp: 1, value: (2.00, 2.00) },
    TimeSeriesDataPoint { timestamp: 2, value: (3.00, 4.00) },
];
let ts_expected = TimeSeries::from_tsdatapoints(expected).unwrap();
assert_eq!(ts_expected, tsres)

pub fn cross_apply_left<T2, T3>(
    &self,
    other: &TimeSeries<TDate, T2>,
    apply_func: fn(_: &T, _: Option<&T2>) -> T3
) -> TimeSeries<TDate, T3> where
    T2: Clone,
    T3: Clone + Debug, 

Left join two series and apply the desired UDF

Example

use tsxlib::timeseries::TimeSeries;
use tsxlib::data_elements::TimeSeriesDataPoint;

let values : Vec<f64> = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let values2 : Vec<f64> = vec![1.0, 2.0, 4.0];
let index: Vec<i32> = (0..values.len()).map(|i| i as i32).collect();
let index2: Vec<i32> = (0..values2.len()).map(|i| i as i32).collect();
let ts = TimeSeries::from_vecs(index, values).unwrap();
let ts1 = TimeSeries::from_vecs(index2, values2).unwrap();
let tsres = ts.cross_apply_left(&ts1,|a,b| (*a, match b { Some(v) => Some(*v), _ => None }));
let expected = vec![
    TimeSeriesDataPoint { timestamp: 0, value: (1.00, Some(1.00)) },
    TimeSeriesDataPoint { timestamp: 1, value: (2.00, Some(2.00)) },
    TimeSeriesDataPoint { timestamp: 2, value: (3.00, Some(4.0)) },
    TimeSeriesDataPoint { timestamp: 3, value: (4.00, None) },
    TimeSeriesDataPoint { timestamp: 4, value: (5.00, None) },
];
let ts_expected = TimeSeries::from_tsdatapoints(expected).unwrap();
assert_eq!(ts_expected, tsres)

pub fn merge_apply_asof<T2, T3>(
    &self,
    other: &TimeSeries<TDate, T2>,
    compare_func: Option<Box<dyn Fn(&TDate, &TDate, &TDate) -> (Ordering, i64)>>,
    apply_func: fn(_: &T, _: Option<&T2>) -> T3,
    merge_mode: MergeAsofMode
) -> TimeSeries<TDate, T3> where
    T2: Clone,
    T3: Clone, 

This is similar to a left join except that it match on nearest key rather than equal keys similiar to https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.merge_asof.html

Example

use tsxlib::timeseries::{TimeSeries,MergeAsofMode};
use tsxlib::data_elements::TimeSeriesDataPoint;
use tsxlib::algo::chrono_utils;
use chrono::{NaiveDateTime,Duration};
let values = vec![1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0];
let index = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];    
let ts = TimeSeries::from_vecs(index.iter().map(|x| NaiveDateTime::from_timestamp(*x,0)).collect(), values).unwrap();
let values2 = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
let index2 = vec![2, 4, 5, 7, 8, 10];    
let ts_join = TimeSeries::from_vecs(index2.iter().map(|x| NaiveDateTime::from_timestamp(*x,0)).collect(), values2).unwrap();
 
let result = ts.merge_apply_asof(&ts_join,Some(chrono_utils::merge_asof_prior(Duration::seconds(1))),|a,b| (*a, match b {
    Some(x) => Some(*x),
    None => None
}), MergeAsofMode::RollPrior);
 
let expected = vec![
    TimeSeriesDataPoint { timestamp: NaiveDateTime::from_timestamp(1,0), value: (1.00, None) },
    TimeSeriesDataPoint { timestamp: NaiveDateTime::from_timestamp(2,0), value: (1.00, Some(1.00)) },
    TimeSeriesDataPoint { timestamp: NaiveDateTime::from_timestamp(3,0), value: (1.00, Some(1.00)) },
    TimeSeriesDataPoint { timestamp: NaiveDateTime::from_timestamp(4,0), value: (1.00, Some(2.00)) },
    TimeSeriesDataPoint { timestamp: NaiveDateTime::from_timestamp(5,0), value: (1.00, Some(3.00)) },
    TimeSeriesDataPoint { timestamp: NaiveDateTime::from_timestamp(6,0), value: (1.00, Some(3.00)) },
    TimeSeriesDataPoint { timestamp: NaiveDateTime::from_timestamp(7,0), value: (1.00, Some(4.00)) },
    TimeSeriesDataPoint { timestamp: NaiveDateTime::from_timestamp(8,0), value: (1.00, Some(5.00)) },
    TimeSeriesDataPoint { timestamp: NaiveDateTime::from_timestamp(9,0), value: (1.00, Some(5.00)) },
    TimeSeriesDataPoint { timestamp: NaiveDateTime::from_timestamp(10,0), value: (1.00, Some(6.00)) },
];
 
let ts_expected = TimeSeries::from_tsdatapoints(expected).unwrap();
 
assert_eq!(result, ts_expected);

pub fn interweave(
    &self,
    other: &TimeSeries<TDate, T>,
    selec_func: fn(_: TimeSeriesDataPoint<TDate, T>, _: TimeSeriesDataPoint<TDate, T>) -> TimeSeriesDataPoint<TDate, T>
) -> TimeSeries<TDate, T>

Interweave series. If a set of points happens to match then the selec_func is used to pick (or generate one)

Example

use tsxlib::timeseries::TimeSeries;
use tsxlib::data_elements::TimeSeriesDataPoint;
let data1 = vec![
    TimeSeriesDataPoint::from_int_stamp(1, 1.0),
    TimeSeriesDataPoint::from_int_stamp(2, 2.0),
    TimeSeriesDataPoint::from_int_stamp(3, 3.0),
    TimeSeriesDataPoint::from_int_stamp(4, 4.0),
    TimeSeriesDataPoint::from_int_stamp(5, 5.0),
];
let data2 = vec![
    TimeSeriesDataPoint::from_int_stamp(4, 6.0),
    TimeSeriesDataPoint::from_int_stamp(5, 7.0),
    TimeSeriesDataPoint::from_int_stamp(6, 8.0),
    TimeSeriesDataPoint::from_int_stamp(7, 9.0),
    TimeSeriesDataPoint::from_int_stamp(8, 10.0),
];
let expected = vec![
    TimeSeriesDataPoint::from_int_stamp(1, 1.0),
    TimeSeriesDataPoint::from_int_stamp(2, 2.0),
    TimeSeriesDataPoint::from_int_stamp(3, 3.0),
    TimeSeriesDataPoint::from_int_stamp(4, 4.0),
    TimeSeriesDataPoint::from_int_stamp(5, 5.0),
    TimeSeriesDataPoint::from_int_stamp(6, 8.0),
    TimeSeriesDataPoint::from_int_stamp(7, 9.0),
    TimeSeriesDataPoint::from_int_stamp(8, 10.0),
];
let ts1 = TimeSeries::from_tsdatapoints(data1).unwrap();
let ts2 = TimeSeries::from_tsdatapoints(data2).unwrap();
let ts_expected = TimeSeries::from_tsdatapoints(expected).unwrap();
let ts_merged = ts1.interweave(&ts2,|left,_right| left);
assert_eq!(ts_merged, ts_expected);

Trait Implementations

impl<TDate: Clone + Serialize + Hash + Eq + Ord, T: Clone> Clone for TimeSeries<TDate, T>

pub fn clone(&self) -> TimeSeries<TDate, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<TDate: Debug + Serialize + Hash + Clone + Eq + Ord, T: Debug + Clone> Debug for TimeSeries<TDate, T>

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

Formats the value using the given formatter.

impl<TDate: Serialize + Display + Hash + Clone + Eq + Ord, T: Display + Clone> Display for TimeSeries<TDate, T>

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

Formats the value using the given formatter.

impl<TDate: Serialize + Hash + Clone + Eq + Ord, T: Clone> FromIterator<TimeSeriesDataPoint<TDate, T>> for TimeSeries<TDate, T>

pub fn from_iter<Tin>(iter: Tin) -> Self where
    Tin: IntoIterator<Item = TimeSeriesDataPoint<TDate, T>>, 

Creates a value from an iterator.

impl<TDate: Serialize + Hash + Clone + Eq + Ord, T: Clone + PartialEq> PartialEq<TimeSeries<TDate, T>> for TimeSeries<TDate, T>

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.