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

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.

Expression API

Functions API

​NumericColumn

​Methods

​abs

​Examples

​acos

​Examples

​asin

​Examples

​atan

​Examples

​atan2

​Examples

​bucket

​Parameters

​Returns

​ceil

​Examples

​corr

​Parameters

​Returns

​cos

​Examples

​cot

​Examples

​cov

​Parameters

​Returns

​degrees

​Examples

​exp

​Returns

​Examples

​floor

​Examples

​ln

​Examples

​log

​Parameters

​Returns

​Examples

​log10

​Examples

​log2

​Examples

​mean

​Parameters

​Returns

​negate

​Returns

​Examples

​radians

​Examples

​round

​Parameters

​Returns

​Examples

​sign

​Examples

​sin

​Examples

​sqrt

​Examples

​std

​Parameters

​Returns

​sum

​Parameters

​Returns

​tan

​Examples

​var

​Parameters

​Returns

​IntegerColumn

​Methods

​bit_and

​bit_or

​bit_xor

NumericColumn

Methods

abs

Examples

acos

Examples

asin

Examples

atan

Examples

atan2

Examples

bucket

Parameters

Returns

ceil

Examples

corr

Parameters

Returns

cos

Examples

cot

Examples

cov

Parameters

Returns

degrees

Examples

exp

Returns

Examples

floor

Examples

ln

Examples

log

Parameters

Returns

Examples

log10

Examples

log2

Examples

mean

Parameters

Returns

negate

Returns

Examples

radians

Examples

round

Parameters

Returns

Examples

sign

Examples

sin

Examples

sqrt

Examples

std

Parameters

Returns

sum

Parameters

Returns

tan

Examples

var

Parameters

Returns

IntegerColumn

Methods

bit_and

bit_or

bit_xor

to_timestamp

FloatingColumn