fmt

dovahcrow · Jan 23, 2024 · 397f675 · 397f675
1 parent 52472fd
commit 397f675
Show file tree

Hide file tree

Showing 22 changed files with 231 additions and 200 deletions.
diff --git a/Justfile b/Justfile
@@ -4,7 +4,7 @@ bootstrap-python:
     rm python/README.md
 
 build-extension:
-    cd native && cargo build --release
+    cd native && cargo build --release --features check
     ls native/target/release
     cd python && poetry run python ../scripts/python-helper.py copy-extension
 
@@ -30,4 +30,4 @@ release:
   git checkout release
   git merge prerelease
   git push
-  git checkout master
+  git checkout master
diff --git a/native/Cargo.toml b/native/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-authors = ["Weiyuan Wu <youngw@sfu.ca>"]
+authors = ["Weiyuan Wu <weiyuan@crows.land>"]
 edition = "2018"
 name = "factor-expr"
 version = "0.2.3"
@@ -8,6 +8,7 @@ version = "0.2.3"
 crate-type = ["rlib", "cdylib"]
 name = "factor_expr"
 
+
 [dependencies]
 anyhow = "1"
 arrow = { version = "50", features = [ "ffi" ] }
@@ -38,3 +39,4 @@ built = {version = "0.7", features = ["chrono"]}
 default = ["extension"]
 executable = ["pyo3/auto-initialize"]
 extension = ["pyo3/extension-module"]
+check = []
diff --git a/native/rustfmt.toml b/native/rustfmt.toml
@@ -0,0 +1,2 @@
+imports_granularity = "Crate"
+unstable_features = true
diff --git a/native/src/float.rs b/native/src/float.rs
@@ -1,8 +1,10 @@
 /// copied from float_ord library
 use std::cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd};
-use std::fmt::{Debug, Display};
-use std::hash::{Hash, Hasher};
-use std::marker::PhantomData;
+use std::{
+    fmt::{Debug, Display},
+    hash::{Hash, Hasher},
+    marker::PhantomData,
+};
 
 pub trait SortOrder {
     fn convert(f: f64) -> u64;
@@ -104,11 +106,12 @@ impl Into<Float<Descending>> for f64 {
 #[cfg(test)]
 mod tests {
     use super::{Ascending, Descending, Float};
-    use rand::distributions::Uniform;
-    use rand::{thread_rng, Rng};
-    use std::collections::hash_map::DefaultHasher;
-    use std::f64::{INFINITY, NAN};
-    use std::hash::{Hash, Hasher};
+    use rand::{distributions::Uniform, thread_rng, Rng};
+    use std::{
+        collections::hash_map::DefaultHasher,
+        f64::{INFINITY, NAN},
+        hash::{Hash, Hasher},
+    };
 
     #[test]
     fn test_ord() {

diff --git a/native/src/ops/arithmetic.rs b/native/src/ops/arithmetic.rs
@@ -2,10 +2,7 @@ use super::{parser::Parameter, BoxOp, Named, Operator};
 use crate::ticker_batch::TickerBatch;
 use anyhow::{anyhow, Error, Result};
 use fehler::{throw, throws};
-use std::borrow::Cow;
-use std::cmp::max;
-use std::iter::FromIterator;
-use std::mem;
+use std::{borrow::Cow, cmp::max, iter::FromIterator, mem};
 
 macro_rules! impl_arithmetic_bivariate {
     ($([$name:tt => $op:ident: $($func:tt)+])+) => {
@@ -38,13 +35,17 @@ macro_rules! impl_arithmetic_bivariate {
                     let (l, r) = (&mut self.l, &mut self.r);
                     let (ls, rs) = rayon::join(|| l.update(tb), || r.update(tb));
                     let (ls, rs) = (&*ls?, &*rs?);
+                    #[cfg(feature = "check")]
                     assert_eq!(tb.len(), ls.len());
+                    #[cfg(feature = "check")]
                     assert_eq!(tb.len(), rs.len());
 
                     let mut results = Vec::with_capacity(tb.len());
 
                     for (&lval, &rval) in ls.into_iter().zip(rs) {
                         if self.i < self.l.ready_offset() || self.i < self.r.ready_offset() {
+                            #[cfg(feature = "check")]
+                            assert!(lval.is_nan() || rval.is_nan());
                             results.push(f64::NAN);
                             self.i += 1;
                             continue;
@@ -190,12 +191,15 @@ macro_rules! impl_arithmetic_univariate {
                 #[throws(Error)]
                 fn update<'a>(&mut self, tb: &'a T) -> Cow<'a, [f64]> {
                     let vals = &*self.inner.update(tb)?;
+                    #[cfg(feature = "check")]
                     assert_eq!(tb.len(), vals.len());
 
                     let mut results = Vec::with_capacity(tb.len());
 
                     for &val in vals {
                         if self.i < self.inner.ready_offset() {
+                            #[cfg(feature = "check")]
+                            assert!(val.is_nan());
                             results.push(f64::NAN);
                             self.i += 1;
                             continue;
@@ -322,12 +326,15 @@ macro_rules! impl_arithmetic_univariate_1arg {
                 #[throws(Error)]
                 fn update<'a>(&mut self, tb: &'a T) -> Cow<'a, [f64]> {
                     let vals = &*self.s.update(tb)?;
+                    #[cfg(feature = "check")]
                     assert_eq!(tb.len(), vals.len());
 
                     let mut results = Vec::with_capacity(tb.len());
 
                     for &val in vals {
                         if self.i < self.s.ready_offset() {
+                            #[cfg(feature = "check")]
+                            assert!(val.is_nan());
                             results.push(f64::NAN);
                             self.i += 1;
                             continue;

diff --git a/native/src/ops/logic.rs b/native/src/ops/logic.rs
@@ -2,10 +2,7 @@ use super::{parser::Parameter, BoxOp, Named, Operator};
 use crate::ticker_batch::TickerBatch;
 use anyhow::{anyhow, Error, Result};
 use fehler::{throw, throws};
-use std::borrow::Cow;
-use std::cmp::max;
-use std::iter::FromIterator;
-use std::mem;
+use std::{borrow::Cow, cmp::max, iter::FromIterator, mem};
 
 // #[derive(Clone)]
 pub struct If<T> {
@@ -49,14 +46,19 @@ impl<T: TickerBatch> Operator<T> for If<T> {
         );
 
         let (conds, btrues, bfalses) = (&*conds?, &*btrues?, &*bfalses?);
+        #[cfg(feature = "check")]
         assert_eq!(tb.len(), conds.len());
+        #[cfg(feature = "check")]
         assert_eq!(tb.len(), btrues.len());
+        #[cfg(feature = "check")]
         assert_eq!(tb.len(), bfalses.len());
 
         let mut results = Vec::with_capacity(tb.len());
 
         for ((&cond, &tval), &fval) in conds.into_iter().zip(btrues).zip(bfalses) {
             if self.i < self.ready_offset() {
+                #[cfg(feature = "check")]
+                assert!(cond.is_nan() || tval.is_nan() || fval.is_nan());
                 results.push(f64::NAN);
                 self.i += 1;
                 continue;
@@ -227,13 +229,17 @@ macro_rules! impl_logic_bivariate {
                     let (l, r) = (&mut self.l, &mut self.r);
                     let (ls, rs) = rayon::join(|| l.update(tb), || r.update(tb));
                     let (ls, rs) = (&*ls?, &*rs?);
+                    #[cfg(feature = "check")]
                     assert_eq!(tb.len(), ls.len());
+                    #[cfg(feature = "check")]
                     assert_eq!(tb.len(), rs.len());
 
                     let mut results = Vec::with_capacity(tb.len());
 
                     for (&lval, &rval) in ls.into_iter().zip(rs) {
                         if self.i < self.l.ready_offset() || self.i < self.r.ready_offset() {
+                            #[cfg(feature = "check")]
+                            assert!(lval.is_nan() || rval.is_nan());
                             results.push(f64::NAN);
                             self.i += 1;
                             continue;
@@ -381,12 +387,15 @@ impl<T: TickerBatch> Operator<T> for Not<T> {
     #[throws(Error)]
     fn update<'a>(&mut self, tb: &'a T) -> Cow<'a, [f64]> {
         let vals = &*self.inner.update(tb)?;
+        #[cfg(feature = "check")]
         assert_eq!(tb.len(), vals.len());
 
         let mut results = Vec::with_capacity(tb.len());
 
         for &val in vals {
             if self.i < self.inner.ready_offset() {
+                #[cfg(feature = "check")]
+                assert!(val.is_nan());
                 results.push(f64::NAN);
                 self.i += 1;
                 continue;

diff --git a/native/src/ops/overlap_studies.rs b/native/src/ops/overlap_studies.rs
@@ -1,6 +1,4 @@
-use std::collections::VecDeque;
-use std::mem;
-use std::{borrow::Cow, iter::FromIterator};
+use std::{borrow::Cow, collections::VecDeque, iter::FromIterator, mem};
 
 use anyhow::{anyhow, Error, Result};
 use fehler::{throw, throws};
@@ -45,12 +43,15 @@ impl<T: TickerBatch> Operator<T> for SMA<T> {
     #[throws(Error)]
     fn update<'a>(&mut self, tb: &'a T) -> Cow<'a, [f64]> {
         let vals = &*self.inner.update(tb)?;
+        #[cfg(feature = "check")]
         assert_eq!(tb.len(), vals.len());
 
         let mut results = Vec::with_capacity(tb.len());
 
         for &val in vals {
             if self.i < self.inner.ready_offset() {
+                #[cfg(feature = "check")]
+                assert!(val.is_nan());
                 results.push(f64::NAN);
                 self.i += 1;
                 continue;

diff --git a/native/src/ops/parser.rs b/native/src/ops/parser.rs
@@ -115,19 +115,19 @@ fn visit<T: TickerBatch>(sexpr: Cons) -> BoxOp<T> {
         Not::<T>::NAME => Result::<Not<T>>::from_iter(params)?.boxed(),
 
         // windows
-        TSSum::<T>::NAME => Result::<TSSum<T>>::from_iter(params)?.boxed(),
-        TSMean::<T>::NAME => Result::<TSMean<T>>::from_iter(params)?.boxed(),
-        TSCorrelation::<T>::NAME => Result::<TSCorrelation<T>>::from_iter(params)?.boxed(),
-        TSMin::<T>::NAME => Result::<TSMin<T>>::from_iter(params)?.boxed(),
-        TSMax::<T>::NAME => Result::<TSMax<T>>::from_iter(params)?.boxed(),
-        TSArgMin::<T>::NAME => Result::<TSArgMin<T>>::from_iter(params)?.boxed(),
-        TSArgMax::<T>::NAME => Result::<TSArgMax<T>>::from_iter(params)?.boxed(),
-        TSStdev::<T>::NAME => Result::<TSStdev<T>>::from_iter(params)?.boxed(),
-        TSSkew::<T>::NAME => Result::<TSSkew<T>>::from_iter(params)?.boxed(),
+        Sum::<T>::NAME => Result::<Sum<T>>::from_iter(params)?.boxed(),
+        Mean::<T>::NAME => Result::<Mean<T>>::from_iter(params)?.boxed(),
+        Correlation::<T>::NAME => Result::<Correlation<T>>::from_iter(params)?.boxed(),
+        Min::<T>::NAME => Result::<Min<T>>::from_iter(params)?.boxed(),
+        Max::<T>::NAME => Result::<Max<T>>::from_iter(params)?.boxed(),
+        ArgMin::<T>::NAME => Result::<ArgMin<T>>::from_iter(params)?.boxed(),
+        ArgMax::<T>::NAME => Result::<ArgMax<T>>::from_iter(params)?.boxed(),
+        Stdev::<T>::NAME => Result::<Stdev<T>>::from_iter(params)?.boxed(),
+        Skew::<T>::NAME => Result::<Skew<T>>::from_iter(params)?.boxed(),
         Delay::<T>::NAME => Result::<Delay<T>>::from_iter(params)?.boxed(),
-        TSRank::<T>::NAME => Result::<TSRank<T>>::from_iter(params)?.boxed(),
-        TSQuantile::<T>::NAME => Result::<TSQuantile<T>>::from_iter(params)?.boxed(),
-        TSLogReturn::<T>::NAME => Result::<TSLogReturn<T>>::from_iter(params)?.boxed(),
+        Rank::<T>::NAME => Result::<Rank<T>>::from_iter(params)?.boxed(),
+        Quantile::<T>::NAME => Result::<Quantile<T>>::from_iter(params)?.boxed(),
+        LogReturn::<T>::NAME => Result::<LogReturn<T>>::from_iter(params)?.boxed(),
 
         // overla_studies
         SMA::<T>::NAME => Result::<SMA<T>>::from_iter(params)?.boxed(),

diff --git a/native/src/ops/window/correlation.rs b/native/src/ops/window/correlation.rs
@@ -2,11 +2,7 @@ use super::super::{parser::Parameter, BoxOp, Named, Operator};
 use crate::ticker_batch::TickerBatch;
 use anyhow::{anyhow, Error, Result};
 use fehler::{throw, throws};
-use std::borrow::Cow;
-use std::cmp::max;
-use std::collections::VecDeque;
-use std::iter::FromIterator;
-use std::mem;
+use std::{borrow::Cow, cmp::max, collections::VecDeque, iter::FromIterator, mem};
 
 #[derive(Clone)]
 struct Cache {
@@ -27,7 +23,7 @@ impl Cache {
     }
 }
 
-pub struct TSCorrelation<T> {
+pub struct Correlation<T> {
     win_size: usize,
     x: BoxOp<T>,
     y: BoxOp<T>,
@@ -36,13 +32,13 @@ pub struct TSCorrelation<T> {
     i: usize,
 }
 
-impl<T> Clone for TSCorrelation<T> {
+impl<T> Clone for Correlation<T> {
     fn clone(&self) -> Self {
         Self::new(self.win_size, self.x.clone(), self.y.clone())
     }
 }
 
-impl<T> TSCorrelation<T> {
+impl<T> Correlation<T> {
     pub fn new(win_size: usize, x: BoxOp<T>, y: BoxOp<T>) -> Self {
         Self {
             win_size,
@@ -55,23 +51,27 @@ impl<T> TSCorrelation<T> {
     }
 }
 
-impl<T> Named for TSCorrelation<T> {
-    const NAME: &'static str = "TSCorr";
+impl<T> Named for Correlation<T> {
+    const NAME: &'static str = "Corr";
 }
 
-impl<T: TickerBatch> Operator<T> for TSCorrelation<T> {
+impl<T: TickerBatch> Operator<T> for Correlation<T> {
     #[throws(Error)]
     fn update<'a>(&mut self, tb: &'a T) -> Cow<'a, [f64]> {
         let (x, y) = (&mut self.x, &mut self.y);
         let (xs, ys) = rayon::join(|| x.update(tb), || y.update(tb));
         let (xs, ys) = (&*xs?, &*ys?);
+        #[cfg(feature = "check")]
         assert_eq!(tb.len(), xs.len());
+        #[cfg(feature = "check")]
         assert_eq!(tb.len(), ys.len());
 
         let mut results = Vec::with_capacity(tb.len());
 
         for (&xval, &yval) in xs.into_iter().zip(ys) {
             if self.i < self.x.ready_offset() || self.i < self.y.ready_offset() {
+                #[cfg(feature = "check")]
+                assert!(xval.is_nan() || yval.is_nan());
                 results.push(f64::NAN);
                 self.i += 1;
                 continue;
@@ -206,25 +206,25 @@ impl<T: TickerBatch> Operator<T> for TSCorrelation<T> {
     }
 }
 
-impl<T: TickerBatch> FromIterator<Parameter<T>> for Result<TSCorrelation<T>> {
+impl<T: TickerBatch> FromIterator<Parameter<T>> for Result<Correlation<T>> {
     #[throws(Error)]
-    fn from_iter<A: IntoIterator<Item = Parameter<T>>>(iter: A) -> TSCorrelation<T> {
+    fn from_iter<A: IntoIterator<Item = Parameter<T>>>(iter: A) -> Correlation<T> {
         let mut params: Vec<_> = iter.into_iter().collect();
         if params.len() != 3 {
             throw!(anyhow!(
                 "{} expect a constant and two series, got {:?}",
-                TSCorrelation::<T>::NAME,
+                Correlation::<T>::NAME,
                 params
             ))
         }
         let k1 = params.remove(0);
         let k2 = params.remove(0).to_operator();
         let k3 = params.remove(0).to_operator();
         match (k1, k2, k3) {
-            (Parameter::Constant(c), Some(sx), Some(sy)) => TSCorrelation::new(c as usize, sx, sy),
+            (Parameter::Constant(c), Some(sx), Some(sy)) => Correlation::new(c as usize, sx, sy),
             _ => throw!(anyhow!(
                 "{} expect a constant and two series",
-                TSCorrelation::<T>::NAME,
+                Correlation::<T>::NAME,
             )),
         }
     }

diff --git a/native/src/ops/window/delay.rs b/native/src/ops/window/delay.rs
@@ -2,10 +2,7 @@ use super::super::{parser::Parameter, BoxOp, Named, Operator};
 use crate::ticker_batch::TickerBatch;
 use anyhow::{anyhow, Error, Result};
 use fehler::{throw, throws};
-use std::borrow::Cow;
-use std::collections::VecDeque;
-use std::iter::FromIterator;
-use std::mem;
+use std::{borrow::Cow, collections::VecDeque, iter::FromIterator, mem};
 
 pub struct Delay<T> {
     win_size: usize,
@@ -40,12 +37,15 @@ impl<T: TickerBatch> Operator<T> for Delay<T> {
     #[throws(Error)]
     fn update<'a>(&mut self, tb: &'a T) -> Cow<'a, [f64]> {
         let vals = &*self.inner.update(tb)?;
+        #[cfg(feature = "check")]
         assert_eq!(tb.len(), vals.len());
 
         let mut results = Vec::with_capacity(tb.len());
 
         for &val in vals {
             if self.i < self.inner.ready_offset() {
+                #[cfg(feature = "check")]
+                assert!(val.is_nan());
                 results.push(f64::NAN);
                 self.i += 1;
                 continue;
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		imports_granularity = "Crate"
		unstable_features = true