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

>>> 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 │
└──────────────────┘

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

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

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

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

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 │
└──────────────┘

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

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 │
└────────────────┘

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 │
└──────────────┘

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

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

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	Convert an integral UNIX timestamp to a timestamp expression.

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')

Convert an integral UNIX timestamp to a timestamp expression.

Parameters

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

Returns

Type	Description
TimestampValue	`self` converted to a timestamp

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.