Numeric and Boolean expressions

Integer, floating point, decimal, and boolean expressions.

NumericValue

NumericValue(self, 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(self, 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.
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 │
└────────┴───────────┘

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(self, 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(self, 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(self, 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.

See Also

Value.isnull() FloatingValue.isnan()

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.

See Also

Value.isnull() FloatingValue.isinf()

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(self, arg)

BooleanValue

BooleanValue(self, 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(self, 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