>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [-1, 2, -3, 4]})
>>> t.values.abs()┏━━━━━━━━━━━━━┓ ┃ Abs(values) ┃ ┡━━━━━━━━━━━━━┩ │ int64 │ ├─────────────┤ │ 1 │ │ 2 │ │ 3 │ │ 4 │ └─────────────┘
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
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
| 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
| 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
| 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(base=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
| 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
| 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=None)
Round values to an indicated number of decimal places.
Parameters
| Name | Type | Description | Default |
|---|---|---|---|
digits |
int | IntegerValue | None | 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 |
None |
Returns
| 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) ┃ ┡━━━━━━━━━━━━━━━┩ │ int64 │ ├───────────────┤ │ 1 │ │ 2 │ │ 2 │ │ 3 │ └───────────────┘
>>> t.values.round(digits=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
| 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
| Type | Description |
|---|---|
| IntegerColumn | A categorical column expression |
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
| Type | Description |
|---|---|
NumericScalar |
The correlation of left and right |
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
| Type | Description |
|---|---|
NumericScalar |
The covariance of self and right |
cummean
cummean(where=None, group_by=None, order_by=None)
Return the cumulative mean of the input.
cumsum
cumsum(where=None, group_by=None, order_by=None)
Return the cumulative sum of the input.
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
| Type | Description |
|---|---|
| Column | Bucketed column |
mean
mean(where=None)
Return the mean of a numeric column.
Parameters
| Name | Type | Description | Default |
|---|---|---|---|
where |
ir.BooleanValue | None |
Filter | None |
Returns
| Type | Description |
|---|---|
NumericScalar |
The mean of the input expression |
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
| Type | Description |
|---|---|
NumericScalar |
Standard deviation of arg |
sum
sum(where=None)
Return the sum of a numeric column.
Parameters
| Name | Type | Description | Default |
|---|---|---|---|
where |
ir.BooleanValue | None |
Filter | None |
Returns
| Type | Description |
|---|---|
NumericScalar |
The sum of the input expression |
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
| Type | Description |
|---|---|
NumericScalar |
Standard deviation of arg |
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. |
| label | Label a set of integer values with strings. |
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
| Type | Description |
|---|---|
IntervalValue |
An interval in units of unit |
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
| Type | Description |
|---|---|
TimestampValue |
self converted to a timestamp |
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
| Type | Description |
|---|---|
| IntegerValue | Converted expression |
label
label(labels, nulls=None)
Label a set of integer values with strings.
Parameters
| Name | Type | Description | Default |
|---|---|---|---|
labels |
Iterable[str] | An iterable of string labels. Each integer value in self will be mapped to a value in labels. |
required |
nulls |
str | None | String label to use for NULL values |
None |
Returns
| Type | Description |
|---|---|
StringValue |
self labeled with labels |
Examples
>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"a": [0, 1, 0, 2]})
>>> t.select(t.a, labeled=t.a.label(["a", "b", "c"]))┏━━━━━━━┳━━━━━━━━━┓ ┃ a ┃ labeled ┃ ┡━━━━━━━╇━━━━━━━━━┩ │ int64 │ string │ ├───────┼─────────┤ │ 0 │ a │ │ 1 │ b │ │ 0 │ a │ │ 2 │ c │ └───────┴─────────┘
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.
bit_or
bit_or(where=None)
Aggregate the column using the bitwise or operator.
bit_xor
bit_xor(where=None)
Aggregate the column using the bitwise exclusive or operator.
FloatingValue
FloatingValue(self, arg)
Methods
| Name | Description |
|---|---|
| isinf | Return whether the value is infinity. |
| isnan | Return whether the value is NaN. |
isinf
isinf()
Return whether the value is infinity.
isnan
isnan()
Return whether the value is NaN.
DecimalValue
DecimalValue(self, arg)
BooleanValue
BooleanValue(self, arg)
Methods
| Name | Description |
|---|---|
| ifelse | Construct a ternary conditional expression. |
| negate | Negate a boolean expression. |
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
| 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()
Negate a boolean expression.
Returns
| Type | Description |
|---|---|
| BooleanValue | A boolean value expression |
Examples
>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [True, False, False, None]})
>>> t.values.negate()┏━━━━━━━━━━━━━┓ ┃ Not(values) ┃ ┡━━━━━━━━━━━━━┩ │ boolean │ ├─────────────┤ │ False │ │ True │ │ True │ │ NULL │ └─────────────┘
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
| 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
| 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
| 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
| 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
| 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
| 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
| 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
| 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 re-used.
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
| Type | Description |
|---|---|
FloatingScalar |
Random float value expression |
e
e
pi
pi