arrow2 0.18.0

Unofficial implementation of Apache Arrow spec in safe Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use arrow2::array::*;
use arrow2::compute::arithmetics::basic::*;
use arrow2::compute::arithmetics::{ArrayCheckedDiv, ArrayDiv};

#[test]
#[should_panic]
fn test_div_mismatched_length() {
    let a = Int32Array::from_slice([5, 6]);
    let b = Int32Array::from_slice([5]);
    div(&a, &b);
}

#[test]
fn test_div() {
    let a = Int32Array::from(&[Some(5), Some(6)]);
    let b = Int32Array::from(&[Some(5), Some(6)]);
    let result = div(&a, &b);
    let expected = Int32Array::from(&[Some(1), Some(1)]);
    assert_eq!(result, expected);

    // Trait testing
    let result = a.div(&b);
    assert_eq!(result, expected);
}

#[test]
#[should_panic]
fn test_div_panic() {
    let a = Int8Array::from(&[Some(10i8)]);
    let b = Int8Array::from(&[Some(0i8)]);
    let _ = div(&a, &b);
}

#[test]
fn test_div_checked() {
    let a = Int32Array::from(&[Some(5), None, Some(3), Some(6)]);
    let b = Int32Array::from(&[Some(5), Some(3), None, Some(6)]);
    let result = checked_div(&a, &b);
    let expected = Int32Array::from(&[Some(1), None, None, Some(1)]);
    assert_eq!(result, expected);

    let a = Int32Array::from(&[Some(5), None, Some(3), Some(6)]);
    let b = Int32Array::from(&[Some(5), Some(0), Some(0), Some(6)]);
    let result = checked_div(&a, &b);
    let expected = Int32Array::from(&[Some(1), None, None, Some(1)]);
    assert_eq!(result, expected);

    // Trait testing
    let result = a.checked_div(&b);
    assert_eq!(result, expected);
}

#[test]
fn test_div_scalar() {
    let a = Int32Array::from(&[None, Some(6), None, Some(6)]);
    let result = div_scalar(&a, &1i32);
    let expected = Int32Array::from(&[None, Some(6), None, Some(6)]);
    assert_eq!(result, expected);

    // Trait testing
    let result = a.div(&1i32);
    assert_eq!(result, expected);

    // check the strength reduced branches
    let a = UInt64Array::from(&[None, Some(6), None, Some(6)]);
    let result = div_scalar(&a, &1u64);
    let expected = UInt64Array::from(&[None, Some(6), None, Some(6)]);
    assert_eq!(result, expected);

    let a = UInt32Array::from(&[None, Some(6), None, Some(6)]);
    let result = div_scalar(&a, &1u32);
    let expected = UInt32Array::from(&[None, Some(6), None, Some(6)]);
    assert_eq!(result, expected);

    let a = UInt16Array::from(&[None, Some(6), None, Some(6)]);
    let result = div_scalar(&a, &1u16);
    let expected = UInt16Array::from(&[None, Some(6), None, Some(6)]);
    assert_eq!(result, expected);

    let a = UInt8Array::from(&[None, Some(6), None, Some(6)]);
    let result = div_scalar(&a, &1u8);
    let expected = UInt8Array::from(&[None, Some(6), None, Some(6)]);
    assert_eq!(result, expected);
}

#[test]
fn test_div_scalar_checked() {
    let a = Int32Array::from(&[None, Some(6), None, Some(6)]);
    let result = checked_div_scalar(&a, &1i32);
    let expected = Int32Array::from(&[None, Some(6), None, Some(6)]);
    assert_eq!(result, expected);

    let a = Int32Array::from(&[None, Some(6), None, Some(6)]);
    let result = checked_div_scalar(&a, &0);
    let expected = Int32Array::from(&[None, None, None, None]);
    assert_eq!(result, expected);

    // Trait testing
    let result = a.checked_div(&0);
    assert_eq!(result, expected);
}