# Numeric and Boolean Expressions¶

These APIs are available on numeric and boolean expressions.

## NumericValue¶

Bases: Value

### Functions¶

#### __add__(other)¶

Add self with other.

#### __floordiv__(other)¶

Floor divide self by other.

#### __mod__(other)¶

Compute self modulo other.

#### __mul__(other)¶

Multiply self and other.

#### __neg__()¶

Negate self.

Returns:

Type Description
NumericValue

self negated

#### __pow__(other)¶

Raise self to the otherth power.

#### __rfloordiv__(other)¶

Floor divide other by self.

#### __rmod__(other)¶

Compute other modulo self.

#### __rpow__(other)¶

Raise other to the selfth power.

#### __rsub__(other)¶

Substract self from other.

#### __rtruediv__(other)¶

Divide other by self.

#### __sub__(other)¶

Substract other from self.

#### __truediv__(other)¶

Divide self by other.

#### 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()¶

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()¶

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()¶

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(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()¶

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(lower=None, upper=None)¶

Trim values outside of lower and upper 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": range(8)})
>>> t.values.clip(lower=3, upper=6)
┏━━━━━━━━━━━━━━━━━━━━┓
┃ Clip(values, 3, 6) ┃
┡━━━━━━━━━━━━━━━━━━━━┩
│ int64              │
├────────────────────┤
│                  3 │
│                  3 │
│                  3 │
│                  3 │
│                  4 │
│                  5 │
│                  6 │
│                  6 │
└────────────────────┘


#### 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()¶

Compute the cotangent of self.

Examples:

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [-1, 0, 1]})
>>> t.values.cot()
┏━━━━━━━━━━━━━┓
┃ Cot(values) ┃
┡━━━━━━━━━━━━━┩
│ float64     │
├─────────────┤
│   -0.642093 │
│         inf │
│    0.642093 │
└─────────────┘


#### 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()¶

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()¶

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()¶

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(base=None)¶

Return the logarithm using a specified base.

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()¶

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()¶

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


#### nullifzero()¶

Return NULL if an expression is zero.

#### 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

#### radians()¶

Compute radians from self degrees.

Examples:

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"values": [0, 90, 180, 270, 360]})
┏━━━━━━━━━━━━━━━━━┓
┡━━━━━━━━━━━━━━━━━┩
│ float64         │
├─────────────────┤
│        0.000000 │
│        1.570796 │
│        3.141593 │
│        4.712389 │
│        6.283185 │
└─────────────────┘


#### 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 self.type() Output
None or 0 decimal decimal
Nonzero decimal decimal
None or 0 Floating int64
Nonzero 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()¶

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()¶

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()¶

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()¶

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


#### zeroifnull()¶

Return zero if an expression is NULL.

## NumericColumn¶

Bases: Column, NumericValue

### Functions¶

#### 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:

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(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(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()¶

Return the cumulative mean of the input.

#### cumsum()¶

Return the cumulative sum of the input.

#### 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(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

#### median(where=None)¶

Return the median of the column.

Parameters:

Name Type Description Default
where ir.BooleanValue | None

Optional boolean expression. If given, only the values where where evaluates to true will be considered for the median.

None

Returns:

Type Description
NumericScalar

Median of the column

#### quantile(quantile, interpolation=None, where=None)¶

Return value at the given quantile.

Parameters:

Name Type Description Default
quantile Sequence[NumericValue | float]

0 <= quantile <= 1, the quantile(s) to compute

required
interpolation Literal['linear', 'lower', 'higher', 'midpoint', 'nearest'] | None

This parameter is backend dependent and may have no effect

This parameter specifies the interpolation method to use, when the desired quantile lies between two data points i and j:

• linear: i + (j - i) * fraction, where fraction is the fractional part of the index surrounded by i and j.
• lower: i.
• higher: j.
• nearest: i or j whichever is nearest.
• midpoint: (i + j) / 2.
None
where ir.BooleanValue | None

Boolean filter for input values

None

Returns:

Type Description
NumericScalar

Quantile of the input

#### 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(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(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¶

Bases: NumericValue

### Functions¶

#### __and__(other)¶

Bitwise and self with other.

#### __invert__()¶

Bitwise not of self.

Returns:

Type Description
IntegerValue

Inverted bits of self.

#### __lshift__(other)¶

Bitwise left shift self with other.

#### __or__(other)¶

Bitwise or self with other.

#### __rlshift__(other)¶

Bitwise left shift self with other.

#### __rrshift__(other)¶

Bitwise right shift self with other.

#### __rshift__(other)¶

Bitwise right shift self with other.

#### __xor__(other)¶

Bitwise xor self with other.

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


#### to_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

#### 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

## IntegerColumn¶

Bases: NumericColumn, IntegerValue

### Functions¶

#### bit_and(where=None)¶

Aggregate the column using the bitwise and operator.

#### bit_or(where=None)¶

Aggregate the column using the bitwise or operator.

#### bit_xor(where=None)¶

Aggregate the column using the bitwise exclusive or operator.

## FloatingValue¶

Bases: NumericValue

### Functions¶

#### isinf()¶

Return whether the value is infinity.

#### isnan()¶

Return whether the value is NaN.

## DecimalValue¶

Bases: NumericValue

## BooleanValue¶

Bases: NumericValue

### Functions¶

#### __and__(other)¶

Construct a binary AND conditional expression with self and other.

Parameters:

Name Type Description Default
self

Left operand

required
other BooleanValue

Right operand

required

Returns:

Type Description
BooleanValue

A Boolean expression

Examples:

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"arr": [[1], [], [42, 42], None]})
>>> t.arr.contains(42) & (t.arr.contains(1))
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ And(ArrayContains(arr, 42), ArrayContains(arr, 1)) ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ boolean                                            │
├────────────────────────────────────────────────────┤
│ False                                              │
│ False                                              │
│ False                                              │
│ NULL                                               │
└────────────────────────────────────────────────────┘

>>> t.arr.contains(42) & (t.arr.contains(42))
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ And(ArrayContains(arr, 42), ArrayContains(arr, 42)) ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ boolean                                             │
├─────────────────────────────────────────────────────┤
│ False                                               │
│ False                                               │
│ True                                                │
│ NULL                                                │
└─────────────────────────────────────────────────────┘


#### __invert__()¶

Construct a unary NOT conditional expression with self.

Parameters:

Name Type Description Default
self

Operand

required

Returns:

Type Description
BooleanValue

A Boolean expression

Examples:

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"arr": [True, False, False, None]})
>>> ~t.arr
┏━━━━━━━━━━┓
┃ Not(arr) ┃
┡━━━━━━━━━━┩
│ boolean  │
├──────────┤
│ False    │
│ True     │
│ True     │
│ NULL     │
└──────────┘


#### __or__(other)¶

Construct a binary OR conditional expression with self and other.

Parameters:

Name Type Description Default
self

Left operand

required
other BooleanValue

Right operand

required

Returns:

Type Description
BooleanValue

A Boolean expression

Examples:

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"arr": [1, 2, 3, None]})
>>> (t.arr > 1) | (t.arr > 2)
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Or(Greater(arr, 1), Greater(arr, 2)) ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ boolean                              │
├──────────────────────────────────────┤
│ False                                │
│ True                                 │
│ True                                 │
│ NULL                                 │
└──────────────────────────────────────┘


#### __xor__(other)¶

Construct a binary XOR conditional expression with self and other.

Parameters:

Name Type Description Default
self

Left operand

required
other BooleanValue

Right operand

required

Returns:

Type Description
BooleanValue

A Boolean expression

Examples:

>>> import ibis
>>> ibis.options.interactive = True
>>> t = ibis.memtable({"arr": [1, 2, 3, None]})
>>> t.arr == 2
┏━━━━━━━━━━━━━━━━┓
┃ Equals(arr, 2) ┃
┡━━━━━━━━━━━━━━━━┩
│ boolean        │
├────────────────┤
│ False          │
│ True           │
│ False          │
│ NULL           │
└────────────────┘

>>> (t.arr > 2)
┏━━━━━━━━━━━━━━━━━┓
┃ Greater(arr, 2) ┃
┡━━━━━━━━━━━━━━━━━┩
│ boolean         │
├─────────────────┤
│ False           │
│ False           │
│ True            │
│ NULL            │
└─────────────────┘

>>> (t.arr == 2) ^ (t.arr > 2)
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Xor(Equals(arr, 2), Greater(arr, 2)) ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ boolean                              │
├──────────────────────────────────────┤
│ False                                │
│ True                                 │
│ True                                 │
│ NULL                                 │
└──────────────────────────────────────┘


#### 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")
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Where(is_person, 'yes', 'no') ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ string                        │
├───────────────────────────────┤
│ yes                           │
│ no                            │
│ yes                           │
│ no                            │
└───────────────────────────────┘


Last update: August 5, 2022