Skip to content

Math

Math routines for PySpark.

div_or_else(cola, colb, default=0.0)

Return result of division of cola by colb or default if colb is zero.

Parameters:

Name Type Description Default
cola Column

dividend

required
colb Column

divisor

required
default Union[float, Column]

default value

0.0

Returns:

Type Description
Column

result of division or zero

Source code in quinn/math.py
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
def div_or_else(
    cola: Column,
    colb: Column,
    default: Union[float, Column] = 0.0,
) -> Column:
    """Return result of division of cola by colb or default if colb is zero.

    :param cola: dividend
    :param colb: divisor
    :param default: default value
    :returns: result of division or zero
    """
    if not isinstance(default, Column):
        default = F.lit(default)

    return F.when(colb == F.lit(0.0), default).otherwise(cola / colb)

rand_laplace(mu, beta, seed=None)

Generate random numbers from Laplace(mu, beta).

Parameters:

Name Type Description Default
mu Union[float, Column]

mu parameter of Laplace distribution

required
beta Union[float, Column]

beta parameter of Laplace distribution

required
seed Optional[int]

random seed value (optional, default None)

None

Returns:

Type Description
Column

column with random numbers

Source code in quinn/math.py
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
def rand_laplace(
    mu: Union[float, Column],
    beta: Union[float, Column],
    seed: Optional[int] = None,
) -> Column:
    """Generate random numbers from Laplace(mu, beta).

    :param mu: mu parameter of Laplace distribution
    :param beta: beta parameter of Laplace distribution
    :param seed: random seed value (optional, default None)
    :returns: column with random numbers
    """
    if not isinstance(mu, Column):
        mu = F.lit(mu)

    if not isinstance(beta, Column):
        beta = F.lit(beta)

    u = F.rand(seed)

    return (
        F.when(u < F.lit(0.5), mu + beta * F.log(2 * u))
        .otherwise(mu - beta * F.log(2 * (1 - u)))
        .alias("laplace_random")
    )