polars_plan/dsl/
bitwise.rs

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
use super::{BitwiseFunction, Expr, FunctionExpr, FunctionFlags};

impl Expr {
    /// Evaluate the number of set bits.
    pub fn bitwise_count_ones(self) -> Self {
        self.apply_private(FunctionExpr::Bitwise(BitwiseFunction::CountOnes))
    }

    /// Evaluate the number of unset bits.
    pub fn bitwise_count_zeros(self) -> Self {
        self.apply_private(FunctionExpr::Bitwise(BitwiseFunction::CountZeros))
    }

    /// Evaluate the number most-significant set bits before seeing an unset bit.
    pub fn bitwise_leading_ones(self) -> Self {
        self.apply_private(FunctionExpr::Bitwise(BitwiseFunction::LeadingOnes))
    }

    /// Evaluate the number most-significant unset bits before seeing an set bit.
    pub fn bitwise_leading_zeros(self) -> Self {
        self.apply_private(FunctionExpr::Bitwise(BitwiseFunction::LeadingZeros))
    }

    /// Evaluate the number least-significant set bits before seeing an unset bit.
    pub fn bitwise_trailing_ones(self) -> Self {
        self.apply_private(FunctionExpr::Bitwise(BitwiseFunction::TrailingOnes))
    }

    /// Evaluate the number least-significant unset bits before seeing an set bit.
    pub fn bitwise_trailing_zeros(self) -> Self {
        self.apply_private(FunctionExpr::Bitwise(BitwiseFunction::TrailingZeros))
    }

    /// Perform an aggregation of bitwise ANDs
    pub fn bitwise_and(self) -> Self {
        self.apply_private(FunctionExpr::Bitwise(BitwiseFunction::And))
            .with_function_options(|mut options| {
                options.flags |= FunctionFlags::RETURNS_SCALAR;
                options
            })
    }

    /// Perform an aggregation of bitwise ORs
    pub fn bitwise_or(self) -> Self {
        self.apply_private(FunctionExpr::Bitwise(BitwiseFunction::Or))
            .with_function_options(|mut options| {
                options.flags |= FunctionFlags::RETURNS_SCALAR;
                options
            })
    }

    /// Perform an aggregation of bitwise XORs
    pub fn bitwise_xor(self) -> Self {
        self.apply_private(FunctionExpr::Bitwise(BitwiseFunction::Xor))
            .with_function_options(|mut options| {
                options.flags |= FunctionFlags::RETURNS_SCALAR;
                options
            })
    }
}