feat: remove lexical (replace with atoi_simd, ryu, and itao).

Cargo.toml

@@ -45,7 +45,8 @@ hashbrown = { version = "0.14", features = ["rayon", "ahash"] }
 hex = "0.4.3"
 indexmap = { version = "2", features = ["std"] }
 itoa = "1.0.6"
-lexical-core = "0.8.5"
+atoi_simd = "0.15"
+fast-float = { version = "0.2" }
 memchr = "2.6"
 multiversion = "0.7"
 ndarray = { version = "0.15", default-features = false }

crates/polars-arrow/Cargo.toml

@@ -33,7 +33,10 @@ simdutf8 = { workspace = true }
 ethnum = { workspace = true }
 
 # To efficiently cast numbers to strings
-lexical-core = { workspace = true, optional = true }
+atoi_simd = { workspace = true, optional = true }
+fast-float = { workspace = true, optional = true }
+itoa = { workspace = true, optional = true }
+ryu = { workspace = true, optional = true }
 
 regex = { workspace = true, optional = true }
 regex-syntax = { version = "0.8", optional = true }
@@ -134,7 +137,7 @@ compute_arithmetics = ["strength_reduce", "compute_arithmetics_decimal"]
 compute_bitwise = []
 compute_boolean = []
 compute_boolean_kleene = []
-compute_cast = ["lexical-core", "compute_take"]
+compute_cast = ["compute_take", "ryu", "atoi_simd", "itoa", "fast-float"]
 compute_comparison = ["compute_take", "compute_boolean"]
 compute_concatenate = []
 compute_filter = []

crates/polars-arrow/src/compute/cast/binary_to.rs

@@ -6,6 +6,47 @@ use crate::datatypes::ArrowDataType;
 use crate::offset::{Offset, Offsets};
 use crate::types::NativeType;
 
+pub(super) trait Parse {
+    fn parse(val: &[u8]) -> Option<Self>
+    where
+        Self: Sized;
+}
+
+macro_rules! impl_parse {
+    ($primitive_type:ident) => {
+        impl Parse for $primitive_type {
+            fn parse(val: &[u8]) -> Option<Self> {
+                atoi_simd::parse(val).ok()
+            }
+        }
+    };
+}
+impl_parse!(i8);
+impl_parse!(i16);
+impl_parse!(i32);
+impl_parse!(i64);
+impl_parse!(u8);
+impl_parse!(u16);
+impl_parse!(u32);
+impl_parse!(u64);
+
+impl Parse for f32 {
+    fn parse(val: &[u8]) -> Option<Self>
+    where
+        Self: Sized,
+    {
+        fast_float::parse(val).ok()
+    }
+}
+impl Parse for f64 {
+    fn parse(val: &[u8]) -> Option<Self>
+    where
+        Self: Sized,
+    {
+        fast_float::parse(val).ok()
+    }
+}
+
 /// Conversion of binary
 pub fn binary_to_large_binary(
     from: &BinaryArray<i32>,
@@ -61,32 +102,15 @@ pub fn binary_to_large_utf8(
     Utf8Array::<i64>::try_new(to_data_type, offsets, values, from.validity().cloned())
 }
 
-/// Casts a [`BinaryArray`] to a [`PrimitiveArray`] at best-effort using `lexical_core::parse_partial`, making any uncastable value as zero.
-pub fn partial_binary_to_primitive<O: Offset, T>(
-    from: &BinaryArray<O>,
-    to: &ArrowDataType,
-) -> PrimitiveArray<T>
-where
-    T: NativeType + lexical_core::FromLexical,
-{
-    let iter = from
-        .iter()
-        .map(|x| x.and_then::<T, _>(|x| lexical_core::parse_partial(x).ok().map(|x| x.0)));
-
-    PrimitiveArray::<T>::from_trusted_len_iter(iter).to(to.clone())
-}
-
 /// Casts a [`BinaryArray`] to a [`PrimitiveArray`], making any uncastable value a Null.
-pub fn binary_to_primitive<O: Offset, T>(
+pub(super) fn binary_to_primitive<O: Offset, T>(
     from: &BinaryArray<O>,
     to: &ArrowDataType,
 ) -> PrimitiveArray<T>
 where
-    T: NativeType + lexical_core::FromLexical,
+    T: NativeType + Parse,
 {
-    let iter = from
-        .iter()
-        .map(|x| x.and_then::<T, _>(|x| lexical_core::parse(x).ok()));
+    let iter = from.iter().map(|x| x.and_then::<T, _>(|x| T::parse(x)));
 
     PrimitiveArray::<T>::from_trusted_len_iter(iter).to(to.clone())
 }
@@ -97,11 +121,11 @@ pub(super) fn binary_to_primitive_dyn<O: Offset, T>(
     options: CastOptions,
 ) -> PolarsResult<Box<dyn Array>>
 where
-    T: NativeType + lexical_core::FromLexical,
+    T: NativeType + Parse,
 {
     let from = from.as_any().downcast_ref().unwrap();
     if options.partial {
-        Ok(Box::new(partial_binary_to_primitive::<O, T>(from, to)))
+        unimplemented!()
     } else {
         Ok(Box::new(binary_to_primitive::<O, T>(from, to)))
     }

crates/polars-arrow/src/compute/cast/mod.rs

@@ -570,42 +570,21 @@ pub fn cast(
         },
 
         (Utf8, _) => match to_type {
-            UInt8 => utf8_to_primitive_dyn::<i32, u8>(array, to_type, options),
-            UInt16 => utf8_to_primitive_dyn::<i32, u16>(array, to_type, options),
-            UInt32 => utf8_to_primitive_dyn::<i32, u32>(array, to_type, options),
-            UInt64 => utf8_to_primitive_dyn::<i32, u64>(array, to_type, options),
-            Int8 => utf8_to_primitive_dyn::<i32, i8>(array, to_type, options),
-            Int16 => utf8_to_primitive_dyn::<i32, i16>(array, to_type, options),
-            Int32 => utf8_to_primitive_dyn::<i32, i32>(array, to_type, options),
-            Int64 => utf8_to_primitive_dyn::<i32, i64>(array, to_type, options),
-            Float32 => utf8_to_primitive_dyn::<i32, f32>(array, to_type, options),
-            Float64 => utf8_to_primitive_dyn::<i32, f64>(array, to_type, options),
-            Date32 => utf8_to_date32_dyn::<i32>(array),
-            Date64 => utf8_to_date64_dyn::<i32>(array),
             LargeUtf8 => Ok(Box::new(utf8_to_large_utf8(
                 array.as_any().downcast_ref().unwrap(),
             ))),
-            Timestamp(time_unit, None) => {
-                utf8_to_naive_timestamp_dyn::<i32>(array, time_unit.to_owned())
-            },
-            Timestamp(time_unit, Some(time_zone)) => {
-                utf8_to_timestamp_dyn::<i32>(array, time_zone.clone(), time_unit.to_owned())
-            },
             _ => polars_bail!(InvalidOperation:
                 "casting from {from_type:?} to {to_type:?} not supported",
             ),
         },
         (LargeUtf8, _) => match to_type {
-            UInt8 => utf8_to_primitive_dyn::<i64, u8>(array, to_type, options),
-            UInt16 => utf8_to_primitive_dyn::<i64, u16>(array, to_type, options),
-            UInt32 => utf8_to_primitive_dyn::<i64, u32>(array, to_type, options),
-            UInt64 => utf8_to_primitive_dyn::<i64, u64>(array, to_type, options),
-            Int8 => utf8_to_primitive_dyn::<i64, i8>(array, to_type, options),
-            Int16 => utf8_to_primitive_dyn::<i64, i16>(array, to_type, options),
-            Int32 => utf8_to_primitive_dyn::<i64, i32>(array, to_type, options),
-            Int64 => utf8_to_primitive_dyn::<i64, i64>(array, to_type, options),
-            Float32 => utf8_to_primitive_dyn::<i64, f32>(array, to_type, options),
-            Float64 => utf8_to_primitive_dyn::<i64, f64>(array, to_type, options),
+            UInt8 | UInt16 | UInt32 | UInt64 | Int8 | Int16 | Int32 | Int64 | Float32 | Float64 => {
+                let binary = utf8_to_binary::<i64>(
+                    array.as_any().downcast_ref().unwrap(),
+                    ArrowDataType::LargeBinary,
+                );
+                cast(&binary, to_type, options)
+            },
             Date32 => utf8_to_date32_dyn::<i64>(array),
             Date64 => utf8_to_date64_dyn::<i64>(array),
             Utf8 => utf8_large_to_utf8(array.as_any().downcast_ref().unwrap()).map(|x| x.boxed()),