polars-df 0.4.0 → 0.6.0

data/ext/polars/src/series.rs

@@ -1,4 +1,11 @@
-use magnus::{exception, Error, IntoValue, RArray, Value};
+mod aggregation;
+mod arithmetic;
+mod comparison;
+mod construction;
+mod export;
+mod set_at_idx;
+
+use magnus::{exception, Error, IntoValue, RArray, Value, QNIL};
 use polars::prelude::*;
 use polars::series::IsSorted;
 use std::cell::RefCell;
@@ -6,9 +13,8 @@ use std::cell::RefCell;
 use crate::apply::series::{call_lambda_and_extract, ApplyLambda};
 use crate::apply_method_all_arrow_series2;
 use crate::conversion::*;
-use crate::list_construction::rb_seq_to_list;
-use crate::set::set_at_idx;
-use crate::{RbDataFrame, RbPolarsErr, RbResult, RbValueError};
+use crate::series::set_at_idx::set_at_idx;
+use crate::{RbDataFrame, RbPolarsErr, RbResult};
 
 #[magnus::wrap(class = "Polars::RbSeries")]
 pub struct RbSeries {
@@ -27,121 +33,46 @@ impl RbSeries {
             series: RefCell::new(series),
         }
     }
-
-    pub fn is_sorted_flag(&self) -> bool {
-        matches!(self.series.borrow().is_sorted_flag(), IsSorted::Ascending)
-    }
-
-    pub fn is_sorted_reverse_flag(&self) -> bool {
-        matches!(self.series.borrow().is_sorted_flag(), IsSorted::Descending)
-    }
-
-    pub fn new_opt_bool(name: String, obj: RArray, strict: bool) -> RbResult<RbSeries> {
-        let len = obj.len();
-        let mut builder = BooleanChunkedBuilder::new(&name, len);
-
-        unsafe {
-            for item in obj.as_slice().iter() {
-                if item.is_nil() {
-                    builder.append_null()
-                } else {
-                    match item.try_convert::<bool>() {
-                        Ok(val) => builder.append_value(val),
-                        Err(e) => {
-                            if strict {
-                                return Err(e);
-                            }
-                            builder.append_null()
-                        }
-                    }
-                }
-            }
-        }
-        let ca = builder.finish();
-
-        let s = ca.into_series();
-        Ok(RbSeries::new(s))
-    }
 }
 
-fn new_primitive<T>(name: &str, obj: RArray, strict: bool) -> RbResult<RbSeries>
-where
-    T: PolarsNumericType,
-    ChunkedArray<T>: IntoSeries,
-    T::Native: magnus::TryConvert,
-{
-    let len = obj.len();
-    let mut builder = PrimitiveChunkedBuilder::<T>::new(name, len);
-
-    unsafe {
-        for item in obj.as_slice().iter() {
-            if item.is_nil() {
-                builder.append_null()
-            } else {
-                match item.try_convert::<T::Native>() {
-                    Ok(val) => builder.append_value(val),
-                    Err(e) => {
-                        if strict {
-                            return Err(e);
-                        }
-                        builder.append_null()
-                    }
-                }
-            }
-        }
+pub fn to_series_collection(rs: RArray) -> RbResult<Vec<Series>> {
+    let mut series = Vec::new();
+    for item in rs.each() {
+        series.push(item?.try_convert::<&RbSeries>()?.series.borrow().clone());
     }
-    let ca = builder.finish();
-
-    let s = ca.into_series();
-    Ok(RbSeries::new(s))
+    Ok(series)
 }
 
-// Init with lists that can contain Nones
-macro_rules! init_method_opt {
-    ($name:ident, $type:ty, $native: ty) => {
-        impl RbSeries {
-            pub fn $name(name: String, obj: RArray, strict: bool) -> RbResult<Self> {
-                new_primitive::<$type>(&name, obj, strict)
-            }
-        }
-    };
+pub fn to_rbseries_collection(s: Vec<Series>) -> RArray {
+    RArray::from_iter(s.into_iter().map(RbSeries::new))
 }
 
-init_method_opt!(new_opt_u8, UInt8Type, u8);
-init_method_opt!(new_opt_u16, UInt16Type, u16);
-init_method_opt!(new_opt_u32, UInt32Type, u32);
-init_method_opt!(new_opt_u64, UInt64Type, u64);
-init_method_opt!(new_opt_i8, Int8Type, i8);
-init_method_opt!(new_opt_i16, Int16Type, i16);
-init_method_opt!(new_opt_i32, Int32Type, i32);
-init_method_opt!(new_opt_i64, Int64Type, i64);
-init_method_opt!(new_opt_f32, Float32Type, f32);
-init_method_opt!(new_opt_f64, Float64Type, f64);
-
 impl RbSeries {
-    pub fn new_str(name: String, val: Wrap<Utf8Chunked>, _strict: bool) -> Self {
-        let mut s = val.0.into_series();
-        s.rename(&name);
-        RbSeries::new(s)
+    pub fn struct_unnest(&self) -> RbResult<RbDataFrame> {
+        let binding = self.series.borrow();
+        let ca = binding.struct_().map_err(RbPolarsErr::from)?;
+        let df: DataFrame = ca.clone().into();
+        Ok(df.into())
     }
 
-    pub fn new_binary(name: String, val: Wrap<BinaryChunked>, _strict: bool) -> Self {
-        let mut s = val.0.into_series();
-        s.rename(&name);
-        RbSeries::new(s)
+    // pub fn struct_fields(&self) -> RbResult<Vec<&str>> {
+    //     let ca = self.series.borrow().struct_().map_err(RbPolarsErr::from)?;
+    //     Ok(ca.fields().iter().map(|s| s.name()).collect())
+    // }
+
+    pub fn is_sorted_ascending_flag(&self) -> bool {
+        matches!(self.series.borrow().is_sorted_flag(), IsSorted::Ascending)
     }
 
-    pub fn new_object(name: String, val: RArray, _strict: bool) -> RbResult<Self> {
-        let val = val
-            .each()
-            .map(|v| v.map(ObjectValue::from))
-            .collect::<RbResult<Vec<ObjectValue>>>()?;
-        let s = ObjectChunked::<ObjectValue>::new_from_vec(&name, val).into_series();
-        Ok(s.into())
+    pub fn is_sorted_descending_flag(&self) -> bool {
+        matches!(self.series.borrow().is_sorted_flag(), IsSorted::Descending)
     }
 
-    pub fn new_list(name: String, seq: Value, dtype: Wrap<DataType>) -> RbResult<Self> {
-        rb_seq_to_list(&name, seq, &dtype.0).map(|s| s.into())
+    pub fn can_fast_explode_flag(&self) -> bool {
+        match self.series.borrow().list() {
+            Err(_) => false,
+            Ok(list) => list._can_fast_explode(),
+        }
     }
 
     pub fn estimated_size(&self) -> usize {
@@ -232,9 +163,9 @@ impl RbSeries {
             .map(|dt| Wrap(dt.clone()).into_value())
     }
 
-    pub fn set_sorted(&self, reverse: bool) -> Self {
+    pub fn set_sorted_flag(&self, descending: bool) -> Self {
         let mut out = self.series.borrow().clone();
-        if reverse {
+        if descending {
             out.set_sorted_flag(IsSorted::Descending);
         } else {
             out.set_sorted_flag(IsSorted::Ascending)
@@ -242,49 +173,6 @@ impl RbSeries {
         out.into()
     }
 
-    pub fn mean(&self) -> Option<f64> {
-        match self.series.borrow().dtype() {
-            DataType::Boolean => {
-                let s = self.series.borrow().cast(&DataType::UInt8).unwrap();
-                s.mean()
-            }
-            _ => self.series.borrow().mean(),
-        }
-    }
-
-    pub fn max(&self) -> RbResult<Value> {
-        Ok(Wrap(
-            self.series
-                .borrow()
-                .max_as_series()
-                .get(0)
-                .map_err(RbPolarsErr::from)?,
-        )
-        .into_value())
-    }
-
-    pub fn min(&self) -> RbResult<Value> {
-        Ok(Wrap(
-            self.series
-                .borrow()
-                .min_as_series()
-                .get(0)
-                .map_err(RbPolarsErr::from)?,
-        )
-        .into_value())
-    }
-
-    pub fn sum(&self) -> RbResult<Value> {
-        Ok(Wrap(
-            self.series
-                .borrow()
-                .sum_as_series()
-                .get(0)
-                .map_err(RbPolarsErr::from)?,
-        )
-        .into_value())
-    }
-
     pub fn n_chunks(&self) -> usize {
         self.series.borrow().n_chunks()
     }
@@ -328,26 +216,6 @@ impl RbSeries {
         }
     }
 
-    pub fn add(&self, other: &RbSeries) -> Self {
-        (&*self.series.borrow() + &*other.series.borrow()).into()
-    }
-
-    pub fn sub(&self, other: &RbSeries) -> Self {
-        (&*self.series.borrow() - &*other.series.borrow()).into()
-    }
-
-    pub fn mul(&self, other: &RbSeries) -> Self {
-        (&*self.series.borrow() * &*other.series.borrow()).into()
-    }
-
-    pub fn div(&self, other: &RbSeries) -> Self {
-        (&*self.series.borrow() / &*other.series.borrow()).into()
-    }
-
-    pub fn rem(&self, other: &RbSeries) -> Self {
-        (&*self.series.borrow() % &*other.series.borrow()).into()
-    }
-
     pub fn sort(&self, reverse: bool) -> Self {
         (self.series.borrow_mut().sort(reverse)).into()
     }
@@ -361,14 +229,6 @@ impl RbSeries {
         Ok(df.into())
     }
 
-    pub fn arg_min(&self) -> Option<usize> {
-        self.series.borrow().arg_min()
-    }
-
-    pub fn arg_max(&self) -> Option<usize> {
-        self.series.borrow().arg_max()
-    }
-
     pub fn take_with_series(&self, indices: &RbSeries) -> RbResult<Self> {
         let binding = indices.series.borrow();
         let idx = binding.idx().map_err(RbPolarsErr::from)?;
@@ -426,60 +286,6 @@ impl RbSeries {
         }
     }
 
-    pub fn eq(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .equal(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
-    }
-
-    pub fn neq(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .not_equal(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
-    }
-
-    pub fn gt(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .gt(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
-    }
-
-    pub fn gt_eq(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .gt_eq(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
-    }
-
-    pub fn lt(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .lt(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
-    }
-
-    pub fn lt_eq(&self, rhs: &RbSeries) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .lt_eq(&*rhs.series.borrow())
-            .map_err(RbPolarsErr::from)?;
-        Ok(Self::new(s.into_series()))
-    }
-
     pub fn not(&self) -> RbResult<Self> {
         let binding = self.series.borrow();
         let bool = binding.bool().map_err(RbPolarsErr::from)?;
@@ -494,85 +300,131 @@ impl RbSeries {
         self.series.borrow().len()
     }
 
-    pub fn to_a(&self) -> RArray {
+    pub fn to_a(&self) -> Value {
         let series = &self.series.borrow();
 
-        fn to_list_recursive(series: &Series) -> RArray {
+        fn to_a_recursive(series: &Series) -> Value {
             let rblist = match series.dtype() {
-                DataType::Boolean => RArray::from_iter(series.bool().unwrap()),
-                DataType::UInt8 => RArray::from_iter(series.u8().unwrap()),
-                DataType::UInt16 => RArray::from_iter(series.u16().unwrap()),
-                DataType::UInt32 => RArray::from_iter(series.u32().unwrap()),
-                DataType::UInt64 => RArray::from_iter(series.u64().unwrap()),
-                DataType::Int8 => RArray::from_iter(series.i8().unwrap()),
-                DataType::Int16 => RArray::from_iter(series.i16().unwrap()),
-                DataType::Int32 => RArray::from_iter(series.i32().unwrap()),
-                DataType::Int64 => RArray::from_iter(series.i64().unwrap()),
-                DataType::Float32 => RArray::from_iter(series.f32().unwrap()),
-                DataType::Float64 => RArray::from_iter(series.f64().unwrap()),
+                DataType::Boolean => RArray::from_iter(series.bool().unwrap()).into_value(),
+                DataType::UInt8 => RArray::from_iter(series.u8().unwrap()).into_value(),
+                DataType::UInt16 => RArray::from_iter(series.u16().unwrap()).into_value(),
+                DataType::UInt32 => RArray::from_iter(series.u32().unwrap()).into_value(),
+                DataType::UInt64 => RArray::from_iter(series.u64().unwrap()).into_value(),
+                DataType::Int8 => RArray::from_iter(series.i8().unwrap()).into_value(),
+                DataType::Int16 => RArray::from_iter(series.i16().unwrap()).into_value(),
+                DataType::Int32 => RArray::from_iter(series.i32().unwrap()).into_value(),
+                DataType::Int64 => RArray::from_iter(series.i64().unwrap()).into_value(),
+                DataType::Float32 => RArray::from_iter(series.f32().unwrap()).into_value(),
+                DataType::Float64 => RArray::from_iter(series.f64().unwrap()).into_value(),
                 DataType::Categorical(_) => {
-                    RArray::from_iter(series.categorical().unwrap().iter_str())
+                    RArray::from_iter(series.categorical().unwrap().iter_str()).into_value()
                 }
-                DataType::Date => {
-                    let a = RArray::with_capacity(series.len());
-                    for v in series.iter() {
-                        a.push::<Value>(Wrap(v).into_value()).unwrap();
+                DataType::Object(_) => {
+                    let v = RArray::with_capacity(series.len());
+                    for i in 0..series.len() {
+                        let obj: Option<&ObjectValue> = series.get_object(i).map(|any| any.into());
+                        match obj {
+                            Some(val) => v.push(val.to_object()).unwrap(),
+                            None => v.push(QNIL).unwrap(),
+                        };
                     }
-                    return a;
+                    v.into_value()
                 }
-                DataType::Datetime(_, _) => {
-                    let a = RArray::with_capacity(series.len());
-                    for v in series.iter() {
-                        a.push::<Value>(Wrap(v).into_value()).unwrap();
+                DataType::List(_) => {
+                    let v = RArray::new();
+                    let ca = series.list().unwrap();
+                    for opt_s in ca.amortized_iter() {
+                        match opt_s {
+                            None => {
+                                v.push(QNIL).unwrap();
+                            }
+                            Some(s) => {
+                                let rblst = to_a_recursive(s.as_ref());
+                                v.push(rblst).unwrap();
+                            }
+                        }
+                    }
+                    v.into_value()
+                }
+                DataType::Array(_, _) => {
+                    let v = RArray::new();
+                    let ca = series.array().unwrap();
+                    for opt_s in ca.amortized_iter() {
+                        match opt_s {
+                            None => {
+                                v.push(QNIL).unwrap();
+                            }
+                            Some(s) => {
+                                let rblst = to_a_recursive(s.as_ref());
+                                v.push(rblst).unwrap();
+                            }
+                        }
                     }
-                    return a;
+                    v.into_value()
+                }
+                DataType::Date => {
+                    let ca = series.date().unwrap();
+                    return Wrap(ca).into_value();
+                }
+                DataType::Time => {
+                    let ca = series.time().unwrap();
+                    return Wrap(ca).into_value();
+                }
+                DataType::Datetime(_, _) => {
+                    let ca = series.datetime().unwrap();
+                    return Wrap(ca).into_value();
+                }
+                DataType::Decimal(_, _) => {
+                    let ca = series.decimal().unwrap();
+                    return Wrap(ca).into_value();
                 }
                 DataType::Utf8 => {
                     let ca = series.utf8().unwrap();
-                    return RArray::from_iter(ca);
+                    return Wrap(ca).into_value();
+                }
+                DataType::Struct(_) => {
+                    let ca = series.struct_().unwrap();
+                    return Wrap(ca).into_value();
+                }
+                DataType::Duration(_) => {
+                    let ca = series.duration().unwrap();
+                    return Wrap(ca).into_value();
                 }
                 DataType::Binary => {
-                    let a = RArray::with_capacity(series.len());
-                    for v in series.iter() {
-                        a.push::<Value>(Wrap(v).into_value()).unwrap();
+                    let ca = series.binary().unwrap();
+                    return Wrap(ca).into_value();
+                }
+                DataType::Null => {
+                    let null: Option<u8> = None;
+                    let n = series.len();
+                    let iter = std::iter::repeat(null).take(n);
+                    use std::iter::{Repeat, Take};
+                    struct NullIter {
+                        iter: Take<Repeat<Option<u8>>>,
+                        n: usize,
+                    }
+                    impl Iterator for NullIter {
+                        type Item = Option<u8>;
+
+                        fn next(&mut self) -> Option<Self::Item> {
+                            self.iter.next()
+                        }
+                        fn size_hint(&self) -> (usize, Option<usize>) {
+                            (self.n, Some(self.n))
+                        }
                     }
-                    return a;
+                    impl ExactSizeIterator for NullIter {}
+
+                    RArray::from_iter(NullIter { iter, n }).into_value()
                 }
-                DataType::Null | DataType::Unknown => {
+                DataType::Unknown => {
                     panic!("to_a not implemented for null/unknown")
                 }
-                _ => todo!(),
             };
             rblist
         }
 
-        to_list_recursive(series)
-    }
-
-    pub fn median(&self) -> Option<f64> {
-        match self.series.borrow().dtype() {
-            DataType::Boolean => {
-                let s = self.series.borrow().cast(&DataType::UInt8).unwrap();
-                s.median()
-            }
-            _ => self.series.borrow().median(),
-        }
-    }
-
-    pub fn quantile(
-        &self,
-        quantile: f64,
-        interpolation: Wrap<QuantileInterpolOptions>,
-    ) -> RbResult<Value> {
-        Ok(Wrap(
-            self.series
-                .borrow()
-                .quantile_as_series(quantile, interpolation.0)
-                .map_err(|_| RbValueError::new_err("invalid quantile".into()))?
-                .get(0)
-                .unwrap_or(AnyValue::Null),
-        )
-        .into_value())
+        to_a_recursive(series)
     }
 
     pub fn clone(&self) -> Self {
@@ -782,11 +634,11 @@ impl RbSeries {
         Ok(RbSeries::new(s))
     }
 
-    pub fn to_dummies(&self, sep: Option<String>) -> RbResult<RbDataFrame> {
+    pub fn to_dummies(&self, sep: Option<String>, drop_first: bool) -> RbResult<RbDataFrame> {
         let df = self
             .series
             .borrow()
-            .to_dummies(sep.as_deref())
+            .to_dummies(sep.as_deref(), drop_first)
             .map_err(RbPolarsErr::from)?;
         Ok(df.into())
     }
@@ -906,266 +758,14 @@ impl_set_with_mask!(set_with_mask_i32, i32, i32, Int32);
 impl_set_with_mask!(set_with_mask_i64, i64, i64, Int64);
 impl_set_with_mask!(set_with_mask_bool, bool, bool, Boolean);
 
-macro_rules! impl_arithmetic {
-    ($name:ident, $type:ty, $operand:tt) => {
-        impl RbSeries {
-            pub fn $name(&self, other: $type) -> RbResult<Self> {
-                Ok(RbSeries::new(&*self.series.borrow() $operand other))
-            }
-        }
-    };
-}
-
-impl_arithmetic!(add_u8, u8, +);
-impl_arithmetic!(add_u16, u16, +);
-impl_arithmetic!(add_u32, u32, +);
-impl_arithmetic!(add_u64, u64, +);
-impl_arithmetic!(add_i8, i8, +);
-impl_arithmetic!(add_i16, i16, +);
-impl_arithmetic!(add_i32, i32, +);
-impl_arithmetic!(add_i64, i64, +);
-impl_arithmetic!(add_datetime, i64, +);
-impl_arithmetic!(add_duration, i64, +);
-impl_arithmetic!(add_f32, f32, +);
-impl_arithmetic!(add_f64, f64, +);
-impl_arithmetic!(sub_u8, u8, -);
-impl_arithmetic!(sub_u16, u16, -);
-impl_arithmetic!(sub_u32, u32, -);
-impl_arithmetic!(sub_u64, u64, -);
-impl_arithmetic!(sub_i8, i8, -);
-impl_arithmetic!(sub_i16, i16, -);
-impl_arithmetic!(sub_i32, i32, -);
-impl_arithmetic!(sub_i64, i64, -);
-impl_arithmetic!(sub_datetime, i64, -);
-impl_arithmetic!(sub_duration, i64, -);
-impl_arithmetic!(sub_f32, f32, -);
-impl_arithmetic!(sub_f64, f64, -);
-impl_arithmetic!(div_u8, u8, /);
-impl_arithmetic!(div_u16, u16, /);
-impl_arithmetic!(div_u32, u32, /);
-impl_arithmetic!(div_u64, u64, /);
-impl_arithmetic!(div_i8, i8, /);
-impl_arithmetic!(div_i16, i16, /);
-impl_arithmetic!(div_i32, i32, /);
-impl_arithmetic!(div_i64, i64, /);
-impl_arithmetic!(div_f32, f32, /);
-impl_arithmetic!(div_f64, f64, /);
-impl_arithmetic!(mul_u8, u8, *);
-impl_arithmetic!(mul_u16, u16, *);
-impl_arithmetic!(mul_u32, u32, *);
-impl_arithmetic!(mul_u64, u64, *);
-impl_arithmetic!(mul_i8, i8, *);
-impl_arithmetic!(mul_i16, i16, *);
-impl_arithmetic!(mul_i32, i32, *);
-impl_arithmetic!(mul_i64, i64, *);
-impl_arithmetic!(mul_f32, f32, *);
-impl_arithmetic!(mul_f64, f64, *);
-impl_arithmetic!(rem_u8, u8, %);
-impl_arithmetic!(rem_u16, u16, %);
-impl_arithmetic!(rem_u32, u32, %);
-impl_arithmetic!(rem_u64, u64, %);
-impl_arithmetic!(rem_i8, i8, %);
-impl_arithmetic!(rem_i16, i16, %);
-impl_arithmetic!(rem_i32, i32, %);
-impl_arithmetic!(rem_i64, i64, %);
-impl_arithmetic!(rem_f32, f32, %);
-impl_arithmetic!(rem_f64, f64, %);
-
-macro_rules! impl_eq_num {
-    ($name:ident, $type:ty) => {
-        impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<Self> {
-                let s = self.series.borrow().equal(rhs).map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
-            }
-        }
-    };
-}
-
-impl_eq_num!(eq_u8, u8);
-impl_eq_num!(eq_u16, u16);
-impl_eq_num!(eq_u32, u32);
-impl_eq_num!(eq_u64, u64);
-impl_eq_num!(eq_i8, i8);
-impl_eq_num!(eq_i16, i16);
-impl_eq_num!(eq_i32, i32);
-impl_eq_num!(eq_i64, i64);
-impl_eq_num!(eq_f32, f32);
-impl_eq_num!(eq_f64, f64);
-// impl_eq_num!(eq_str, &str);
-
-macro_rules! impl_neq_num {
-    ($name:ident, $type:ty) => {
-        impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<Self> {
-                let s = self
-                    .series
-                    .borrow()
-                    .not_equal(rhs)
-                    .map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
-            }
-        }
-    };
-}
-
-impl_neq_num!(neq_u8, u8);
-impl_neq_num!(neq_u16, u16);
-impl_neq_num!(neq_u32, u32);
-impl_neq_num!(neq_u64, u64);
-impl_neq_num!(neq_i8, i8);
-impl_neq_num!(neq_i16, i16);
-impl_neq_num!(neq_i32, i32);
-impl_neq_num!(neq_i64, i64);
-impl_neq_num!(neq_f32, f32);
-impl_neq_num!(neq_f64, f64);
-// impl_neq_num!(neq_str, &str);
-
-macro_rules! impl_gt_num {
-    ($name:ident, $type:ty) => {
-        impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<Self> {
-                let s = self.series.borrow().gt(rhs).map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
-            }
-        }
-    };
-}
-
-impl_gt_num!(gt_u8, u8);
-impl_gt_num!(gt_u16, u16);
-impl_gt_num!(gt_u32, u32);
-impl_gt_num!(gt_u64, u64);
-impl_gt_num!(gt_i8, i8);
-impl_gt_num!(gt_i16, i16);
-impl_gt_num!(gt_i32, i32);
-impl_gt_num!(gt_i64, i64);
-impl_gt_num!(gt_f32, f32);
-impl_gt_num!(gt_f64, f64);
-// impl_gt_num!(gt_str, &str);
-
-macro_rules! impl_gt_eq_num {
-    ($name:ident, $type:ty) => {
-        impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<Self> {
-                let s = self.series.borrow().gt_eq(rhs).map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
-            }
-        }
-    };
-}
-
-impl_gt_eq_num!(gt_eq_u8, u8);
-impl_gt_eq_num!(gt_eq_u16, u16);
-impl_gt_eq_num!(gt_eq_u32, u32);
-impl_gt_eq_num!(gt_eq_u64, u64);
-impl_gt_eq_num!(gt_eq_i8, i8);
-impl_gt_eq_num!(gt_eq_i16, i16);
-impl_gt_eq_num!(gt_eq_i32, i32);
-impl_gt_eq_num!(gt_eq_i64, i64);
-impl_gt_eq_num!(gt_eq_f32, f32);
-impl_gt_eq_num!(gt_eq_f64, f64);
-// impl_gt_eq_num!(gt_eq_str, &str);
-
-macro_rules! impl_lt_num {
-    ($name:ident, $type:ty) => {
-        impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<RbSeries> {
-                let s = self.series.borrow().lt(rhs).map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
-            }
-        }
-    };
-}
-
-impl_lt_num!(lt_u8, u8);
-impl_lt_num!(lt_u16, u16);
-impl_lt_num!(lt_u32, u32);
-impl_lt_num!(lt_u64, u64);
-impl_lt_num!(lt_i8, i8);
-impl_lt_num!(lt_i16, i16);
-impl_lt_num!(lt_i32, i32);
-impl_lt_num!(lt_i64, i64);
-impl_lt_num!(lt_f32, f32);
-impl_lt_num!(lt_f64, f64);
-// impl_lt_num!(lt_str, &str);
-
-macro_rules! impl_lt_eq_num {
-    ($name:ident, $type:ty) => {
-        impl RbSeries {
-            pub fn $name(&self, rhs: $type) -> RbResult<Self> {
-                let s = self.series.borrow().lt_eq(rhs).map_err(RbPolarsErr::from)?;
-                Ok(RbSeries::new(s.into_series()))
-            }
-        }
-    };
-}
-
-impl_lt_eq_num!(lt_eq_u8, u8);
-impl_lt_eq_num!(lt_eq_u16, u16);
-impl_lt_eq_num!(lt_eq_u32, u32);
-impl_lt_eq_num!(lt_eq_u64, u64);
-impl_lt_eq_num!(lt_eq_i8, i8);
-impl_lt_eq_num!(lt_eq_i16, i16);
-impl_lt_eq_num!(lt_eq_i32, i32);
-impl_lt_eq_num!(lt_eq_i64, i64);
-impl_lt_eq_num!(lt_eq_f32, f32);
-impl_lt_eq_num!(lt_eq_f64, f64);
-// impl_lt_eq_num!(lt_eq_str, &str);
-
-pub fn to_series_collection(rs: RArray) -> RbResult<Vec<Series>> {
-    let mut series = Vec::new();
-    for item in rs.each() {
-        series.push(item?.try_convert::<&RbSeries>()?.series.borrow().clone());
-    }
-    Ok(series)
-}
-
-pub fn to_rbseries_collection(s: Vec<Series>) -> RArray {
-    RArray::from_iter(s.into_iter().map(RbSeries::new))
-}
-
 impl RbSeries {
-    pub fn new_opt_date(name: String, values: RArray, _strict: Option<bool>) -> RbResult<Self> {
-        let len = values.len();
-        let mut builder = PrimitiveChunkedBuilder::<Int32Type>::new(&name, len);
-        for item in values.each() {
-            let v = item?;
-            if v.is_nil() {
-                builder.append_null();
-            } else {
-                // convert to DateTime for UTC
-                let v = v
-                    .funcall::<_, _, Value>("to_datetime", ())?
-                    .funcall::<_, _, Value>("to_time", ())?
-                    .funcall::<_, _, i64>("to_i", ())?;
-
-                // TODO use strict
-                builder.append_value((v / 86400) as i32);
-            }
-        }
-        let ca: ChunkedArray<Int32Type> = builder.finish();
-        Ok(ca.into_date().into_series().into())
-    }
-
-    pub fn new_opt_datetime(name: String, values: RArray, _strict: Option<bool>) -> RbResult<Self> {
-        let len = values.len();
-        let mut builder = PrimitiveChunkedBuilder::<Int64Type>::new(&name, len);
-        for item in values.each() {
-            let v = item?;
-            if v.is_nil() {
-                builder.append_null();
-            } else {
-                let sec: i64 = v.funcall("to_i", ())?;
-                let nsec: i64 = v.funcall("nsec", ())?;
-                // TODO use strict
-                builder.append_value(sec * 1_000_000_000 + nsec);
-            }
-        }
-        let ca: ChunkedArray<Int64Type> = builder.finish();
-        Ok(ca
-            .into_datetime(TimeUnit::Nanoseconds, None)
-            .into_series()
+    pub fn extend_constant(&self, value: Wrap<AnyValue>, n: usize) -> RbResult<Self> {
+        Ok(self
+            .series
+            .borrow()
+            .clone()
+            .extend_constant(value.0, n)
+            .map_err(RbPolarsErr::from)?
             .into())
     }
 }