chore(rust): move abs to ops

crates/polars-core/Cargo.toml

@@ -93,7 +93,6 @@ group_by_list = []
 rolling_window = []
 diagonal_concat = []
 horizontal_concat = []
-abs = []
 dataframe_arithmetic = []
 product = []
 unique_counts = []
@@ -148,7 +147,6 @@ docs-selection = [
   "dtype-decimal",
   "diagonal_concat",
   "horizontal_concat",
-  "abs",
   "dataframe_arithmetic",
   "product",
   "unique_counts",

crates/polars-core/src/chunked_array/ops/mod.rs

@@ -6,8 +6,6 @@ use arrow::offset::OffsetsBuffer;
 use crate::datatypes::ObjectType;
 use crate::prelude::*;
 
-#[cfg(feature = "abs")]
-mod abs;
 pub(crate) mod aggregate;
 pub(crate) mod any_value;
 pub(crate) mod append;

crates/polars-core/src/series/mod.rs

@@ -765,26 +765,6 @@ impl Series {
         }
     }
 
-    #[cfg(feature = "abs")]
-    /// convert numerical values to their absolute value
-    pub fn abs(&self) -> PolarsResult<Series> {
-        let a = self.to_physical_repr();
-        use DataType::*;
-        let out = match a.dtype() {
-            #[cfg(feature = "dtype-i8")]
-            Int8 => a.i8().unwrap().abs().into_series(),
-            #[cfg(feature = "dtype-i16")]
-            Int16 => a.i16().unwrap().abs().into_series(),
-            Int32 => a.i32().unwrap().abs().into_series(),
-            Int64 => a.i64().unwrap().abs().into_series(),
-            UInt8 | UInt16 | UInt32 | UInt64 => self.clone(),
-            Float32 => a.f32().unwrap().abs().into_series(),
-            Float64 => a.f64().unwrap().abs().into_series(),
-            dt => polars_bail!(opq = abs, dt),
-        };
-        out.cast(self.dtype())
-    }
-
     // used for formatting
     pub fn str_value(&self, index: usize) -> PolarsResult<Cow<str>> {
         let out = match self.0.get(index)? {

crates/polars-ops/Cargo.toml

@@ -115,3 +115,4 @@ repeat_by = []
 peaks = []
 cum_agg = []
 ewma = []
+abs = []

crates/polars-ops/src/series/ops/abs.rs

@@ -0,0 +1,29 @@
+use num_traits::Signed;
+use polars_core::prelude::*;
+
+fn abs_numeric<T>(ca: &ChunkedArray<T>) -> ChunkedArray<T>
+where
+    T: PolarsNumericType,
+    T::Native: Signed,
+{
+    ca.apply_values(|v| v.abs())
+}
+
+/// convert numerical values to their absolute value
+pub fn abs(s: &Series) -> PolarsResult<Series> {
+    let physical_s = s.to_physical_repr();
+    use DataType::*;
+    let out = match physical_s.dtype() {
+        #[cfg(feature = "dtype-i8")]
+        Int8 => abs_numeric(physical_s.i8()?).into_series(),
+        #[cfg(feature = "dtype-i16")]
+        Int16 => abs_numeric(physical_s.i16()?).into_series(),
+        Int32 => abs_numeric(physical_s.i32()?).into_series(),
+        Int64 => abs_numeric(physical_s.i64()?).into_series(),
+        UInt8 | UInt16 | UInt32 | UInt64 => s.clone(),
+        Float32 => abs_numeric(physical_s.f32()?).into_series(),
+        Float64 => abs_numeric(physical_s.f64()?).into_series(),
+        dt => polars_bail!(opq = abs, dt),
+    };
+    out.cast(s.dtype())
+}

crates/polars-ops/src/series/ops/mod.rs

@@ -1,3 +1,5 @@
+#[cfg(feature = "abs")]
+mod abs;
 mod approx_algo;
 #[cfg(feature = "approx_unique")]
 mod approx_unique;
@@ -46,6 +48,8 @@ mod search_sorted;
 mod to_dummies;
 mod various;
 
+#[cfg(feature = "abs")]
+pub use abs::*;
 pub use approx_algo::*;
 #[cfg(feature = "approx_unique")]
 pub use approx_unique::*;

crates/polars-plan/Cargo.toml

@@ -110,7 +110,7 @@ rank = ["polars-ops/rank"]
 diff = ["polars-ops/diff"]
 pct_change = ["polars-ops/pct_change"]
 moment = ["polars-ops/moment"]
-abs = ["polars-core/abs"]
+abs = ["polars-ops/abs"]
 random = ["polars-core/random"]
 dynamic_group_by = ["polars-core/dynamic_group_by"]
 ewma = ["polars-ops/ewma"]

crates/polars-plan/src/dsl/function_expr/abs.rs

@@ -1,5 +1,5 @@
 use super::*;
 
 pub(super) fn abs(s: &Series) -> PolarsResult<Series> {
-    s.abs()
+    polars_ops::prelude::abs(s)
 }

crates/polars-time/src/group_by/dynamic.rs

@@ -659,6 +659,7 @@ fn update_subgroups_idx(
 #[cfg(test)]
 mod test {
     use chrono::prelude::*;
+    use polars_ops::prelude::abs;
 
     use super::*;
 
@@ -777,11 +778,11 @@ mod test {
             "",
             [0.0, 8.0, 4.000000000000002, 6.666666666666667, 24.5, 0.0],
         );
-        assert!((var - expected).abs().unwrap().lt(1e-12).unwrap().all());
+        assert!(abs(&(var - expected)).unwrap().lt(1e-12).unwrap().all());
 
         let var = unsafe { nulls.agg_var(&groups, 1) };
         let expected = Series::new("", [0.0, 8.0, 8.0, 9.333333333333343, 24.5, 0.0]);
-        assert!((var - expected).abs().unwrap().lt(1e-12).unwrap().all());
+        assert!(abs(&(var - expected)).unwrap().lt(1e-12).unwrap().all());
 
         let quantile = unsafe { a.agg_quantile(&groups, 0.5, QuantileInterpolOptions::Linear) };
         let expected = Series::new("", [3.0, 5.0, 5.0, 6.0, 5.5, 1.0]);

crates/polars/Cargo.toml

@@ -150,7 +150,7 @@ range = ["polars-lazy?/range"]
 true_div = ["polars-lazy?/true_div"]
 diagonal_concat = ["polars-core/diagonal_concat", "polars-lazy?/diagonal_concat", "polars-sql?/diagonal_concat"]
 horizontal_concat = ["polars-core/horizontal_concat"]
-abs = ["polars-core/abs", "polars-lazy?/abs"]
+abs = ["polars-ops/abs", "polars-lazy?/abs"]
 dynamic_group_by = ["polars-core/dynamic_group_by", "polars-lazy?/dynamic_group_by"]
 ewma = ["polars-ops/ewma", "polars-lazy?/ewma"]
 dot_diagram = ["polars-lazy?/dot_diagram"]