>>> 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.
NumericColumn
NumericColumn(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. |
| bucket | Compute a discrete binning of a numeric array. |
| ceil | Return the ceiling of self. |
| corr | Return the correlation of two numeric columns. |
| cos | Compute the cosine of self. |
| cot | Compute the cotangent of self. |
| cov | Return the covariance of two numeric columns. |
| 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)\). |
| mean | Return the mean of a numeric column. |
| negate | Negate a numeric expression. |
| 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. |
| std | Return the standard deviation of a numeric column. |
| sum | Return the sum of a numeric column. |
| tan | Compute the tangent of self. |
| var | Return the variance of a numeric column. |
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 │ └──────────────────┘
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 |
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 │ └──────────────┘
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 |
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 │ └─────────────┘
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 |
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(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 │ └──────────────┘
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 |
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 │ └────────────────┘
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
| 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) ┃ ┡━━━━━━━━━━━━━━━┩ │ 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 │ └──────────────┘
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 |
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 |
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 │ └─────────────┘
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 |
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. |
| to_timestamp |
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.
to_timestamp
to_timestamp(unit='s')FloatingColumn
FloatingColumn(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.