You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by vi...@apache.org on 2022/08/23 07:06:54 UTC
[arrow-rs] branch master updated: Add test for float nan comparison (#2555)
This is an automated email from the ASF dual-hosted git repository.
viirya pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow-rs.git
The following commit(s) were added to refs/heads/master by this push:
new 0771b0112 Add test for float nan comparison (#2555)
0771b0112 is described below
commit 0771b011226eed5de67805e131e44ab273baf601
Author: Liang-Chi Hsieh <vi...@gmail.com>
AuthorDate: Tue Aug 23 00:06:49 2022 -0700
Add test for float nan comparison (#2555)
* Add test for float nan comparison
* Add more tests
---
arrow/src/compute/kernels/comparison.rs | 210 ++++++++++++++++++++++++++++++++
1 file changed, 210 insertions(+)
diff --git a/arrow/src/compute/kernels/comparison.rs b/arrow/src/compute/kernels/comparison.rs
index a94078f4d..39828b64f 100644
--- a/arrow/src/compute/kernels/comparison.rs
+++ b/arrow/src/compute/kernels/comparison.rs
@@ -5278,4 +5278,214 @@ mod tests {
BooleanArray::from(vec![Some(true), None, Some(false)])
);
}
+
+ #[test]
+ fn test_eq_dyn_neq_dyn_float_nan() {
+ let array1: Float32Array = vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let array2: Float32Array = vec![f32::NAN, f32::NAN, 8.0, 8.0, 10.0]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(true), Some(true), Some(true)],
+ );
+ assert_eq!(eq_dyn(&array1, &array2).unwrap(), expected);
+
+ let expected = BooleanArray::from(
+ vec![Some(true), Some(true), Some(false), Some(false), Some(false)],
+ );
+ assert_eq!(neq_dyn(&array1, &array2).unwrap(), expected);
+
+ let array1: Float64Array = vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let array2: Float64Array = vec![f64::NAN, f64::NAN, 8.0, 8.0, 10.0]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(true), Some(true), Some(true)],
+ );
+ assert_eq!(eq_dyn(&array1, &array2).unwrap(), expected);
+
+ let expected = BooleanArray::from(
+ vec![Some(true), Some(true), Some(false), Some(false), Some(false)],
+ );
+ assert_eq!(neq_dyn(&array1, &array2).unwrap(), expected);
+ }
+
+ #[test]
+ fn test_lt_dyn_lt_eq_dyn_float_nan() {
+ let array1: Float32Array = vec![f32::NAN, 7.0, 8.0, 8.0, 11.0, f32::NAN]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let array2: Float32Array = vec![f32::NAN, f32::NAN, 8.0, 9.0, 10.0, 1.0]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(false), Some(true), Some(false), Some(false)],
+ );
+ assert_eq!(lt_dyn(&array1, &array2).unwrap(), expected);
+
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(true), Some(true), Some(false), Some(false)],
+ );
+ assert_eq!(lt_eq_dyn(&array1, &array2).unwrap(), expected);
+
+ let array1: Float64Array = vec![f64::NAN, 7.0, 8.0, 8.0, 11.0, f64::NAN]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let array2: Float64Array = vec![f64::NAN, f64::NAN, 8.0, 9.0, 10.0, 1.0]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(false), Some(true), Some(false), Some(false)],
+ );
+ assert_eq!(lt_dyn(&array1, &array2).unwrap(), expected);
+
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(true), Some(true), Some(false), Some(false)],
+ );
+ assert_eq!(lt_eq_dyn(&array1, &array2).unwrap(), expected);
+ }
+
+ #[test]
+ fn test_gt_dyn_gt_eq_dyn_float_nan() {
+ let array1: Float32Array = vec![f32::NAN, 7.0, 8.0, 8.0, 11.0, f32::NAN]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let array2: Float32Array = vec![f32::NAN, f32::NAN, 8.0, 9.0, 10.0, 1.0]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(false), Some(false), Some(true), Some(false)],
+ );
+ assert_eq!(gt_dyn(&array1, &array2).unwrap(), expected);
+
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(true), Some(false), Some(true), Some(false)],
+ );
+ assert_eq!(gt_eq_dyn(&array1, &array2).unwrap(), expected);
+
+ let array1: Float64Array = vec![f64::NAN, 7.0, 8.0, 8.0, 11.0, f64::NAN]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let array2: Float64Array = vec![f64::NAN, f64::NAN, 8.0, 9.0, 10.0, 1.0]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(false), Some(false), Some(true), Some(false)],
+ );
+ assert_eq!(gt_dyn(&array1, &array2).unwrap(), expected);
+
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(true), Some(false), Some(true), Some(false)],
+ );
+ assert_eq!(gt_eq_dyn(&array1, &array2).unwrap(), expected);
+ }
+
+ #[test]
+ fn test_eq_dyn_scalar_neq_dyn_scalar_float_nan() {
+ let array: Float32Array = vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(false), Some(false), Some(false)],
+ );
+ assert_eq!(eq_dyn_scalar(&array, f32::NAN).unwrap(), expected);
+
+ let expected = BooleanArray::from(
+ vec![Some(true), Some(true), Some(true), Some(true), Some(true)],
+ );
+ assert_eq!(neq_dyn_scalar(&array, f32::NAN).unwrap(), expected);
+
+ let array: Float64Array = vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(false), Some(false), Some(false)],
+ );
+ assert_eq!(eq_dyn_scalar(&array, f64::NAN).unwrap(), expected);
+
+ let expected = BooleanArray::from(
+ vec![Some(true), Some(true), Some(true), Some(true), Some(true)],
+ );
+ assert_eq!(neq_dyn_scalar(&array, f64::NAN).unwrap(), expected);
+ }
+
+ #[test]
+ fn test_lt_dyn_scalar_lt_eq_dyn_scalar_float_nan() {
+ let array: Float32Array = vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(false), Some(false), Some(false)],
+ );
+ assert_eq!(lt_dyn_scalar(&array, f32::NAN).unwrap(), expected);
+
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(false), Some(false), Some(false)],
+ );
+ assert_eq!(lt_eq_dyn_scalar(&array, f32::NAN).unwrap(), expected);
+
+ let array: Float64Array = vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(false), Some(false), Some(false)],
+ );
+ assert_eq!(lt_dyn_scalar(&array, f64::NAN).unwrap(), expected);
+
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(false), Some(false), Some(false)],
+ );
+ assert_eq!(lt_eq_dyn_scalar(&array, f64::NAN).unwrap(), expected);
+ }
+
+ #[test]
+ fn test_gt_dyn_scalar_gt_eq_dyn_scalar_float_nan() {
+ let array: Float32Array = vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(false), Some(false), Some(false)],
+ );
+ assert_eq!(gt_dyn_scalar(&array, f32::NAN).unwrap(), expected);
+
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(false), Some(false), Some(false)],
+ );
+ assert_eq!(gt_eq_dyn_scalar(&array, f32::NAN).unwrap(), expected);
+
+ let array: Float64Array = vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]
+ .into_iter()
+ .map(Some)
+ .collect();
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(false), Some(false), Some(false)],
+ );
+ assert_eq!(gt_dyn_scalar(&array, f64::NAN).unwrap(), expected);
+
+ let expected = BooleanArray::from(
+ vec![Some(false), Some(false), Some(false), Some(false), Some(false)],
+ );
+ assert_eq!(gt_eq_dyn_scalar(&array, f64::NAN).unwrap(), expected);
+ }
}