polars-df 0.1.2 → 0.1.3

data/ext/polars/src/lib.rs

@@ -5,6 +5,8 @@ mod error;
 mod file;
 mod lazy;
 mod series;
+mod set;
+mod utils;
 
 use batched_csv::RbBatchedCsv;
 use conversion::*;
@@ -13,14 +15,16 @@ use error::{RbPolarsErr, RbValueError};
 use file::get_file_like;
 use lazy::dataframe::{RbLazyFrame, RbLazyGroupBy};
 use lazy::dsl::{RbExpr, RbWhen, RbWhenThen};
+use lazy::utils::rb_exprs_to_exprs;
 use magnus::{
     define_module, function, memoize, method, prelude::*, Error, RArray, RClass, RHash, RModule,
     Value,
 };
-use polars::datatypes::DataType;
+use polars::datatypes::{DataType, TimeUnit};
 use polars::error::PolarsResult;
 use polars::frame::DataFrame;
 use polars::functions::{diag_concat_df, hor_concat_df};
+use polars::prelude::{ClosedWindow, Duration, IntoSeries, TimeZone};
 use series::RbSeries;
 
 type RbResult<T> = Result<T, Error>;
@@ -42,6 +46,9 @@ fn init() -> RbResult<()> {
     module.define_singleton_method("_concat_series", function!(concat_series, 1))?;
     module.define_singleton_method("_ipc_schema", function!(ipc_schema, 1))?;
     module.define_singleton_method("_parquet_schema", function!(parquet_schema, 1))?;
+    module.define_singleton_method("_rb_date_range", function!(rb_date_range, 7))?;
+    module.define_singleton_method("_as_struct", function!(as_struct, 1))?;
+    module.define_singleton_method("_arg_where", function!(arg_where, 1))?;
 
     let class = module.define_class("RbBatchedCsv", Default::default())?;
     class.define_singleton_method("new", function!(RbBatchedCsv::new, -1))?;
@@ -50,7 +57,7 @@ fn init() -> RbResult<()> {
     let class = module.define_class("RbDataFrame", Default::default())?;
     class.define_singleton_method("new", function!(RbDataFrame::init, 1))?;
     class.define_singleton_method("read_csv", function!(RbDataFrame::read_csv, -1))?;
-    class.define_singleton_method("read_parquet", function!(RbDataFrame::read_parquet, 1))?;
+    class.define_singleton_method("read_parquet", function!(RbDataFrame::read_parquet, 7))?;
     class.define_singleton_method("read_ipc", function!(RbDataFrame::read_ipc, 6))?;
     class.define_singleton_method("read_hash", function!(RbDataFrame::read_hash, 1))?;
     class.define_singleton_method("read_json", function!(RbDataFrame::read_json, 1))?;
@@ -60,7 +67,21 @@ fn init() -> RbResult<()> {
     class.define_method("write_ndjson", method!(RbDataFrame::write_ndjson, 1))?;
     class.define_method("write_csv", method!(RbDataFrame::write_csv, 10))?;
     class.define_method("write_ipc", method!(RbDataFrame::write_ipc, 2))?;
+    class.define_method("row_tuple", method!(RbDataFrame::row_tuple, 1))?;
+    class.define_method("row_tuples", method!(RbDataFrame::row_tuples, 0))?;
     class.define_method("write_parquet", method!(RbDataFrame::write_parquet, 5))?;
+    class.define_method("add", method!(RbDataFrame::add, 1))?;
+    class.define_method("sub", method!(RbDataFrame::sub, 1))?;
+    class.define_method("div", method!(RbDataFrame::div, 1))?;
+    class.define_method("mul", method!(RbDataFrame::mul, 1))?;
+    class.define_method("rem", method!(RbDataFrame::rem, 1))?;
+    class.define_method("add_df", method!(RbDataFrame::add_df, 1))?;
+    class.define_method("sub_df", method!(RbDataFrame::sub_df, 1))?;
+    class.define_method("div_df", method!(RbDataFrame::div_df, 1))?;
+    class.define_method("mul_df", method!(RbDataFrame::mul_df, 1))?;
+    class.define_method("rem_df", method!(RbDataFrame::rem_df, 1))?;
+    class.define_method("sample_n", method!(RbDataFrame::sample_n, 4))?;
+    class.define_method("sample_frac", method!(RbDataFrame::sample_frac, 4))?;
     class.define_method("rechunk", method!(RbDataFrame::rechunk, 0))?;
     class.define_method("to_s", method!(RbDataFrame::to_s, 0))?;
     class.define_method("get_columns", method!(RbDataFrame::get_columns, 0))?;
@@ -74,7 +95,19 @@ fn init() -> RbResult<()> {
     class.define_method("shape", method!(RbDataFrame::shape, 0))?;
     class.define_method("height", method!(RbDataFrame::height, 0))?;
     class.define_method("width", method!(RbDataFrame::width, 0))?;
+    class.define_method("hstack_mut", method!(RbDataFrame::hstack_mut, 1))?;
+    class.define_method("hstack", method!(RbDataFrame::hstack, 1))?;
+    class.define_method("extend", method!(RbDataFrame::extend, 1))?;
+    class.define_method("vstack_mut", method!(RbDataFrame::vstack_mut, 1))?;
+    class.define_method("vstack", method!(RbDataFrame::vstack, 1))?;
+    class.define_method("drop_in_place", method!(RbDataFrame::drop_in_place, 1))?;
+    class.define_method("drop_nulls", method!(RbDataFrame::drop_nulls, 1))?;
+    class.define_method("drop", method!(RbDataFrame::drop, 1))?;
     class.define_method("select_at_idx", method!(RbDataFrame::select_at_idx, 1))?;
+    class.define_method(
+        "find_idx_by_name",
+        method!(RbDataFrame::find_idx_by_name, 1),
+    )?;
     class.define_method("column", method!(RbDataFrame::column, 1))?;
     class.define_method("select", method!(RbDataFrame::select, 1))?;
     class.define_method("take", method!(RbDataFrame::take, 1))?;
@@ -116,6 +149,7 @@ fn init() -> RbResult<()> {
     class.define_method("shrink_to_fit", method!(RbDataFrame::shrink_to_fit, 0))?;
     class.define_method("transpose", method!(RbDataFrame::transpose, 2))?;
     class.define_method("upsample", method!(RbDataFrame::upsample, 5))?;
+    class.define_method("to_struct", method!(RbDataFrame::to_struct, 1))?;
     class.define_method("unnest", method!(RbDataFrame::unnest, 1))?;
 
     let class = module.define_class("RbExpr", Default::default())?;
@@ -304,6 +338,7 @@ fn init() -> RbResult<()> {
     class.define_method("dt_tz_localize", method!(RbExpr::dt_tz_localize, 1))?;
     class.define_method("dt_truncate", method!(RbExpr::dt_truncate, 2))?;
     class.define_method("dt_round", method!(RbExpr::dt_round, 2))?;
+    class.define_method("reinterpret", method!(RbExpr::reinterpret, 1))?;
     class.define_method("mode", method!(RbExpr::mode, 0))?;
     class.define_method("keep_name", method!(RbExpr::keep_name, 0))?;
     class.define_method("prefix", method!(RbExpr::prefix, 1))?;
@@ -353,6 +388,7 @@ fn init() -> RbResult<()> {
     class.define_method("ewm_mean", method!(RbExpr::ewm_mean, 3))?;
     class.define_method("ewm_std", method!(RbExpr::ewm_std, 4))?;
     class.define_method("ewm_var", method!(RbExpr::ewm_var, 4))?;
+    class.define_method("extend_constant", method!(RbExpr::extend_constant, 2))?;
     class.define_method("any", method!(RbExpr::any, 0))?;
     class.define_method("all", method!(RbExpr::all, 0))?;
     class.define_method(
@@ -369,6 +405,7 @@ fn init() -> RbResult<()> {
     )?;
     class.define_method("log", method!(RbExpr::log, 1))?;
     class.define_method("exp", method!(RbExpr::exp, 0))?;
+    class.define_method("entropy", method!(RbExpr::entropy, 2))?;
 
     // meta
     class.define_method("meta_pop", method!(RbExpr::meta_pop, 0))?;
@@ -386,6 +423,7 @@ fn init() -> RbResult<()> {
     class.define_singleton_method("fold", function!(crate::lazy::dsl::fold, 3))?;
     class.define_singleton_method("lit", function!(crate::lazy::dsl::lit, 1))?;
     class.define_singleton_method("arange", function!(crate::lazy::dsl::arange, 3))?;
+    class.define_singleton_method("repeat", function!(crate::lazy::dsl::repeat, 2))?;
     class.define_singleton_method("when", function!(crate::lazy::dsl::when, 1))?;
     class.define_singleton_method("concat_str", function!(crate::lazy::dsl::concat_str, 2))?;
     class.define_singleton_method("concat_lst", function!(crate::lazy::dsl::concat_lst, 1))?;
@@ -469,6 +507,7 @@ fn init() -> RbResult<()> {
     class.define_singleton_method("new_opt_f32", function!(RbSeries::new_opt_f32, 3))?;
     class.define_singleton_method("new_opt_f64", function!(RbSeries::new_opt_f64, 3))?;
     class.define_singleton_method("new_str", function!(RbSeries::new_str, 3))?;
+    class.define_singleton_method("new_opt_date", function!(RbSeries::new_opt_date, 3))?;
     class.define_method("is_sorted_flag", method!(RbSeries::is_sorted_flag, 0))?;
     class.define_method(
         "is_sorted_reverse_flag",
@@ -536,14 +575,85 @@ fn init() -> RbResult<()> {
     class.define_method("kurtosis", method!(RbSeries::kurtosis, 2))?;
     class.define_method("cast", method!(RbSeries::cast, 2))?;
     class.define_method("time_unit", method!(RbSeries::time_unit, 0))?;
-    // rest
-    class.define_method("cumsum", method!(RbSeries::cumsum, 1))?;
-    class.define_method("cummax", method!(RbSeries::cummax, 1))?;
-    class.define_method("cummin", method!(RbSeries::cummin, 1))?;
-    class.define_method("cumprod", method!(RbSeries::cumprod, 1))?;
-    class.define_method("slice", method!(RbSeries::slice, 2))?;
-    class.define_method("ceil", method!(RbSeries::ceil, 0))?;
-    class.define_method("round", method!(RbSeries::round, 1))?;
+    class.define_method("set_at_idx", method!(RbSeries::set_at_idx, 2))?;
+
+    // eq
+    class.define_method("eq_u8", method!(RbSeries::eq_u8, 1))?;
+    class.define_method("eq_u16", method!(RbSeries::eq_u16, 1))?;
+    class.define_method("eq_u32", method!(RbSeries::eq_u32, 1))?;
+    class.define_method("eq_u64", method!(RbSeries::eq_u64, 1))?;
+    class.define_method("eq_i8", method!(RbSeries::eq_i8, 1))?;
+    class.define_method("eq_i16", method!(RbSeries::eq_i16, 1))?;
+    class.define_method("eq_i32", method!(RbSeries::eq_i32, 1))?;
+    class.define_method("eq_i64", method!(RbSeries::eq_i64, 1))?;
+    class.define_method("eq_f32", method!(RbSeries::eq_f32, 1))?;
+    class.define_method("eq_f64", method!(RbSeries::eq_f64, 1))?;
+    // class.define_method("eq_str", method!(RbSeries::eq_str, 1))?;
+
+    // neq
+    class.define_method("neq_u8", method!(RbSeries::neq_u8, 1))?;
+    class.define_method("neq_u16", method!(RbSeries::neq_u16, 1))?;
+    class.define_method("neq_u32", method!(RbSeries::neq_u32, 1))?;
+    class.define_method("neq_u64", method!(RbSeries::neq_u64, 1))?;
+    class.define_method("neq_i8", method!(RbSeries::neq_i8, 1))?;
+    class.define_method("neq_i16", method!(RbSeries::neq_i16, 1))?;
+    class.define_method("neq_i32", method!(RbSeries::neq_i32, 1))?;
+    class.define_method("neq_i64", method!(RbSeries::neq_i64, 1))?;
+    class.define_method("neq_f32", method!(RbSeries::neq_f32, 1))?;
+    class.define_method("neq_f64", method!(RbSeries::neq_f64, 1))?;
+    // class.define_method("neq_str", method!(RbSeries::neq_str, 1))?;
+
+    // gt
+    class.define_method("gt_u8", method!(RbSeries::gt_u8, 1))?;
+    class.define_method("gt_u16", method!(RbSeries::gt_u16, 1))?;
+    class.define_method("gt_u32", method!(RbSeries::gt_u32, 1))?;
+    class.define_method("gt_u64", method!(RbSeries::gt_u64, 1))?;
+    class.define_method("gt_i8", method!(RbSeries::gt_i8, 1))?;
+    class.define_method("gt_i16", method!(RbSeries::gt_i16, 1))?;
+    class.define_method("gt_i32", method!(RbSeries::gt_i32, 1))?;
+    class.define_method("gt_i64", method!(RbSeries::gt_i64, 1))?;
+    class.define_method("gt_f32", method!(RbSeries::gt_f32, 1))?;
+    class.define_method("gt_f64", method!(RbSeries::gt_f64, 1))?;
+    // class.define_method("gt_str", method!(RbSeries::gt_str, 1))?;
+
+    // gt_eq
+    class.define_method("gt_eq_u8", method!(RbSeries::gt_eq_u8, 1))?;
+    class.define_method("gt_eq_u16", method!(RbSeries::gt_eq_u16, 1))?;
+    class.define_method("gt_eq_u32", method!(RbSeries::gt_eq_u32, 1))?;
+    class.define_method("gt_eq_u64", method!(RbSeries::gt_eq_u64, 1))?;
+    class.define_method("gt_eq_i8", method!(RbSeries::gt_eq_i8, 1))?;
+    class.define_method("gt_eq_i16", method!(RbSeries::gt_eq_i16, 1))?;
+    class.define_method("gt_eq_i32", method!(RbSeries::gt_eq_i32, 1))?;
+    class.define_method("gt_eq_i64", method!(RbSeries::gt_eq_i64, 1))?;
+    class.define_method("gt_eq_f32", method!(RbSeries::gt_eq_f32, 1))?;
+    class.define_method("gt_eq_f64", method!(RbSeries::gt_eq_f64, 1))?;
+    // class.define_method("gt_eq_str", method!(RbSeries::gt_eq_str, 1))?;
+
+    // lt
+    class.define_method("lt_u8", method!(RbSeries::lt_u8, 1))?;
+    class.define_method("lt_u16", method!(RbSeries::lt_u16, 1))?;
+    class.define_method("lt_u32", method!(RbSeries::lt_u32, 1))?;
+    class.define_method("lt_u64", method!(RbSeries::lt_u64, 1))?;
+    class.define_method("lt_i8", method!(RbSeries::lt_i8, 1))?;
+    class.define_method("lt_i16", method!(RbSeries::lt_i16, 1))?;
+    class.define_method("lt_i32", method!(RbSeries::lt_i32, 1))?;
+    class.define_method("lt_i64", method!(RbSeries::lt_i64, 1))?;
+    class.define_method("lt_f32", method!(RbSeries::lt_f32, 1))?;
+    class.define_method("lt_f64", method!(RbSeries::lt_f64, 1))?;
+    // class.define_method("lt_str", method!(RbSeries::lt_str, 1))?;
+
+    // lt_eq
+    class.define_method("lt_eq_u8", method!(RbSeries::lt_eq_u8, 1))?;
+    class.define_method("lt_eq_u16", method!(RbSeries::lt_eq_u16, 1))?;
+    class.define_method("lt_eq_u32", method!(RbSeries::lt_eq_u32, 1))?;
+    class.define_method("lt_eq_u64", method!(RbSeries::lt_eq_u64, 1))?;
+    class.define_method("lt_eq_i8", method!(RbSeries::lt_eq_i8, 1))?;
+    class.define_method("lt_eq_i16", method!(RbSeries::lt_eq_i16, 1))?;
+    class.define_method("lt_eq_i32", method!(RbSeries::lt_eq_i32, 1))?;
+    class.define_method("lt_eq_i64", method!(RbSeries::lt_eq_i64, 1))?;
+    class.define_method("lt_eq_f32", method!(RbSeries::lt_eq_f32, 1))?;
+    class.define_method("lt_eq_f64", method!(RbSeries::lt_eq_f64, 1))?;
+    // class.define_method("lt_eq_str", method!(RbSeries::lt_eq_str, 1))?;
 
     let class = module.define_class("RbWhen", Default::default())?;
     class.define_method("_then", method!(RbWhen::then, 1))?;
@@ -641,3 +751,34 @@ fn parquet_schema(rb_f: Value) -> RbResult<Value> {
     }
     Ok(dict.into())
 }
+
+fn rb_date_range(
+    start: i64,
+    stop: i64,
+    every: String,
+    closed: Wrap<ClosedWindow>,
+    name: String,
+    tu: Wrap<TimeUnit>,
+    tz: Option<TimeZone>,
+) -> RbSeries {
+    polars::time::date_range_impl(
+        &name,
+        start,
+        stop,
+        Duration::parse(&every),
+        closed.0,
+        tu.0,
+        tz,
+    )
+    .into_series()
+    .into()
+}
+
+fn as_struct(exprs: RArray) -> RbResult<RbExpr> {
+    let exprs = rb_exprs_to_exprs(exprs)?;
+    Ok(polars::lazy::dsl::as_struct(&exprs).into())
+}
+
+fn arg_where(condition: &RbExpr) -> RbExpr {
+    polars::lazy::dsl::arg_where(condition.inner.clone()).into()
+}

data/ext/polars/src/series.rs

@@ -5,6 +5,7 @@ use polars::series::IsSorted;
 use std::cell::RefCell;
 
 use crate::conversion::*;
+use crate::set::set_at_idx;
 use crate::{RbDataFrame, RbPolarsErr, RbResult, RbValueError};
 
 #[magnus::wrap(class = "Polars::RbSeries")]
@@ -474,6 +475,12 @@ impl RbSeries {
             s.into_iter().collect()
         } else if let Ok(s) = series.utf8() {
             s.into_iter().collect()
+        } else if let Ok(_s) = series.date() {
+            let a = RArray::with_capacity(series.len());
+            for v in series.iter() {
+                a.push::<Value>(Wrap(v).into()).unwrap();
+            }
+            a
         } else {
             unimplemented!();
         }
@@ -594,44 +601,190 @@ impl RbSeries {
         }
     }
 
-    // dispatch dynamically in future?
-
-    pub fn cumsum(&self, reverse: bool) -> Self {
-        self.series.borrow().cumsum(reverse).into()
+    pub fn set_at_idx(&self, idx: &RbSeries, values: &RbSeries) -> RbResult<()> {
+        let mut s = self.series.borrow_mut();
+        match set_at_idx(s.clone(), &idx.series.borrow(), &values.series.borrow()) {
+            Ok(out) => {
+                *s = out;
+                Ok(())
+            }
+            Err(e) => Err(RbPolarsErr::from(e)),
+        }
     }
+}
 
-    pub fn cummax(&self, reverse: bool) -> Self {
-        self.series.borrow().cummax(reverse).into()
-    }
+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()))
+            }
+        }
+    };
+}
 
-    pub fn cummin(&self, reverse: bool) -> Self {
-        self.series.borrow().cummin(reverse).into()
-    }
+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()))
+            }
+        }
+    };
+}
 
-    pub fn cumprod(&self, reverse: bool) -> Self {
-        self.series.borrow().cumprod(reverse).into()
-    }
+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()))
+            }
+        }
+    };
+}
 
-    pub fn slice(&self, offset: i64, length: usize) -> Self {
-        let series = self.series.borrow().slice(offset, length);
-        series.into()
-    }
+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()))
+            }
+        }
+    };
+}
 
-    pub fn ceil(&self) -> RbResult<Self> {
-        let s = self.series.borrow().ceil().map_err(RbPolarsErr::from)?;
-        Ok(s.into())
-    }
+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()))
+            }
+        }
+    };
+}
 
-    pub fn round(&self, decimals: u32) -> RbResult<Self> {
-        let s = self
-            .series
-            .borrow()
-            .round(decimals)
-            .map_err(RbPolarsErr::from)?;
-        Ok(s.into())
-    }
+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>) -> Vec<RbSeries> {
     s.into_iter().map(RbSeries::new).collect()
 }
+
+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: Value = v.funcall("to_datetime", ())?;
+                let v: Value = v.funcall("to_time", ())?;
+                let v: Value = v.funcall("to_i", ())?;
+                // TODO use strict
+                builder.append_value(v.try_convert::<i32>()? / 86400);
+            }
+        }
+        let ca: ChunkedArray<Int32Type> = builder.finish();
+        Ok(ca.into_date().into_series().into())
+    }
+}

data/ext/polars/src/set.rs

@@ -0,0 +1,91 @@
+// use polars::export::arrow2::array::Array;
+use polars::prelude::*;
+
+pub fn set_at_idx(mut s: Series, idx: &Series, values: &Series) -> PolarsResult<Series> {
+    let logical_dtype = s.dtype().clone();
+    let idx = idx.cast(&IDX_DTYPE)?;
+    let idx = idx.rechunk();
+    let idx = idx.idx().unwrap();
+    let idx = idx.downcast_iter().next().unwrap();
+
+    // if idx.null_count() > 0 {
+    //     return Err(PolarsError::ComputeError(
+    //         "index values should not be null".into(),
+    //     ));
+    // }
+
+    let idx = idx.values().as_slice();
+
+    let values = values.to_physical_repr().cast(&s.dtype().to_physical())?;
+
+    // do not shadow, otherwise s is not dropped immediately
+    // and we want to have mutable access
+    s = s.to_physical_repr().into_owned();
+    let mutable_s = s._get_inner_mut();
+
+    let s = match logical_dtype.to_physical() {
+        DataType::Int8 => {
+            let ca: &mut ChunkedArray<Int8Type> = mutable_s.as_mut();
+            let values = values.i8()?;
+            std::mem::take(ca).set_at_idx2(idx, values.into_iter())
+        }
+        DataType::Int16 => {
+            let ca: &mut ChunkedArray<Int16Type> = mutable_s.as_mut();
+            let values = values.i16()?;
+            std::mem::take(ca).set_at_idx2(idx, values.into_iter())
+        }
+        DataType::Int32 => {
+            let ca: &mut ChunkedArray<Int32Type> = mutable_s.as_mut();
+            let values = values.i32()?;
+            std::mem::take(ca).set_at_idx2(idx, values.into_iter())
+        }
+        DataType::Int64 => {
+            let ca: &mut ChunkedArray<Int64Type> = mutable_s.as_mut();
+            let values = values.i64()?;
+            std::mem::take(ca).set_at_idx2(idx, values.into_iter())
+        }
+        DataType::UInt8 => {
+            let ca: &mut ChunkedArray<UInt8Type> = mutable_s.as_mut();
+            let values = values.u8()?;
+            std::mem::take(ca).set_at_idx2(idx, values.into_iter())
+        }
+        DataType::UInt16 => {
+            let ca: &mut ChunkedArray<UInt16Type> = mutable_s.as_mut();
+            let values = values.u16()?;
+            std::mem::take(ca).set_at_idx2(idx, values.into_iter())
+        }
+        DataType::UInt32 => {
+            let ca: &mut ChunkedArray<UInt32Type> = mutable_s.as_mut();
+            let values = values.u32()?;
+            std::mem::take(ca).set_at_idx2(idx, values.into_iter())
+        }
+        DataType::UInt64 => {
+            let ca: &mut ChunkedArray<UInt64Type> = mutable_s.as_mut();
+            let values = values.u64()?;
+            std::mem::take(ca).set_at_idx2(idx, values.into_iter())
+        }
+        DataType::Float32 => {
+            let ca: &mut ChunkedArray<Float32Type> = mutable_s.as_mut();
+            let values = values.f32()?;
+            std::mem::take(ca).set_at_idx2(idx, values.into_iter())
+        }
+        DataType::Float64 => {
+            let ca: &mut ChunkedArray<Float64Type> = mutable_s.as_mut();
+            let values = values.f64()?;
+            std::mem::take(ca).set_at_idx2(idx, values.into_iter())
+        }
+        DataType::Boolean => {
+            let ca = s.bool()?;
+            let values = values.bool()?;
+            ca.set_at_idx2(idx, values)
+        }
+        DataType::Utf8 => {
+            let ca = s.utf8()?;
+            let values = values.utf8()?;
+            ca.set_at_idx2(idx, values)
+        }
+        _ => panic!("not yet implemented for dtype: {}", logical_dtype),
+    };
+
+    s.and_then(|s| s.cast(&logical_dtype))
+}

data/ext/polars/src/utils.rs

@@ -0,0 +1,19 @@
+use polars::prelude::*;
+
+pub fn reinterpret(s: &Series, signed: bool) -> polars::prelude::PolarsResult<Series> {
+    match (s.dtype(), signed) {
+        (DataType::UInt64, true) => {
+            let ca = s.u64().unwrap();
+            Ok(ca.reinterpret_signed().into_series())
+        }
+        (DataType::UInt64, false) => Ok(s.clone()),
+        (DataType::Int64, false) => {
+            let ca = s.i64().unwrap();
+            Ok(ca.reinterpret_unsigned().into_series())
+        }
+        (DataType::Int64, true) => Ok(s.clone()),
+        _ => Err(PolarsError::ComputeError(
+            "reinterpret is only allowed for 64bit integers dtype, use cast otherwise".into(),
+        )),
+    }
+}

data/lib/polars/batched_csv_reader.rb

@@ -1,4 +1,5 @@
 module Polars
+  # @private
   class BatchedCsvReader
     attr_accessor :_reader, :new_columns
 

data/lib/polars/cat_expr.rb

@@ -1,11 +1,50 @@
 module Polars
+  # Namespace for categorical related expressions.
   class CatExpr
+    # @private
     attr_accessor :_rbexpr
 
+    # @private
     def initialize(expr)
       self._rbexpr = expr._rbexpr
     end
 
+    # Determine how this categorical series should be sorted.
+    #
+    # @param ordering ["physical", "lexical"]
+    #   Ordering type:
+    #
+    #   - 'physical' -> Use the physical representation of the categories to determine the order (default).
+    #   - 'lexical' -> Use the string values to determine the ordering.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"cats" => ["z", "z", "k", "a", "b"], "vals" => [3, 1, 2, 2, 3]}
+    #   ).with_columns(
+    #     [
+    #       Polars.col("cats").cast(:cat).cat.set_ordering("lexical")
+    #     ]
+    #   )
+    #   df.sort(["cats", "vals"])
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌──────┬──────┐
+    #   # │ cats ┆ vals │
+    #   # │ ---  ┆ ---  │
+    #   # │ cat  ┆ i64  │
+    #   # ╞══════╪══════╡
+    #   # │ a    ┆ 2    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ b    ┆ 3    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ k    ┆ 2    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ z    ┆ 1    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ z    ┆ 3    │
+    #   # └──────┴──────┘
     def set_ordering(ordering)
       Utils.wrap_expr(_rbexpr.cat_set_ordering(ordering))
     end