Numeric and Boolean expressions

Integer, floating point, decimal, and boolean expressions.

NumericValue

NumericValue(arg)

Methods

Name	Description
abs	Return the absolute value of `self`.
acos	Compute the arc cosine of `self`.
asin	Compute the arc sine of `self`.
atan	Compute the arc tangent of `self`.
atan2	Compute the two-argument version of arc tangent.
ceil	Return the ceiling of `self`.
clip	Trim values outside of `lower` and `upper` bounds.
cos	Compute the cosine of `self`.
cot	Compute the cotangent of `self`.
degrees	Compute the degrees of `self` radians.
exp	Compute \(e^\texttt{self}\).
floor	Return the floor of an expression.
ln	Compute \(\ln\left(\texttt{self}\right)\).
log	Compute \(\log_{\texttt{base}}\left(\texttt{self}\right)\).
log10	Compute \(\log_{10}\left(\texttt{self}\right)\).
log2	Compute \(\log_{2}\left(\texttt{self}\right)\).
negate	Negate a numeric expression.
point	Return a point constructed from the coordinate values.
radians	Compute radians from `self` degrees.
round	Round values to an indicated number of decimal places.
sign	Return the sign of the input.
sin	Compute the sine of `self`.
sqrt	Compute the square root of `self`.
tan	Compute the tangent of `self`.

abs

abs()

Return the absolute value of self.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [-1, 2, -3, 4]})
>>> t.values.abs()

┏━━━━━━━━━━━━━┓
┃ Abs(values) ┃
┡━━━━━━━━━━━━━┩
│ int64       │
├─────────────┤
│           1 │
│           2 │
│           3 │
│           4 │
└─────────────┘

acos

acos()

Compute the arc cosine of self.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [-1, 0, 1]})
>>> t.values.acos()

┏━━━━━━━━━━━━━━┓
┃ Acos(values) ┃
┡━━━━━━━━━━━━━━┩
│ float64      │
├──────────────┤
│     3.141593 │
│     1.570796 │
│     0.000000 │
└──────────────┘

asin

asin()

Compute the arc sine of self.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [-1, 0, 1]})
>>> t.values.asin()

┏━━━━━━━━━━━━━━┓
┃ Asin(values) ┃
┡━━━━━━━━━━━━━━┩
│ float64      │
├──────────────┤
│    -1.570796 │
│     0.000000 │
│     1.570796 │
└──────────────┘

atan

atan()

Compute the arc tangent of self.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [-1, 0, 1]})
>>> t.values.atan()

┏━━━━━━━━━━━━━━┓
┃ Atan(values) ┃
┡━━━━━━━━━━━━━━┩
│ float64      │
├──────────────┤
│    -0.785398 │
│     0.000000 │
│     0.785398 │
└──────────────┘

atan2

atan2(other, /)

Compute the two-argument version of arc tangent.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [-1, 0, 1]})
>>> t.values.atan2(0)

┏━━━━━━━━━━━━━━━━━━┓
┃ Atan2(values, 0) ┃
┡━━━━━━━━━━━━━━━━━━┩
│ float64          │
├──────────────────┤
│        -1.570796 │
│         0.000000 │
│         1.570796 │
└──────────────────┘

ceil

ceil()

Return the ceiling of self.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [1, 1.1, 2, 2.1, 3.3]})
>>> t.values.ceil()

┏━━━━━━━━━━━━━━┓
┃ Ceil(values) ┃
┡━━━━━━━━━━━━━━┩
│ int64        │
├──────────────┤
│            1 │
│            2 │
│            2 │
│            3 │
│            4 │
└──────────────┘

clip

clip(lower=None, upper=None)

Trim values outside of lower and upper bounds.

NULL values are preserved and are not replaced with bounds.

Parameters

Name	Type	Description	Default
lower	NumericValue \| None	Lower bound	`None`
upper	NumericValue \| None	Upper bound	`None`

Returns

Name	Type	Description
	NumericValue	Clipped input

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable(
...     {"values": [None, 2, 3, None, 5, None, None, 8]},
...     schema=dict(values="int"),
... )
>>> t.values.clip(lower=3, upper=6)

┏━━━━━━━━━━━━━━━━━━━━┓
┃ Clip(values, 3, 6) ┃
┡━━━━━━━━━━━━━━━━━━━━┩
│ int64              │
├────────────────────┤
│               NULL │
│                  3 │
│                  3 │
│               NULL │
│                  5 │
│               NULL │
│               NULL │
│                  6 │
└────────────────────┘

cos

cos()

Compute the cosine of self.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [-1, 0, 1]})
>>> t.values.cos()

┏━━━━━━━━━━━━━┓
┃ Cos(values) ┃
┡━━━━━━━━━━━━━┩
│ float64     │
├─────────────┤
│    0.540302 │
│    1.000000 │
│    0.540302 │
└─────────────┘

cot

cot()

Compute the cotangent of self.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [-1, -2, 3]})
>>> t.values.cot()

┏━━━━━━━━━━━━━┓
┃ Cot(values) ┃
┡━━━━━━━━━━━━━┩
│ float64     │
├─────────────┤
│   -0.642093 │
│    0.457658 │
│   -7.015253 │
└─────────────┘

degrees

degrees()

Compute the degrees of self radians.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> from math import pi
>>> t = ibis.memtable({"values": [0, pi / 2, pi, 3 * pi / 2, 2 * pi]})
>>> t.values.degrees()

┏━━━━━━━━━━━━━━━━━┓
┃ Degrees(values) ┃
┡━━━━━━━━━━━━━━━━━┩
│ float64         │
├─────────────────┤
│             0.0 │
│            90.0 │
│           180.0 │
│           270.0 │
│           360.0 │
└─────────────────┘

exp

exp()

Compute \(e^\texttt{self}\).

Returns

Name	Type	Description
	NumericValue	\(e^\texttt{self}\)

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": range(4)})
>>> t.values.exp()

┏━━━━━━━━━━━━━┓
┃ Exp(values) ┃
┡━━━━━━━━━━━━━┩
│ float64     │
├─────────────┤
│    1.000000 │
│    2.718282 │
│    7.389056 │
│   20.085537 │
└─────────────┘

floor

floor()

Return the floor of an expression.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [1, 1.1, 2, 2.1, 3.3]})
>>> t.values.floor()

┏━━━━━━━━━━━━━━━┓
┃ Floor(values) ┃
┡━━━━━━━━━━━━━━━┩
│ int64         │
├───────────────┤
│             1 │
│             1 │
│             2 │
│             2 │
│             3 │
└───────────────┘

ln

ln()

Compute \(\ln\left(\texttt{self}\right)\).

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [1, 2.718281828, 3]})
>>> t.values.ln()

┏━━━━━━━━━━━━┓
┃ Ln(values) ┃
┡━━━━━━━━━━━━┩
│ float64    │
├────────────┤
│   0.000000 │
│   1.000000 │
│   1.098612 │
└────────────┘

log

log(base=None, /)

Compute \(\log_{\texttt{base}}\left(\texttt{self}\right)\).

Parameters

Name	Type	Description	Default
base	NumericValue \| None	The base of the logarithm. If `None`, base `e` is used.	`None`

Returns

Name	Type	Description
	NumericValue	Logarithm of `arg` with base `base`

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> from math import e
>>> t = ibis.memtable({"values": [e, e**2, e**3]})
>>> t.values.log()

┏━━━━━━━━━━━━━┓
┃ Log(values) ┃
┡━━━━━━━━━━━━━┩
│ float64     │
├─────────────┤
│         1.0 │
│         2.0 │
│         3.0 │
└─────────────┘

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [10, 100, 1000]})
>>> t.values.log(10)

┏━━━━━━━━━━━━━━━━━┓
┃ Log(values, 10) ┃
┡━━━━━━━━━━━━━━━━━┩
│ float64         │
├─────────────────┤
│             1.0 │
│             2.0 │
│             3.0 │
└─────────────────┘

log10

log10()

Compute \(\log_{10}\left(\texttt{self}\right)\).

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [1, 10, 100]})
>>> t.values.log10()

┏━━━━━━━━━━━━━━━┓
┃ Log10(values) ┃
┡━━━━━━━━━━━━━━━┩
│ float64       │
├───────────────┤
│           0.0 │
│           1.0 │
│           2.0 │
└───────────────┘

log2

log2()

Compute \(\log_{2}\left(\texttt{self}\right)\).

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [1, 2, 4, 8]})
>>> t.values.log2()

┏━━━━━━━━━━━━━━┓
┃ Log2(values) ┃
┡━━━━━━━━━━━━━━┩
│ float64      │
├──────────────┤
│          0.0 │
│          1.0 │
│          2.0 │
│          3.0 │
└──────────────┘

negate

negate()

Negate a numeric expression.

Returns

Name	Type	Description
	NumericValue	A numeric value expression

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [-1, 0, 1]})
>>> t.values.negate()

┏━━━━━━━━━━━━━━━━┓
┃ Negate(values) ┃
┡━━━━━━━━━━━━━━━━┩
│ int64          │
├────────────────┤
│              1 │
│              0 │
│             -1 │
└────────────────┘

point

point(right, /)

Return a point constructed from the coordinate values.

Constant coordinates result in construction of a POINT literal or column.

Parameters

Name	Type	Description	Default
right	int \| float \| NumericValue	Y coordinate	required

Returns

Name	Type	Description
	`PointValue`	Points

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.examples.zones.fetch()
>>> t.x_cent.point(t.y_cent)

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ GeoPoint(x_cent, y_cent)         ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ point:geometry                   │
├──────────────────────────────────┤
│ <POINT (935996.821 191376.75)>   │
│ <POINT (1031085.719 164018.754)> │
│ <POINT (1026452.617 254265.479)> │
│ <POINT (990633.981 202959.782)>  │
│ <POINT (931871.37 140681.351)>   │
│ <POINT (964319.735 157998.936)>  │
│ <POINT (1006496.679 216719.218)> │
│ <POINT (1005551.571 222936.088)> │
│ <POINT (1043002.677 212969.849)> │
│ <POINT (1042223.605 186706.496)> │
│ …                                │
└──────────────────────────────────┘

radians

radians()

Compute radians from self degrees.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [0, 90, 180, 270, 360]})
>>> t.values.radians()

┏━━━━━━━━━━━━━━━━━┓
┃ Radians(values) ┃
┡━━━━━━━━━━━━━━━━━┩
│ float64         │
├─────────────────┤
│        0.000000 │
│        1.570796 │
│        3.141593 │
│        4.712389 │
│        6.283185 │
└─────────────────┘

round

round(digits=0, /)

Round values to an indicated number of decimal places.

Parameters

Name	Type	Description	Default
digits	int \| IntegerValue	The number of digits to round to. Here’s how the `digits` parameter affects the expression output type: - `digits` is `False`-y; `self.type()` is `decimal` → `decimal` - `digits` is nonzero; `self.type()` is `decimal` → `decimal` - `digits` is `False`-y; `self.type()` is Floating → `int64` - `digits` is nonzero; `self.type()` is Floating → `float64`	`0`

Returns

Name	Type	Description
	NumericValue	The rounded expression

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [1.22, 1.64, 2.15, 2.54]})
>>> t

┏━━━━━━━━━┓
┃ values  ┃
┡━━━━━━━━━┩
│ float64 │
├─────────┤
│    1.22 │
│    1.64 │
│    2.15 │
│    2.54 │
└─────────┘

>>> t.values.round()

┏━━━━━━━━━━━━━━━━━━┓
┃ Round(values, 0) ┃
┡━━━━━━━━━━━━━━━━━━┩
│ int64            │
├──────────────────┤
│                1 │
│                2 │
│                2 │
│                3 │
└──────────────────┘

>>> t.values.round(1)

┏━━━━━━━━━━━━━━━━━━┓
┃ Round(values, 1) ┃
┡━━━━━━━━━━━━━━━━━━┩
│ float64          │
├──────────────────┤
│              1.2 │
│              1.6 │
│              2.2 │
│              2.5 │
└──────────────────┘

sign

sign()

Return the sign of the input.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [-1, 2, -3, 4]})
>>> t.values.sign()

┏━━━━━━━━━━━━━━┓
┃ Sign(values) ┃
┡━━━━━━━━━━━━━━┩
│ int64        │
├──────────────┤
│           -1 │
│            1 │
│           -1 │
│            1 │
└──────────────┘

sin

sin()

Compute the sine of self.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [-1, 0, 1]})
>>> t.values.sin()

┏━━━━━━━━━━━━━┓
┃ Sin(values) ┃
┡━━━━━━━━━━━━━┩
│ float64     │
├─────────────┤
│   -0.841471 │
│    0.000000 │
│    0.841471 │
└─────────────┘

sqrt

sqrt()

Compute the square root of self.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [1, 4, 9, 16]})
>>> t.values.sqrt()

┏━━━━━━━━━━━━━━┓
┃ Sqrt(values) ┃
┡━━━━━━━━━━━━━━┩
│ float64      │
├──────────────┤
│          1.0 │
│          2.0 │
│          3.0 │
│          4.0 │
└──────────────┘

tan

tan()

Compute the tangent of self.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [-1, 0, 1]})
>>> t.values.tan()

┏━━━━━━━━━━━━━┓
┃ Tan(values) ┃
┡━━━━━━━━━━━━━┩
│ float64     │
├─────────────┤
│   -1.557408 │
│    0.000000 │
│    1.557408 │
└─────────────┘

NumericColumn

NumericColumn(arg)

Methods

Name	Description
approx_quantile	Compute one or more approximate quantiles of a column.
bucket	Compute a discrete binning of a numeric array.
corr	Return the correlation of two numeric columns.
cov	Return the covariance of two numeric columns.
cummean	Return the cumulative mean of the input.
cumsum	Return the cumulative sum of the input.
histogram	Compute a histogram with fixed width bins.
kurtosis	Return the kurtosis of a numeric column.
mean	Return the mean of a numeric column.
std	Return the standard deviation of a numeric column.
sum	Return the sum of a numeric column.
var	Return the variance of a numeric column.

approx_quantile

approx_quantile(quantile, /, *, where=None)

Compute one or more approximate quantiles of a column.

The result may or may not be exact

Whether the result is an approximation depends on the backend.

Parameters

Name	Type	Description	Default
quantile	float \| `ir`.`NumericValue` \| Sequence[`ir`.`NumericValue` \| float]	`0 <= quantile <= 1`, or an array of such values indicating the quantile or quantiles to compute	required
where	`ir`.`BooleanValue` \| None	Boolean filter for input values	`None`

Returns

Name	Type	Description
	Scalar	Quantile of the input

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.examples.penguins.fetch()

Compute the approximate 0.50 quantile of bill_depth_mm.

>>> t.bill_depth_mm.approx_quantile(0.50)

┌────────┐
│ 17.318 │
└────────┘

Compute multiple approximate quantiles in one call - in this case the result is an array.

>>> t.bill_depth_mm.approx_quantile([0.25, 0.75])

┌────────────────────────┐
│ [15.565625, 18.671875] │
└────────────────────────┘

bucket

bucket(
    buckets,
    /,
    *,
    closed='left',
    close_extreme=True,
    include_under=False,
    include_over=False,
)

Compute a discrete binning of a numeric array.

Parameters

Name	Type	Description	Default
buckets	Sequence[int]	List of buckets	required
closed	Literal['left', 'right']	Which side of each interval is closed. For example: `python buckets = [0, 100, 200] closed = "left" # 100 falls in 2nd bucket closed = "right" # 100 falls in 1st bucket`	`'left'`
close_extreme	bool	Whether the extreme values fall in the last bucket	`True`
include_over	bool	Include values greater than the last bucket in the last bucket	`False`
include_under	bool	Include values less than the first bucket in the first bucket	`False`

Returns

Name	Type	Description
	IntegerColumn	A categorical column expression

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable(
...     {
...         "values": [-1, 3, 5, 6, 8, 10, 11],
...     }
... )
>>> buckets = [0, 5, 10]
>>> t.mutate(
...     bucket_closed_left=t.values.bucket(buckets),
...     bucket_closed_right=t.values.bucket(buckets, closed="right"),
...     bucket_over_under=t.values.bucket(buckets, include_over=True, include_under=True),
... )

┏━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┓
┃ values ┃ bucket_closed_left ┃ bucket_closed_right ┃ bucket_over_under ┃
┡━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━┩
│ int64  │ int8               │ int8                │ int8              │
├────────┼────────────────────┼─────────────────────┼───────────────────┤
│     -1 │               NULL │                NULL │                 0 │
│      3 │                  0 │                   0 │                 1 │
│      5 │                  1 │                   0 │                 2 │
│      6 │                  1 │                   1 │                 2 │
│      8 │                  1 │                   1 │                 2 │
│     10 │                  1 │                   1 │                 2 │
│     11 │               NULL │                NULL │                 3 │
└────────┴────────────────────┴─────────────────────┴───────────────────┘

corr

corr(right, /, *, where=None, how='sample')

Return the correlation of two numeric columns.

Parameters

Name	Type	Description	Default
right	NumericColumn	Numeric column	required
where	`ir`.`BooleanValue` \| None	Filter	`None`
how	Literal['sample', 'pop']	Population or sample correlation	`'sample'`

Returns

Name	Type	Description
	`NumericScalar`	The correlation of `left` and `right`

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable(
...     {
...         "left": [1, 3, 3, 4, 5, 7],
...         "right": [7, 5, 4, 3, 3, 1],
...     }
... )
>>> t.left.corr(t.right, how="pop")

┌────────┐
│ -0.968 │
└────────┘

>>> t.mutate(corr_col=t.left.corr(t.right, how="pop"))

┏━━━━━━━┳━━━━━━━┳━━━━━━━━━━┓
┃ left  ┃ right ┃ corr_col ┃
┡━━━━━━━╇━━━━━━━╇━━━━━━━━━━┩
│ int64 │ int64 │ float64  │
├───────┼───────┼──────────┤
│     1 │     7 │   -0.968 │
│     3 │     5 │   -0.968 │
│     3 │     4 │   -0.968 │
│     4 │     3 │   -0.968 │
│     5 │     3 │   -0.968 │
│     7 │     1 │   -0.968 │
└───────┴───────┴──────────┘

cov

cov(right, /, *, where=None, how='sample')

Return the covariance of two numeric columns.

Parameters

Name	Type	Description	Default
right	NumericColumn	Numeric column	required
where	`ir`.`BooleanValue` \| None	Filter	`None`
how	Literal['sample', 'pop']	Population or sample covariance	`'sample'`

Returns

Name	Type	Description
	`NumericScalar`	The covariance of `self` and `right`

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable(
...     {
...         "left": [1, 3, 3, 4, 5, 7],
...         "right": [7, 5, 4, 3, 3, 1],
...     }
... )
>>> t.left.cov(t.right)

┌───────────┐
│ -4.033333 │
└───────────┘

>>> t.left.cov(t.right, how="pop")

┌───────────┐
│ -3.361111 │
└───────────┘

>>> t.mutate(cov_col=t.left.cov(t.right, how="pop"))

┏━━━━━━━┳━━━━━━━┳━━━━━━━━━━━┓
┃ left  ┃ right ┃ cov_col   ┃
┡━━━━━━━╇━━━━━━━╇━━━━━━━━━━━┩
│ int64 │ int64 │ float64   │
├───────┼───────┼───────────┤
│     1 │     7 │ -3.361111 │
│     3 │     5 │ -3.361111 │
│     3 │     4 │ -3.361111 │
│     4 │     3 │ -3.361111 │
│     5 │     3 │ -3.361111 │
│     7 │     1 │ -3.361111 │
└───────┴───────┴───────────┘

cummean

cummean(where=None, group_by=None, order_by=None)

Return the cumulative mean of the input.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable(
...     {
...         "id": [1, 2, 3, 4, 5, 6],
...         "grouper": ["a", "a", "a", "b", "b", "c"],
...         "values": [3, 2, 1, 2, 3, 2],
...     }
... )
>>> t.mutate(cummean=t.values.cummean()).order_by("id")

┏━━━━━━━┳━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━┓
┃ id    ┃ grouper ┃ values ┃ cummean  ┃
┡━━━━━━━╇━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━┩
│ int64 │ string  │ int64  │ float64  │
├───────┼─────────┼────────┼──────────┤
│     1 │ a       │      3 │ 3.000000 │
│     2 │ a       │      2 │ 2.500000 │
│     3 │ a       │      1 │ 2.000000 │
│     4 │ b       │      2 │ 2.000000 │
│     5 │ b       │      3 │ 2.200000 │
│     6 │ c       │      2 │ 2.166667 │
└───────┴─────────┴────────┴──────────┘

>>> t.mutate(cummean=t.values.cummean(where=t.grouper != "c", group_by="grouper")).order_by(
...     "id"
... )

┏━━━━━━━┳━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━┓
┃ id    ┃ grouper ┃ values ┃ cummean ┃
┡━━━━━━━╇━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━┩
│ int64 │ string  │ int64  │ float64 │
├───────┼─────────┼────────┼─────────┤
│     1 │ a       │      3 │     3.0 │
│     2 │ a       │      2 │     2.5 │
│     3 │ a       │      1 │     2.0 │
│     4 │ b       │      2 │     2.0 │
│     5 │ b       │      3 │     2.5 │
│     6 │ c       │      2 │    NULL │
└───────┴─────────┴────────┴─────────┘

cumsum

cumsum(where=None, group_by=None, order_by=None)

Return the cumulative sum of the input.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable(
...     {
...         "id": [1, 2, 3, 4, 5, 6],
...         "grouper": ["a", "a", "a", "b", "b", "c"],
...         "values": [3, 2, 1, 2, 3, 2],
...     }
... )
>>> t.mutate(cumsum=t.values.cumsum())

┏━━━━━━━┳━━━━━━━━━┳━━━━━━━━┳━━━━━━━━┓
┃ id    ┃ grouper ┃ values ┃ cumsum ┃
┡━━━━━━━╇━━━━━━━━━╇━━━━━━━━╇━━━━━━━━┩
│ int64 │ string  │ int64  │ int64  │
├───────┼─────────┼────────┼────────┤
│     1 │ a       │      3 │      3 │
│     2 │ a       │      2 │      5 │
│     3 │ a       │      1 │      6 │
│     4 │ b       │      2 │      8 │
│     5 │ b       │      3 │     11 │
│     6 │ c       │      2 │     13 │
└───────┴─────────┴────────┴────────┘

>>> t.mutate(cumsum=t.values.cumsum(where=t.grouper != "c"))

┏━━━━━━━┳━━━━━━━━━┳━━━━━━━━┳━━━━━━━━┓
┃ id    ┃ grouper ┃ values ┃ cumsum ┃
┡━━━━━━━╇━━━━━━━━━╇━━━━━━━━╇━━━━━━━━┩
│ int64 │ string  │ int64  │ int64  │
├───────┼─────────┼────────┼────────┤
│     1 │ a       │      3 │      3 │
│     2 │ a       │      2 │      5 │
│     3 │ a       │      1 │      6 │
│     4 │ b       │      2 │      8 │
│     5 │ b       │      3 │     11 │
│     6 │ c       │      2 │     11 │
└───────┴─────────┴────────┴────────┘

histogram

histogram(nbins=None, binwidth=None, base=None, eps=1e-13)

Compute a histogram with fixed width bins.

Parameters

Name	Type	Description	Default
nbins	int \| None	If supplied, will be used to compute the binwidth	`None`
binwidth	float \| None	If not supplied, computed from the data (actual max and min values)	`None`
base	float \| None	The value of the first histogram bin. Defaults to the minimum value of `column`.	`None`
eps	float	Allowed floating point epsilon for histogram base	`1e-13`

Returns

Name	Type	Description
	Column	Bucketed column

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable(
...     {
...         "values": [-1, 3, 5, 6, 8, 10, 11, 23, 25],
...     }
... )

Compute a histogram with 5 bins.

>>> t.mutate(histogram=t.values.histogram(nbins=5))

┏━━━━━━━━┳━━━━━━━━━━━┓
┃ values ┃ histogram ┃
┡━━━━━━━━╇━━━━━━━━━━━┩
│ int64  │ int64     │
├────────┼───────────┤
│     -1 │         0 │
│      3 │         0 │
│      5 │         1 │
│      6 │         1 │
│      8 │         1 │
│     10 │         2 │
│     11 │         2 │
│     23 │         4 │
│     25 │         4 │
└────────┴───────────┘

Compute a histogram with a fixed bin width of 10.

>>> t.mutate(histogram=t.values.histogram(binwidth=10))

┏━━━━━━━━┳━━━━━━━━━━━┓
┃ values ┃ histogram ┃
┡━━━━━━━━╇━━━━━━━━━━━┩
│ int64  │ int64     │
├────────┼───────────┤
│     -1 │         0 │
│      3 │         0 │
│      5 │         0 │
│      6 │         0 │
│      8 │         0 │
│     10 │         1 │
│     11 │         1 │
│     23 │         2 │
│     25 │         2 │
└────────┴───────────┘

kurtosis

kurtosis(where=None, how='sample')

Return the kurtosis of a numeric column.

Parameters

Name	Type	Description	Default
where	`ir`.`BooleanValue` \| None	Filter	`None`
how	Literal['sample', 'pop']	Whether to include bias correction. `"sample"` includes the correction while `"pop"` does not.	`'sample'`

Returns

Name	Type	Description
	`NumericScalar`	Kurtosis of `arg`

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable(
...     {
...         "keys": ["a", "a", "b", "b", "a", "a", "b", "b"],
...         "values": [1, 2, 3, 3, 6, 4, 5, 7],
...     }
... )
>>> t.values.kurtosis()

┌──────────┐
│ -0.88595 │
└──────────┘

>>> t.group_by("keys").agg(kurt=t.values.kurtosis()).order_by("keys")

┏━━━━━━━━┳━━━━━━━━━━━┓
┃ keys   ┃ kurt      ┃
┡━━━━━━━━╇━━━━━━━━━━━┩
│ string │ float64   │
├────────┼───────────┤
│ a      │ -1.699512 │
│ b      │ -1.289256 │
└────────┴───────────┘

mean

mean(where=None)

Return the mean of a numeric column.

Parameters

Name	Type	Description	Default
where	`ir`.`BooleanValue` \| None	Filter	`None`

Returns

Name	Type	Description
	`NumericScalar`	The mean of the input expression

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable(
...     {
...         "id": [1, 2, 3, 4, 5, 6],
...         "grouper": ["a", "a", "a", "b", "b", "c"],
...         "values": [3, 2, 1, 2, 3, 2],
...     }
... )
>>> t.mutate(mean_col=t.values.mean())

┏━━━━━━━┳━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━┓
┃ id    ┃ grouper ┃ values ┃ mean_col ┃
┡━━━━━━━╇━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━┩
│ int64 │ string  │ int64  │ float64  │
├───────┼─────────┼────────┼──────────┤
│     1 │ a       │      3 │ 2.166667 │
│     2 │ a       │      2 │ 2.166667 │
│     3 │ a       │      1 │ 2.166667 │
│     4 │ b       │      2 │ 2.166667 │
│     5 │ b       │      3 │ 2.166667 │
│     6 │ c       │      2 │ 2.166667 │
└───────┴─────────┴────────┴──────────┘

>>> t.mutate(mean_col=t.values.mean(where=t.grouper != "c"))

┏━━━━━━━┳━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━┓
┃ id    ┃ grouper ┃ values ┃ mean_col ┃
┡━━━━━━━╇━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━┩
│ int64 │ string  │ int64  │ float64  │
├───────┼─────────┼────────┼──────────┤
│     1 │ a       │      3 │      2.2 │
│     2 │ a       │      2 │      2.2 │
│     3 │ a       │      1 │      2.2 │
│     4 │ b       │      2 │      2.2 │
│     5 │ b       │      3 │      2.2 │
│     6 │ c       │      2 │      2.2 │
└───────┴─────────┴────────┴──────────┘

std

std(where=None, how='sample')

Return the standard deviation of a numeric column.

Parameters

Name	Type	Description	Default
where	`ir`.`BooleanValue` \| None	Filter	`None`
how	Literal['sample', 'pop']	Sample or population standard deviation	`'sample'`

Returns

Name	Type	Description
	`NumericScalar`	Standard deviation of `arg`

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable(
...     {
...         "values": [1, 3, 3, 4, 5, 7],
...     }
... )
>>> t.values.std()

┌──────────┐
│ 2.041241 │
└──────────┘

>>> t.mutate(std_col=t.values.std())

┏━━━━━━━━┳━━━━━━━━━━┓
┃ values ┃ std_col  ┃
┡━━━━━━━━╇━━━━━━━━━━┩
│ int64  │ float64  │
├────────┼──────────┤
│      1 │ 2.041241 │
│      3 │ 2.041241 │
│      3 │ 2.041241 │
│      4 │ 2.041241 │
│      5 │ 2.041241 │
│      7 │ 2.041241 │
└────────┴──────────┘

sum

sum(where=None)

Return the sum of a numeric column.

Parameters

Name	Type	Description	Default
where	`ir`.`BooleanValue` \| None	Filter	`None`

Returns

Name	Type	Description
	`NumericScalar`	The sum of the input expression

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable(
...     {
...         "id": [1, 2, 3, 4, 5, 6],
...         "grouper": ["a", "a", "a", "b", "b", "c"],
...         "values": [3, 2, 1, 2, 3, 2],
...     }
... )
>>> t.mutate(sum_col=t.values.sum())

┏━━━━━━━┳━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━┓
┃ id    ┃ grouper ┃ values ┃ sum_col ┃
┡━━━━━━━╇━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━┩
│ int64 │ string  │ int64  │ int64   │
├───────┼─────────┼────────┼─────────┤
│     1 │ a       │      3 │      13 │
│     2 │ a       │      2 │      13 │
│     3 │ a       │      1 │      13 │
│     4 │ b       │      2 │      13 │
│     5 │ b       │      3 │      13 │
│     6 │ c       │      2 │      13 │
└───────┴─────────┴────────┴─────────┘

>>> t.mutate(sum_col=t.values.sum(where=t.grouper != "c"))

┏━━━━━━━┳━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━┓
┃ id    ┃ grouper ┃ values ┃ sum_col ┃
┡━━━━━━━╇━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━┩
│ int64 │ string  │ int64  │ int64   │
├───────┼─────────┼────────┼─────────┤
│     1 │ a       │      3 │      11 │
│     2 │ a       │      2 │      11 │
│     3 │ a       │      1 │      11 │
│     4 │ b       │      2 │      11 │
│     5 │ b       │      3 │      11 │
│     6 │ c       │      2 │      11 │
└───────┴─────────┴────────┴─────────┘

var

var(where=None, how='sample')

Return the variance of a numeric column.

Parameters

Name	Type	Description	Default
where	`ir`.`BooleanValue` \| None	Filter	`None`
how	Literal['sample', 'pop']	Sample or population variance	`'sample'`

Returns

Name	Type	Description
	`NumericScalar`	Standard deviation of `arg`

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable(
...     {
...         "values": [1, 3, 3, 4, 5, 7],
...     }
... )
>>> t.values.var()

┌──────────┐
│ 4.166667 │
└──────────┘

>>> t.mutate(var_col=t.values.var())

┏━━━━━━━━┳━━━━━━━━━━┓
┃ values ┃ var_col  ┃
┡━━━━━━━━╇━━━━━━━━━━┩
│ int64  │ float64  │
├────────┼──────────┤
│      1 │ 4.166667 │
│      3 │ 4.166667 │
│      3 │ 4.166667 │
│      4 │ 4.166667 │
│      5 │ 4.166667 │
│      7 │ 4.166667 │
└────────┴──────────┘

IntegerValue

IntegerValue(arg)

Methods

Name	Description
as_interval	Convert an integer to an interval.
as_timestamp	Convert an integral UNIX timestamp to a timestamp expression.
convert_base	Convert an integer from one base to another.

as_interval

as_interval(unit='s', /)

Convert an integer to an interval.

Parameters

Name	Type	Description	Default
unit	Literal['Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', 'us', 'ns']	Unit for the resulting interval	`'s'`

Returns

Name	Type	Description
	IntervalValue	An interval in units of `unit`

Examples

>>> from datetime import datetime
>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable(
...     {
...         "timestamp_col": [
...             datetime(2024, 1, 1, 0, 0, 0),
...             datetime(2024, 1, 1, 0, 0, 0),
...             datetime(2024, 1, 1, 0, 0, 0),
...         ],
...         "int_col": [1, 2, 3],
...     }
... )
>>> t.int_col.as_interval("h")

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ IntervalFromInteger(int_col, HOUR)                         ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ interval('h')                                              │
├────────────────────────────────────────────────────────────┤
│ MonthDayNano(months=0, days=0, nanoseconds=3600000000000)  │
│ MonthDayNano(months=0, days=0, nanoseconds=7200000000000)  │
│ MonthDayNano(months=0, days=0, nanoseconds=10800000000000) │
└────────────────────────────────────────────────────────────┘

>>> t.mutate(timestamp_added_col=t.timestamp_col + t.int_col.as_interval("h"))

┏━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┓
┃ timestamp_col       ┃ int_col ┃ timestamp_added_col ┃
┡━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━┩
│ timestamp           │ int64   │ timestamp           │
├─────────────────────┼─────────┼─────────────────────┤
│ 2024-01-01 00:00:00 │       1 │ 2024-01-01 01:00:00 │
│ 2024-01-01 00:00:00 │       2 │ 2024-01-01 02:00:00 │
│ 2024-01-01 00:00:00 │       3 │ 2024-01-01 03:00:00 │
└─────────────────────┴─────────┴─────────────────────┘

as_timestamp

as_timestamp(unit, /)

Convert an integral UNIX timestamp to a timestamp expression.

Parameters

Name	Type	Description	Default
unit	Literal['s', 'ms', 'us']	The resolution of `arg`	required

Returns

Name	Type	Description
	TimestampValue	`self` converted to a timestamp

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"int_col": [0, 1730501716, 2147483647]})
>>> t.int_col.as_timestamp("s")

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ TimestampFromUNIX(int_col, SECOND) ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ timestamp                          │
├────────────────────────────────────┤
│ 1970-01-01 00:00:00                │
│ 2024-11-01 22:55:16                │
│ 2038-01-19 03:14:07                │
└────────────────────────────────────┘

convert_base

convert_base(from_base, to_base)

Convert an integer from one base to another.

Parameters

Name	Type	Description	Default
from_base	IntegerValue	Numeric base of expression	required
to_base	IntegerValue	New base	required

Returns

Name	Type	Description
	IntegerValue	Converted expression

IntegerColumn

IntegerColumn(arg)

Methods

Name	Description
bit_and	Aggregate the column using the bitwise and operator.
bit_or	Aggregate the column using the bitwise or operator.
bit_xor	Aggregate the column using the bitwise exclusive or operator.

bit_and

bit_and(where=None)

Aggregate the column using the bitwise and operator.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"x": [-1, 0, 1]})
>>> t.x.bit_and()

┌───┐
│ 0 │
└───┘

>>> t.x.bit_and(where=t.x != 0)

┌───┐
│ 1 │
└───┘

bit_or

bit_or(where=None)

Aggregate the column using the bitwise or operator.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"x": [-1, 0, 1]})
>>> t.x.bit_or()

┌────┐
│ -1 │
└────┘

>>> t.x.bit_or(where=t.x >= 0)

┌───┐
│ 1 │
└───┘

bit_xor

bit_xor(where=None)

Aggregate the column using the bitwise exclusive or operator.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"x": [-1, 0, 1]})
>>> t.x.bit_xor()

┌────┐
│ -2 │
└────┘

>>> t.x.bit_xor(where=t.x >= 0)

┌───┐
│ 1 │
└───┘

FloatingValue

FloatingValue(arg)

Methods

Name	Description
isinf	Return whether the value is +/-inf. Does NOT detect `NULL` and `inf` values.
isnan	Return whether the value is NaN. Does NOT detect `NULL` and `inf` values.

isinf

isinf()

Return whether the value is +/-inf. Does NOT detect NULL and inf values.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"f": [None, "-inf", "3.0", "inf", "nan"]})
>>> t = t.mutate(f=ibis._.f.cast(float))
>>> t.mutate(
...     isnull=t.f.isnull(),
...     isnan=t.f.isnan(),
...     isinf=t.f.isinf(),
... )

┏━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┓
┃ f       ┃ isnull  ┃ isnan   ┃ isinf   ┃
┡━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━┩
│ float64 │ boolean │ boolean │ boolean │
├─────────┼─────────┼─────────┼─────────┤
│    NULL │ True    │ NULL    │ NULL    │
│    -inf │ False   │ False   │ True    │
│     3.0 │ False   │ False   │ False   │
│     inf │ False   │ False   │ True    │
│     nan │ False   │ True    │ False   │
└─────────┴─────────┴─────────┴─────────┘

isnan

isnan()

Return whether the value is NaN. Does NOT detect NULL and inf values.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"f": [None, "-inf", "3.0", "inf", "nan"]})
>>> t = t.mutate(f=ibis._.f.cast(float))
>>> t.mutate(
...     isnull=t.f.isnull(),
...     isnan=t.f.isnan(),
...     isinf=t.f.isinf(),
... )

┏━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┓
┃ f       ┃ isnull  ┃ isnan   ┃ isinf   ┃
┡━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━┩
│ float64 │ boolean │ boolean │ boolean │
├─────────┼─────────┼─────────┼─────────┤
│    NULL │ True    │ NULL    │ NULL    │
│    -inf │ False   │ False   │ True    │
│     3.0 │ False   │ False   │ False   │
│     inf │ False   │ False   │ True    │
│     nan │ False   │ True    │ False   │
└─────────┴─────────┴─────────┴─────────┘

DecimalValue

DecimalValue(arg)

BooleanValue

BooleanValue(arg)

Methods

Name	Description
ifelse	Construct a ternary conditional expression.
negate	DEPRECATED.

ifelse

ifelse(true_expr, false_expr, /)

Construct a ternary conditional expression.

Parameters

Name	Type	Description	Default
true_expr	`ir`.`Value`	Expression to return if `self` evaluates to `True`	required
false_expr	`ir`.`Value`	Expression to return if `self` evaluates to `False` or `NULL`	required

Returns

Name	Type	Description
	`Value`	The value of `true_expr` if `arg` is `True` else `false_expr`

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"is_person": [True, False, True, None]})
>>> t.is_person.ifelse("yes", "no")

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ IfElse(is_person, 'yes', 'no') ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ string                         │
├────────────────────────────────┤
│ yes                            │
│ no                             │
│ yes                            │
│ no                             │
└────────────────────────────────┘

negate

negate()

DEPRECATED.

BooleanColumn

BooleanColumn(arg)

Methods

Name	Description
all	Return whether all elements are `True`.
any	Return whether at least one element is `True`.
cumall	Accumulate the `all` aggregate.
cumany	Accumulate the `any` aggregate.
notall	Return whether not all elements are `True`.
notany	Return whether no elements are `True`.

all

all(where=None)

Return whether all elements are True.

Parameters

Name	Type	Description	Default
where	BooleanValue \| None	Optional filter for the aggregation	`None`

Returns

Name	Type	Description
	BooleanValue	Whether all elements are `True`

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"arr": [1, 2, 3, 4]})
>>> (t.arr >= 1).all()

┌──────┐
│ True │
└──────┘

>>> (t.arr > 2).all()

┌───────┐
│ False │
└───────┘

>>> (t.arr == 2).all(where=t.arr == 2)

┌──────┐
│ True │
└──────┘

>>> (t.arr == 2).all(where=t.arr >= 2)

┌───────┐
│ False │
└───────┘

any

any(where=None)

Return whether at least one element is True.

If the expression does not reference any foreign tables, the result will be a scalar reduction, otherwise it will be a deferred expression constructing an exists subquery when passed to a table method.

Parameters

Name	Type	Description	Default
where	BooleanValue \| None	Optional filter for the aggregation	`None`

Returns

Name	Type	Description
	BooleanValue	Whether at least one element is `True`.

Notes

Consider the following ibis expressions

import ibis

t = ibis.table(dict(a="string"))
s = ibis.table(dict(a="string"))

cond = (t.a == s.a).any()

Without knowing the table to use as the outer query there are two ways to turn this expression into a SQL EXISTS predicate, depending on which of t or s is filtered on.

Filtering from t:

SELECT *
FROM t
WHERE EXISTS (SELECT 1 FROM s WHERE t.a = s.a)

Filtering from s:

SELECT *
FROM s
WHERE EXISTS (SELECT 1 FROM t WHERE t.a = s.a)

Notably the correlated subquery cannot stand on its own.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"arr": [1, 2, 3, None]})
>>> (t.arr > 2).any()

┌──────┐
│ True │
└──────┘

>>> (t.arr > 4).any()

┌───────┐
│ False │
└───────┘

>>> (t.arr == None).any(where=t.arr != None)

┌───────┐
│ False │
└───────┘

cumall

cumall(where=None, group_by=None, order_by=None)

Accumulate the all aggregate.

Returns

Name	Type	Description
	BooleanColumn	A boolean column with the cumulative `all` aggregate.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"arr": [1, 2, 3, 4]})
>>> ((t.arr > 1) & (t.arr >= 1)).cumall()

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ All(And(Greater(arr, 1), GreaterEqual(arr, 1))) ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ boolean                                         │
├─────────────────────────────────────────────────┤
│ False                                           │
│ False                                           │
│ False                                           │
│ False                                           │
└─────────────────────────────────────────────────┘

>>> ((t.arr > 0) & (t.arr >= 1)).cumall()

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ All(And(Greater(arr, 0), GreaterEqual(arr, 1))) ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ boolean                                         │
├─────────────────────────────────────────────────┤
│ True                                            │
│ True                                            │
│ True                                            │
│ True                                            │
└─────────────────────────────────────────────────┘

cumany

cumany(where=None, group_by=None, order_by=None)

Accumulate the any aggregate.

Returns

Name	Type	Description
	BooleanColumn	A boolean column with the cumulative `any` aggregate.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"arr": [1, 2, 3, 4]})
>>> ((t.arr > 1) | (t.arr >= 1)).cumany()

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Any(Or(Greater(arr, 1), GreaterEqual(arr, 1))) ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ boolean                                        │
├────────────────────────────────────────────────┤
│ True                                           │
│ True                                           │
│ True                                           │
│ True                                           │
└────────────────────────────────────────────────┘

>>> ((t.arr > 1) & (t.arr >= 1)).cumany()

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Any(And(Greater(arr, 1), GreaterEqual(arr, 1))) ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ boolean                                         │
├─────────────────────────────────────────────────┤
│ False                                           │
│ True                                            │
│ True                                            │
│ True                                            │
└─────────────────────────────────────────────────┘

notall

notall(where=None)

Return whether not all elements are True.

Parameters

Name	Type	Description	Default
where	BooleanValue \| None	Optional filter for the aggregation	`None`

Returns

Name	Type	Description
	BooleanValue	Whether not all elements are `True`

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"arr": [1, 2, 3, 4]})
>>> (t.arr >= 1).notall()

┌───────┐
│ False │
└───────┘

>>> (t.arr > 2).notall()

┌──────┐
│ True │
└──────┘

>>> (t.arr == 2).notall(where=t.arr == 2)

┌───────┐
│ False │
└───────┘

>>> (t.arr == 2).notall(where=t.arr >= 2)

┌──────┐
│ True │
└──────┘

notany

notany(where=None)

Return whether no elements are True.

Parameters

Name	Type	Description	Default
where	BooleanValue \| None	Optional filter for the aggregation	`None`

Returns

Name	Type	Description
	BooleanValue	Whether no elements are `True`.

Examples

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"arr": [1, 2, 3, 4]})
>>> (t.arr > 1).notany()

┌───────┐
│ False │
└───────┘

>>> (t.arr > 4).notany()

┌──────┐
│ True │
└──────┘

>>> m = ibis.memtable({"arr": [True, True, True, False]})
>>> (t.arr == None).notany(where=t.arr != None)

┌──────┐
│ True │
└──────┘

and_

ibis.and_(*predicates)

Combine multiple predicates using &.

Parameters

Name	Type	Description	Default
predicates	`ir`.`BooleanValue`	Boolean value expressions	`()`

Returns

Name	Type	Description
	`BooleanValue`	A new predicate that evaluates to True if all composing predicates are True. If no predicates were provided, returns True.

or_

ibis.or_(*predicates)

Combine multiple predicates using |.

Parameters

Name	Type	Description	Default
predicates	`ir`.`BooleanValue`	Boolean value expressions	`()`

Returns

Name	Type	Description
	`BooleanValue`	A new predicate that evaluates to True if any composing predicates are True. If no predicates were provided, returns False.

random

ibis.random()

Return a random floating point number in the range [0.0, 1.0).

Similar to random.random in the Python standard library.

Repeated use of random

ibis.random() will generate a column of distinct random numbers even if the same instance of ibis.random() is reused.

When Ibis compiles an expression to SQL, each place where random is used will render as a separate call to the given backend’s random number generator.

>>> from ibis.interactive import *
>>> t = ibis.memtable({"a": range(5)})
>>> r_a = ibis.random()
>>> t.mutate(random_1=r_a, random_2=r_a)  # doctest: +SKIP
┏━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓
┃ a     ┃ random_1 ┃ random_2 ┃
┡━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩
│ int64 │ float64  │ float64  │
├───────┼──────────┼──────────┤
│     0 │ 0.191130 │ 0.098715 │
│     1 │ 0.255262 │ 0.828454 │
│     2 │ 0.011804 │ 0.392275 │
│     3 │ 0.309941 │ 0.347300 │
│     4 │ 0.482783 │ 0.095562 │
└───────┴──────────┴──────────┘

Returns

Name	Type	Description
	`FloatingScalar`	Random float value expression

e

e

pi

pi