polars-ops 0.54.4

More operations on Polars data structures
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
102
103
104
105
106
107
108
109

use std::fmt::Write;

use polars_core::prelude::arity::broadcast_binary_elementwise;
use polars_core::prelude::{StringChunked, UInt64Chunked};

fn pad_fn<'a>(
    s: Option<&'a str>,
    length: Option<u64>,
    buf: &mut String,
    fill_char: char,
    pad_start: bool,
) -> Option<&'a str> {
    if let (Some(s), Some(length)) = (s, length) {
        let length = length as usize;
        let n_chars = s.chars().count();
        if length <= n_chars {
            return Some(s);
        }
        let padding = length - n_chars;
        buf.clear();
        if !pad_start {
            buf.push_str(s);
        }
        for _ in 0..padding {
            buf.push(fill_char)
        }
        if pad_start {
            buf.push_str(s);
        }
        // extend lifetime
        // lifetime is bound to 'a
        let slice = buf.as_str();
        Some(unsafe { std::mem::transmute::<&str, &'a str>(slice) })
    } else {
        None
    }
}

fn zfill_fn<'a>(s: Option<&'a str>, length: Option<u64>, buf: &mut String) -> Option<&'a str> {
    if let (Some(s), Some(length)) = (s, length) {
        let s_len = s.len();
        let length = length as usize;
        if length <= s_len {
            return Some(s);
        }
        buf.clear();
        let length = length - s_len;
        if let Some(stripped) = s.strip_prefix('-') {
            write!(buf, "-{:0length$}{stripped}", 0,).unwrap();
        } else if let Some(stripped) = s.strip_prefix('+') {
            write!(buf, "+{:0length$}{stripped}", 0,).unwrap();
        } else {
            write!(buf, "{:0length$}{s}", 0,).unwrap();
        };
        // extend lifetime
        // lifetime is bound to 'a
        let slice = buf.as_str();
        Some(unsafe { std::mem::transmute::<&str, &'a str>(slice) })
    } else {
        None
    }
}

pub(super) fn zfill<'a>(ca: &'a StringChunked, length: &'a UInt64Chunked) -> StringChunked {
    // amortize allocation
    let mut buf = String::new();
    fn infer<F: for<'a> FnMut(Option<&'a str>, Option<u64>) -> Option<&'a str>>(f: F) -> F where {
        f
    }
    broadcast_binary_elementwise(
        ca,
        length,
        infer(|opt_s, opt_len| zfill_fn(opt_s, opt_len, &mut buf)),
    )
}

pub(super) fn pad_start<'a>(
    ca: &'a StringChunked,
    length: &'a UInt64Chunked,
    fill_char: char,
) -> StringChunked {
    // amortize allocation
    let mut buf = String::new();
    fn infer<F: for<'a> FnMut(Option<&'a str>, Option<u64>) -> Option<&'a str>>(f: F) -> F where {
        f
    }
    broadcast_binary_elementwise(
        ca,
        length,
        infer(|opt_s, opt_len| pad_fn(opt_s, opt_len, &mut buf, fill_char, true)),
    )
}

pub(super) fn pad_end<'a>(
    ca: &'a StringChunked,
    length: &'a UInt64Chunked,
    fill_char: char,
) -> StringChunked {
    // amortize allocation
    let mut buf = String::new();
    fn infer<F: for<'a> FnMut(Option<&'a str>, Option<u64>) -> Option<&'a str>>(f: F) -> F where {
        f
    }
    broadcast_binary_elementwise(
        ca,
        length,
        infer(|opt_s, opt_len| pad_fn(opt_s, opt_len, &mut buf, fill_char, false)),
    )
}