manual implement series trait and impl bitwise operations

polars/Cargo.toml

@@ -95,6 +95,7 @@ diff = ["polars-core/diff", "polars-lazy/diff"]
 moment = ["polars-core/moment", "polars-lazy/moment"]
 arange = ["polars-lazy/arange"]
 true_div = ["polars-lazy/true_div"]
+series_bitwise = ["polars-core/series_bitwise"]
 
 # don't use this
 private = []

polars/polars-core/Cargo.toml

@@ -75,6 +75,7 @@ list = []
 rank = []
 diff = []
 moment = []
+series_bitwise = []
 
 
 # opt-in datatypes for Series

polars/polars-core/src/chunked_array/arithmetic.rs

@@ -543,6 +543,144 @@ impl Pow for Utf8Chunked {}
 impl Pow for ListChunked {}
 impl Pow for CategoricalChunked {}
 
+#[cfg(feature = "series_bitwise")]
+mod bitwise {
+    use super::*;
+    use crate::utils::{combine_validities, CustomIterTools};
+    use std::ops::{BitAnd, BitOr, BitXor};
+
+    impl<T> BitAnd for &ChunkedArray<T>
+    where
+        T: PolarsIntegerType,
+        T::Native: BitAnd<Output = T::Native>,
+    {
+        type Output = ChunkedArray<T>;
+
+        fn bitand(self, rhs: Self) -> Self::Output {
+            let (l, r) = align_chunks_binary(self, rhs);
+            let chunks = l
+                .downcast_iter()
+                .zip(r.downcast_iter())
+                .map(|(l_arr, r_arr)| {
+                    let l_vals = l_arr.values().as_slice();
+                    let r_vals = l_arr.values().as_slice();
+                    let valididity =
+                        combine_validities(l_arr.validity().as_ref(), r_arr.validity().as_ref());
+
+                    let av = l_vals
+                        .iter()
+                        .zip(r_vals)
+                        .map(|(l, r)| *l & *r)
+                        .collect_trusted::<AlignedVec<_>>();
+
+                    let arr =
+                        PrimitiveArray::from_data(T::get_dtype().to_arrow(), av.into(), valididity);
+                    Arc::new(arr) as ArrayRef
+                })
+                .collect::<Vec<_>>();
+
+            ChunkedArray::new_from_chunks(self.name(), chunks)
+        }
+    }
+
+    impl<T> BitOr for &ChunkedArray<T>
+    where
+        T: PolarsIntegerType,
+        T::Native: BitOr<Output = T::Native>,
+    {
+        type Output = ChunkedArray<T>;
+
+        fn bitor(self, rhs: Self) -> Self::Output {
+            let (l, r) = align_chunks_binary(self, rhs);
+            let chunks = l
+                .downcast_iter()
+                .zip(r.downcast_iter())
+                .map(|(l_arr, r_arr)| {
+                    let l_vals = l_arr.values().as_slice();
+                    let r_vals = l_arr.values().as_slice();
+                    let valididity =
+                        combine_validities(l_arr.validity().as_ref(), r_arr.validity().as_ref());
+
+                    let av = l_vals
+                        .iter()
+                        .zip(r_vals)
+                        .map(|(l, r)| *l | *r)
+                        .collect_trusted::<AlignedVec<_>>();
+
+                    let arr =
+                        PrimitiveArray::from_data(T::get_dtype().to_arrow(), av.into(), valididity);
+                    Arc::new(arr) as ArrayRef
+                })
+                .collect::<Vec<_>>();
+
+            ChunkedArray::new_from_chunks(self.name(), chunks)
+        }
+    }
+
+    impl<T> BitXor for &ChunkedArray<T>
+    where
+        T: PolarsIntegerType,
+        T::Native: BitXor<Output = T::Native>,
+    {
+        type Output = ChunkedArray<T>;
+
+        fn bitxor(self, rhs: Self) -> Self::Output {
+            let (l, r) = align_chunks_binary(self, rhs);
+            let chunks = l
+                .downcast_iter()
+                .zip(r.downcast_iter())
+                .map(|(l_arr, r_arr)| {
+                    let l_vals = l_arr.values().as_slice();
+                    let r_vals = l_arr.values().as_slice();
+                    let valididity =
+                        combine_validities(l_arr.validity().as_ref(), r_arr.validity().as_ref());
+
+                    let av = l_vals
+                        .iter()
+                        .zip(r_vals)
+                        .map(|(l, r)| l.bitxor(*r))
+                        .collect_trusted::<AlignedVec<_>>();
+
+                    let arr =
+                        PrimitiveArray::from_data(T::get_dtype().to_arrow(), av.into(), valididity);
+                    Arc::new(arr) as ArrayRef
+                })
+                .collect::<Vec<_>>();
+
+            ChunkedArray::new_from_chunks(self.name(), chunks)
+        }
+    }
+
+    macro_rules! impl_floats {
+        ($_type:ty) => {
+            impl BitXor for &$_type {
+                type Output = $_type;
+
+                fn bitxor(self, _rhs: Self) -> Self::Output {
+                    unimplemented!()
+                }
+            }
+            impl BitAnd for &$_type {
+                type Output = $_type;
+
+                fn bitand(self, _rhs: Self) -> Self::Output {
+                    unimplemented!()
+                }
+            }
+            impl BitOr for &$_type {
+                type Output = $_type;
+
+                fn bitor(self, _rhs: Self) -> Self::Output {
+                    unimplemented!()
+                }
+            }
+        };
+    }
+
+    impl_floats!(Float64Chunked);
+    impl_floats!(Float32Chunked);
+}
+
 #[cfg(test)]
 pub(crate) mod test {
     use crate::prelude::*;

polars/polars-core/src/chunked_array/ops/rolling_window.rs

@@ -401,14 +401,6 @@ where
     }
 }
 
-impl ChunkWindow for ListChunked {}
-impl ChunkWindow for Utf8Chunked {}
-impl ChunkWindow for BooleanChunked {}
-#[cfg(feature = "dtype-categorical")]
-impl ChunkWindow for CategoricalChunked {}
-#[cfg(feature = "object")]
-impl<T> ChunkWindow for ObjectChunked<T> {}
-
 impl<T> ChunkRollApply for ChunkedArray<T>
 where
     T: PolarsNumericType,

polars/polars-core/src/chunked_array/ops/sort.rs

@@ -397,20 +397,6 @@ impl ChunkSort<CategoricalType> for CategoricalChunked {
     }
 }
 
-impl ChunkSort<ListType> for ListChunked {
-    fn sort(&self, _reverse: bool) -> Self {
-        unimplemented!()
-    }
-
-    fn sort_in_place(&mut self, _reverse: bool) {
-        unimplemented!()
-    }
-
-    fn argsort(&self, _reverse: bool) -> UInt32Chunked {
-        unimplemented!()
-    }
-}
-
 #[cfg(feature = "object")]
 impl<T> ChunkSort<ObjectType<T>> for ObjectChunked<T> {
     fn sort(&self, _reverse: bool) -> Self {

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

@@ -91,19 +91,6 @@ macro_rules! is_unique_duplicated {
     }};
 }
 
-impl ChunkUnique<ListType> for ListChunked {
-    fn unique(&self) -> Result<ChunkedArray<ListType>> {
-        Err(PolarsError::InvalidOperation(
-            "unique not supported for list".into(),
-        ))
-    }
-
-    fn arg_unique(&self) -> Result<UInt32Chunked> {
-        Err(PolarsError::InvalidOperation(
-            "unique not supported for list".into(),
-        ))
-    }
-}
 #[cfg(feature = "object")]
 impl<T> ChunkUnique<ObjectType<T>> for ObjectChunked<T> {
     fn unique(&self) -> Result<ChunkedArray<ObjectType<T>>> {
@@ -397,7 +384,6 @@ where
     }
 }
 
-impl ToDummies<ListType> for ListChunked {}
 #[cfg(feature = "object")]
 impl<T> ToDummies<ObjectType<T>> for ObjectChunked<T> {}
 impl ToDummies<Float32Type> for Float32Chunked {}

polars/polars-core/src/series/arithmetic.rs

@@ -104,9 +104,6 @@ impl NumOpsDispatch for Utf8Chunked {
         Ok(out.into_series())
     }
 }
-impl NumOpsDispatch for BooleanChunked {}
-impl NumOpsDispatch for ListChunked {}
-impl NumOpsDispatch for CategoricalChunked {}
 
 #[cfg(feature = "checked_arithmetic")]
 pub mod checked {