Class: Polars::Expr
- Inherits:
-
Object
- Object
- Polars::Expr
- Defined in:
- lib/polars/expr.rb
Overview
Expressions that can be used in various contexts.
Instance Method Summary collapse
-
#! ⇒ Expr
Performs boolean not.
-
#!=(other) ⇒ Expr
Not equal.
-
#%(other) ⇒ Expr
Returns the modulo.
-
#&(other) ⇒ Expr
Bitwise AND.
-
#*(other) ⇒ Expr
Performs multiplication.
-
#**(power) ⇒ Expr
Raises to the power of exponent.
-
#+(other) ⇒ Expr
Performs addition.
-
#-(other) ⇒ Expr
Performs subtraction.
-
#-@ ⇒ Expr
Performs negation.
-
#/(other) ⇒ Expr
Performs division.
-
#<(other) ⇒ Expr
Less than.
-
#<=(other) ⇒ Expr
Less than or equal.
-
#==(other) ⇒ Expr
Equal.
-
#>(other) ⇒ Expr
Greater than.
-
#>=(other) ⇒ Expr
Greater than or equal.
-
#^(other) ⇒ Expr
Bitwise XOR.
-
#_hash(seed = 0, seed_1 = nil, seed_2 = nil, seed_3 = nil) ⇒ Expr
Hash the elements in the selection.
-
#abs ⇒ Expr
Compute absolute values.
-
#add(other) ⇒ Expr
Method equivalent of addition operator
expr + other
. -
#agg_groups ⇒ Expr
Get the group indexes of the group by operation.
-
#alias(name) ⇒ Expr
Rename the output of an expression.
-
#all(drop_nulls: true) ⇒ Boolean
Check if all boolean values in a Boolean column are
true
. -
#any(drop_nulls: true) ⇒ Boolean
Check if any boolean value in a Boolean column is
true
. -
#append(other, upcast: true) ⇒ Expr
Append expressions.
-
#approx_n_unique ⇒ Expr
(also: #approx_unique)
Approx count unique values.
-
#arccos ⇒ Expr
Compute the element-wise value for the inverse cosine.
-
#arccosh ⇒ Expr
Compute the element-wise value for the inverse hyperbolic cosine.
-
#arcsin ⇒ Expr
Compute the element-wise value for the inverse sine.
-
#arcsinh ⇒ Expr
Compute the element-wise value for the inverse hyperbolic sine.
-
#arctan ⇒ Expr
Compute the element-wise value for the inverse tangent.
-
#arctanh ⇒ Expr
Compute the element-wise value for the inverse hyperbolic tangent.
-
#arg_max ⇒ Expr
Get the index of the maximal value.
-
#arg_min ⇒ Expr
Get the index of the minimal value.
-
#arg_sort(reverse: false, nulls_last: false) ⇒ Expr
Get the index values that would sort this column.
-
#arg_unique ⇒ Expr
Get index of first unique value.
-
#argsort(reverse: false, nulls_last: false) ⇒ expr
Get the index values that would sort this column.
-
#arr ⇒ ArrayExpr
Create an object namespace of all array related methods.
-
#backward_fill(limit: nil) ⇒ Expr
Fill missing values with the next to be seen values.
-
#bin ⇒ BinaryExpr
Create an object namespace of all binary related methods.
-
#bottom_k(k: 5) ⇒ Expr
Return the
k
smallest elements. -
#cast(dtype, strict: true) ⇒ Expr
Cast between data types.
-
#cat ⇒ CatExpr
Create an object namespace of all categorical related methods.
-
#ceil ⇒ Expr
Rounds up to the nearest integer value.
-
#clip(lower_bound, upper_bound) ⇒ Expr
Set values outside the given boundaries to the boundary value.
-
#clip_max(upper_bound) ⇒ Expr
Clip (limit) the values in an array to a
max
boundary. -
#clip_min(lower_bound) ⇒ Expr
Clip (limit) the values in an array to a
min
boundary. -
#cos ⇒ Expr
Compute the element-wise value for the cosine.
-
#cosh ⇒ Expr
Compute the element-wise value for the hyperbolic cosine.
-
#count ⇒ Expr
Count the number of values in this expression.
-
#cum_count(reverse: false) ⇒ Expr
(also: #cumcount)
Get an array with the cumulative count computed at every element.
-
#cum_max(reverse: false) ⇒ Expr
(also: #cummax)
Get an array with the cumulative max computed at every element.
-
#cum_min(reverse: false) ⇒ Expr
(also: #cummin)
Get an array with the cumulative min computed at every element.
-
#cum_prod(reverse: false) ⇒ Expr
(also: #cumprod)
Get an array with the cumulative product computed at every element.
-
#cum_sum(reverse: false) ⇒ Expr
(also: #cumsum)
Get an array with the cumulative sum computed at every element.
-
#cumulative_eval(expr, min_periods: 1, parallel: false) ⇒ Expr
Run an expression over a sliding window that increases
1
slot every iteration. -
#cut(breaks, labels: nil, left_closed: false, include_breaks: false) ⇒ Expr
Bin continuous values into discrete categories.
-
#diff(n: 1, null_behavior: "ignore") ⇒ Expr
Calculate the n-th discrete difference.
-
#dot(other) ⇒ Expr
Compute the dot/inner product between two Expressions.
-
#drop_nans ⇒ Expr
Drop floating point NaN values.
-
#drop_nulls ⇒ Expr
Drop null values.
-
#dt ⇒ DateTimeExpr
Create an object namespace of all datetime related methods.
-
#entropy(base: 2, normalize: true) ⇒ Expr
Computes the entropy.
-
#eq(other) ⇒ Expr
Method equivalent of equality operator
expr == other
. -
#eq_missing(other) ⇒ Expr
Method equivalent of equality operator
expr == other
whereNone == None
. -
#ewm_mean(com: nil, span: nil, half_life: nil, alpha: nil, adjust: true, min_periods: 1, ignore_nulls: true) ⇒ Expr
Exponentially-weighted moving average.
-
#ewm_std(com: nil, span: nil, half_life: nil, alpha: nil, adjust: true, bias: false, min_periods: 1, ignore_nulls: true) ⇒ Expr
Exponentially-weighted moving standard deviation.
-
#ewm_var(com: nil, span: nil, half_life: nil, alpha: nil, adjust: true, bias: false, min_periods: 1, ignore_nulls: true) ⇒ Expr
Exponentially-weighted moving variance.
-
#exclude(columns) ⇒ Expr
Exclude certain columns from a wildcard/regex selection.
-
#exp ⇒ Expr
Compute the exponential, element-wise.
-
#explode ⇒ Expr
Explode a list or utf8 Series.
-
#extend_constant(value, n) ⇒ Expr
Extend the Series with given number of values.
-
#fill_nan(fill_value) ⇒ Expr
Fill floating point NaN value with a fill value.
-
#fill_null(value = nil, strategy: nil, limit: nil) ⇒ Expr
Fill null values using the specified value or strategy.
-
#filter(predicate) ⇒ Expr
Filter a single column.
-
#first ⇒ Expr
Get the first value.
-
#flatten ⇒ Expr
Explode a list or utf8 Series.
-
#floor ⇒ Expr
Rounds down to the nearest integer value.
-
#floordiv(other) ⇒ Expr
Method equivalent of integer division operator
expr // other
. -
#forward_fill(limit: nil) ⇒ Expr
Fill missing values with the latest seen values.
-
#gather(indices) ⇒ Expr
(also: #take)
Take values by index.
-
#gather_every(n, offset = 0) ⇒ Expr
(also: #take_every)
Take every nth value in the Series and return as a new Series.
-
#ge(other) ⇒ Expr
Method equivalent of "greater than or equal" operator
expr >= other
. -
#gt(other) ⇒ Expr
Method equivalent of "greater than" operator
expr > other
. -
#head(n = 10) ⇒ Expr
Get the first
n
rows. -
#implode ⇒ Expr
Aggregate to list.
-
#interpolate(method: "linear") ⇒ Expr
Fill nulls with linear interpolation over missing values.
-
#is_between(start, _end, closed: "both") ⇒ Expr
Check if this expression is between start and end.
-
#is_duplicated ⇒ Expr
Get mask of duplicated values.
-
#is_finite ⇒ Expr
Returns a boolean Series indicating which values are finite.
-
#is_first_distinct ⇒ Expr
(also: #is_first)
Get a mask of the first unique value.
-
#is_in(other) ⇒ Expr
(also: #in?)
Check if elements of this expression are present in the other Series.
-
#is_infinite ⇒ Expr
Returns a boolean Series indicating which values are infinite.
-
#is_nan ⇒ Expr
Returns a boolean Series indicating which values are NaN.
-
#is_not ⇒ Expr
(also: #not_)
Negate a boolean expression.
-
#is_not_nan ⇒ Expr
Returns a boolean Series indicating which values are not NaN.
-
#is_not_null ⇒ Expr
Returns a boolean Series indicating which values are not null.
-
#is_null ⇒ Expr
Returns a boolean Series indicating which values are null.
-
#is_unique ⇒ Expr
Get mask of unique values.
-
#keep_name ⇒ Expr
Keep the original root name of the expression.
-
#kurtosis(fisher: true, bias: true) ⇒ Expr
Compute the kurtosis (Fisher or Pearson) of a dataset.
-
#last ⇒ Expr
Get the last value.
-
#le(other) ⇒ Expr
Method equivalent of "less than or equal" operator
expr <= other
. -
#len ⇒ Expr
(also: #length)
Count the number of values in this expression.
-
#limit(n = 10) ⇒ Expr
Get the first
n
rows. -
#list ⇒ ListExpr
Create an object namespace of all list related methods.
-
#log(base = Math::E) ⇒ Expr
Compute the logarithm to a given base.
-
#log10 ⇒ Expr
Compute the base 10 logarithm of the input array, element-wise.
-
#lower_bound ⇒ Expr
Calculate the lower bound.
-
#lt(other) ⇒ Expr
Method equivalent of "less than" operator
expr < other
. -
#map_alias(&f) ⇒ Expr
Rename the output of an expression by mapping a function over the root name.
-
#max ⇒ Expr
Get maximum value.
-
#mean ⇒ Expr
Get mean value.
-
#median ⇒ Expr
Get median value using linear interpolation.
-
#meta ⇒ MetaExpr
Create an object namespace of all meta related expression methods.
-
#min ⇒ Expr
Get minimum value.
-
#mod(other) ⇒ Expr
Method equivalent of modulus operator
expr % other
. -
#mode ⇒ Expr
Compute the most occurring value(s).
-
#mul(other) ⇒ Expr
Method equivalent of multiplication operator
expr * other
. -
#n_unique ⇒ Expr
Count unique values.
-
#name ⇒ NameExpr
Create an object namespace of all expressions that modify expression names.
-
#nan_max ⇒ Expr
Get maximum value, but propagate/poison encountered NaN values.
-
#nan_min ⇒ Expr
Get minimum value, but propagate/poison encountered NaN values.
-
#ne(other) ⇒ Expr
Method equivalent of inequality operator
expr != other
. -
#ne_missing(other) ⇒ Expr
Method equivalent of equality operator
expr != other
whereNone == None
. -
#neg ⇒ Expr
Method equivalent of unary minus operator
-expr
. -
#null_count ⇒ Expr
Count null values.
-
#over(expr) ⇒ Expr
Apply window function over a subgroup.
-
#pct_change(n: 1) ⇒ Expr
Computes percentage change between values.
-
#peak_max ⇒ Expr
Get a boolean mask of the local maximum peaks.
-
#peak_min ⇒ Expr
Get a boolean mask of the local minimum peaks.
-
#pow(exponent) ⇒ Expr
Raise expression to the power of exponent.
-
#prefix(prefix) ⇒ Expr
Add a prefix to the root column name of the expression.
-
#product ⇒ Expr
Compute the product of an expression.
-
#qcut(quantiles, labels: nil, left_closed: false, allow_duplicates: false, include_breaks: false) ⇒ Expr
Bin continuous values into discrete categories based on their quantiles.
-
#quantile(quantile, interpolation: "nearest") ⇒ Expr
Get quantile value.
-
#rank(method: "average", reverse: false, seed: nil) ⇒ Expr
Assign ranks to data, dealing with ties appropriately.
-
#rechunk ⇒ Expr
Create a single chunk of memory for this Series.
-
#reinterpret(signed: false) ⇒ Expr
Reinterpret the underlying bits as a signed/unsigned integer.
-
#repeat_by(by) ⇒ Expr
Repeat the elements in this Series as specified in the given expression.
-
#replace(old, new = NO_DEFAULT, default: NO_DEFAULT, return_dtype: nil) ⇒ Expr
Replace values by different values.
-
#reshape(dims) ⇒ Expr
Reshape this Expr to a flat Series or a Series of Lists.
-
#reverse ⇒ Expr
Reverse the selection.
-
#rle ⇒ Expr
Get the lengths of runs of identical values.
-
#rle_id ⇒ Expr
Map values to run IDs.
-
#rolling_max(window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left") ⇒ Expr
Apply a rolling max (moving max) over the values in this array.
-
#rolling_mean(window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left") ⇒ Expr
Apply a rolling mean (moving mean) over the values in this array.
-
#rolling_median(window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left", warn_if_unsorted: true) ⇒ Expr
Compute a rolling median.
-
#rolling_min(window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left") ⇒ Expr
Apply a rolling min (moving min) over the values in this array.
-
#rolling_quantile(quantile, interpolation: "nearest", window_size: 2, weights: nil, min_periods: nil, center: false, by: nil, closed: "left", warn_if_unsorted: true) ⇒ Expr
Compute a rolling quantile.
-
#rolling_skew(window_size, bias: true) ⇒ Expr
Compute a rolling skew.
-
#rolling_std(window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left", ddof: 1, warn_if_unsorted: true) ⇒ Expr
Compute a rolling standard deviation.
-
#rolling_sum(window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left") ⇒ Expr
Apply a rolling sum (moving sum) over the values in this array.
-
#rolling_var(window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left", ddof: 1, warn_if_unsorted: true) ⇒ Expr
Compute a rolling variance.
-
#round(decimals = 0) ⇒ Expr
Round underlying floating point data by
decimals
digits. -
#sample(frac: nil, with_replacement: true, shuffle: false, seed: nil, n: nil) ⇒ Expr
Sample from this expression.
-
#search_sorted(element, side: "any") ⇒ Expr
Find indices where elements should be inserted to maintain order.
-
#set_sorted(descending: false) ⇒ Expr
Flags the expression as 'sorted'.
-
#shift(n = 1, fill_value: nil) ⇒ Expr
Shift the values by a given period.
-
#shift_and_fill(periods, fill_value) ⇒ Expr
Shift the values by a given period and fill the resulting null values.
-
#shrink_dtype ⇒ Expr
Shrink numeric columns to the minimal required datatype.
-
#shuffle(seed: nil) ⇒ Expr
Shuffle the contents of this expr.
-
#sign ⇒ Expr
Compute the element-wise indication of the sign.
-
#sin ⇒ Expr
Compute the element-wise value for the sine.
-
#sinh ⇒ Expr
Compute the element-wise value for the hyperbolic sine.
-
#skew(bias: true) ⇒ Expr
Compute the sample skewness of a data set.
-
#slice(offset, length = nil) ⇒ Expr
Get a slice of this expression.
-
#sort(reverse: false, nulls_last: false) ⇒ Expr
Sort this column.
-
#sort_by(by, reverse: false) ⇒ Expr
Sort this column by the ordering of another column, or multiple other columns.
-
#sqrt ⇒ Expr
Compute the square root of the elements.
-
#std(ddof: 1) ⇒ Expr
Get standard deviation.
-
#str ⇒ StringExpr
Create an object namespace of all string related methods.
-
#struct ⇒ StructExpr
Create an object namespace of all struct related methods.
-
#sub(other) ⇒ Expr
Method equivalent of subtraction operator
expr - other
. -
#suffix(suffix) ⇒ Expr
Add a suffix to the root column name of the expression.
-
#sum ⇒ Expr
Get sum value.
-
#tail(n = 10) ⇒ Expr
Get the last
n
rows. -
#tan ⇒ Expr
Compute the element-wise value for the tangent.
-
#tanh ⇒ Expr
Compute the element-wise value for the hyperbolic tangent.
-
#to_physical ⇒ Expr
Cast to physical representation of the logical dtype.
-
#to_s ⇒ String
(also: #inspect)
Returns a string representing the Expr.
-
#top_k(k: 5) ⇒ Expr
Return the
k
largest elements. -
#truediv(other) ⇒ Expr
Method equivalent of float division operator
expr / other
. -
#unique(maintain_order: false) ⇒ Expr
Get unique values of this expression.
-
#unique_counts ⇒ Expr
Return a count of the unique values in the order of appearance.
-
#upper_bound ⇒ Expr
Calculate the upper bound.
-
#value_counts(multithreaded: false, sort: false) ⇒ Expr
Count all unique values and create a struct mapping value to count.
-
#var(ddof: 1) ⇒ Expr
Get variance.
-
#where(predicate) ⇒ Expr
Filter a single column.
-
#xor(other) ⇒ Expr
Method equivalent of bitwise exclusive-or operator
expr ^ other
. -
#|(other) ⇒ Expr
Bitwise OR.
Instance Method Details
#!=(other) ⇒ Expr
Not equal.
113 114 115 |
# File 'lib/polars/expr.rb', line 113 def !=(other) _from_rbexpr(_rbexpr.neq(_to_expr(other)._rbexpr)) end |
#%(other) ⇒ Expr
Returns the modulo.
77 78 79 |
# File 'lib/polars/expr.rb', line 77 def %(other) _from_rbexpr(_rbexpr % _to_rbexpr(other)) end |
#&(other) ⇒ Expr
Bitwise AND.
35 36 37 |
# File 'lib/polars/expr.rb', line 35 def &(other) _from_rbexpr(_rbexpr._and(_to_rbexpr(other))) end |
#*(other) ⇒ Expr
Performs multiplication.
63 64 65 |
# File 'lib/polars/expr.rb', line 63 def *(other) _from_rbexpr(_rbexpr * _to_rbexpr(other)) end |
#**(power) ⇒ Expr
Raises to the power of exponent.
84 85 86 87 |
# File 'lib/polars/expr.rb', line 84 def **(power) exponent = Utils.expr_to_lit_or_expr(power) _from_rbexpr(_rbexpr.pow(exponent._rbexpr)) end |
#+(other) ⇒ Expr
Performs addition.
49 50 51 |
# File 'lib/polars/expr.rb', line 49 def +(other) _from_rbexpr(_rbexpr + _to_rbexpr(other)) end |
#-(other) ⇒ Expr
Performs subtraction.
56 57 58 |
# File 'lib/polars/expr.rb', line 56 def -(other) _from_rbexpr(_rbexpr - _to_rbexpr(other)) end |
#-@ ⇒ Expr
Performs negation.
141 142 143 |
# File 'lib/polars/expr.rb', line 141 def -@ _from_rbexpr(_rbexpr.neg) end |
#/(other) ⇒ Expr
Performs division.
70 71 72 |
# File 'lib/polars/expr.rb', line 70 def /(other) _from_rbexpr(_rbexpr / _to_rbexpr(other)) end |
#<(other) ⇒ Expr
Less than.
120 121 122 |
# File 'lib/polars/expr.rb', line 120 def <(other) _from_rbexpr(_rbexpr.lt(_to_expr(other)._rbexpr)) end |
#<=(other) ⇒ Expr
Less than or equal.
99 100 101 |
# File 'lib/polars/expr.rb', line 99 def <=(other) _from_rbexpr(_rbexpr.lt_eq(_to_expr(other)._rbexpr)) end |
#==(other) ⇒ Expr
Equal.
106 107 108 |
# File 'lib/polars/expr.rb', line 106 def ==(other) _from_rbexpr(_rbexpr.eq(_to_expr(other)._rbexpr)) end |
#>(other) ⇒ Expr
Greater than.
127 128 129 |
# File 'lib/polars/expr.rb', line 127 def >(other) _from_rbexpr(_rbexpr.gt(_to_expr(other)._rbexpr)) end |
#>=(other) ⇒ Expr
Greater than or equal.
92 93 94 |
# File 'lib/polars/expr.rb', line 92 def >=(other) _from_rbexpr(_rbexpr.gt_eq(_to_expr(other)._rbexpr)) end |
#^(other) ⇒ Expr
Bitwise XOR.
28 29 30 |
# File 'lib/polars/expr.rb', line 28 def ^(other) _from_rbexpr(_rbexpr._xor(_to_rbexpr(other))) end |
#_hash(seed = 0, seed_1 = nil, seed_2 = nil, seed_3 = nil) ⇒ Expr
Hash the elements in the selection.
The hash value is of type :u64
.
3754 3755 3756 3757 3758 3759 3760 |
# File 'lib/polars/expr.rb', line 3754 def _hash(seed = 0, seed_1 = nil, seed_2 = nil, seed_3 = nil) k0 = seed k1 = seed_1.nil? ? seed : seed_1 k2 = seed_2.nil? ? seed : seed_2 k3 = seed_3.nil? ? seed : seed_3 _from_rbexpr(_rbexpr._hash(k0, k1, k2, k3)) end |
#abs ⇒ Expr
Compute absolute values.
4674 4675 4676 |
# File 'lib/polars/expr.rb', line 4674 def abs _from_rbexpr(_rbexpr.abs) end |
#add(other) ⇒ Expr
Method equivalent of addition operator expr + other
.
3337 3338 3339 |
# File 'lib/polars/expr.rb', line 3337 def add(other) self + other end |
#agg_groups ⇒ Expr
Get the group indexes of the group by operation.
Should be used in aggregation context only.
701 702 703 |
# File 'lib/polars/expr.rb', line 701 def agg_groups _from_rbexpr(_rbexpr.agg_groups) end |
#alias(name) ⇒ Expr
Rename the output of an expression.
324 325 326 |
# File 'lib/polars/expr.rb', line 324 def alias(name) _from_rbexpr(_rbexpr._alias(name)) end |
#all(drop_nulls: true) ⇒ Boolean
Check if all boolean values in a Boolean column are true
.
This method is an expression - not to be confused with
Polars.all
which is a function to select all columns.
223 224 225 |
# File 'lib/polars/expr.rb', line 223 def all(drop_nulls: true) _from_rbexpr(_rbexpr.all(drop_nulls)) end |
#any(drop_nulls: true) ⇒ Boolean
Check if any boolean value in a Boolean column is true
.
198 199 200 |
# File 'lib/polars/expr.rb', line 198 def any(drop_nulls: true) _from_rbexpr(_rbexpr.any(drop_nulls)) end |
#append(other, upcast: true) ⇒ Expr
Append expressions.
This is done by adding the chunks of other
to this Series
.
813 814 815 816 |
# File 'lib/polars/expr.rb', line 813 def append(other, upcast: true) other = Utils.expr_to_lit_or_expr(other) _from_rbexpr(_rbexpr.append(other._rbexpr, upcast)) end |
#approx_n_unique ⇒ Expr Also known as: approx_unique
Approx count unique values.
This is done using the HyperLogLog++ algorithm for cardinality estimation.
2082 2083 2084 |
# File 'lib/polars/expr.rb', line 2082 def approx_n_unique _from_rbexpr(_rbexpr.approx_n_unique) end |
#arccos ⇒ Expr
Compute the element-wise value for the inverse cosine.
5167 5168 5169 |
# File 'lib/polars/expr.rb', line 5167 def arccos _from_rbexpr(_rbexpr.arccos) end |
#arccosh ⇒ Expr
Compute the element-wise value for the inverse hyperbolic cosine.
5287 5288 5289 |
# File 'lib/polars/expr.rb', line 5287 def arccosh _from_rbexpr(_rbexpr.arccosh) end |
#arcsin ⇒ Expr
Compute the element-wise value for the inverse sine.
5147 5148 5149 |
# File 'lib/polars/expr.rb', line 5147 def arcsin _from_rbexpr(_rbexpr.arcsin) end |
#arcsinh ⇒ Expr
Compute the element-wise value for the inverse hyperbolic sine.
5267 5268 5269 |
# File 'lib/polars/expr.rb', line 5267 def arcsinh _from_rbexpr(_rbexpr.arcsinh) end |
#arctan ⇒ Expr
Compute the element-wise value for the inverse tangent.
5187 5188 5189 |
# File 'lib/polars/expr.rb', line 5187 def arctan _from_rbexpr(_rbexpr.arctan) end |
#arctanh ⇒ Expr
Compute the element-wise value for the inverse hyperbolic tangent.
5307 5308 5309 |
# File 'lib/polars/expr.rb', line 5307 def arctanh _from_rbexpr(_rbexpr.arctanh) end |
#arg_max ⇒ Expr
Get the index of the maximal value.
1443 1444 1445 |
# File 'lib/polars/expr.rb', line 1443 def arg_max _from_rbexpr(_rbexpr.arg_max) end |
#arg_min ⇒ Expr
Get the index of the minimal value.
1467 1468 1469 |
# File 'lib/polars/expr.rb', line 1467 def arg_min _from_rbexpr(_rbexpr.arg_min) end |
#arg_sort(reverse: false, nulls_last: false) ⇒ Expr
Get the index values that would sort this column.
1419 1420 1421 |
# File 'lib/polars/expr.rb', line 1419 def arg_sort(reverse: false, nulls_last: false) _from_rbexpr(_rbexpr.arg_sort(reverse, nulls_last)) end |
#arg_unique ⇒ Expr
Get index of first unique value.
2148 2149 2150 |
# File 'lib/polars/expr.rb', line 2148 def arg_unique _from_rbexpr(_rbexpr.arg_unique) end |
#argsort(reverse: false, nulls_last: false) ⇒ expr
Get the index values that would sort this column.
Alias for #arg_sort.
4707 4708 4709 |
# File 'lib/polars/expr.rb', line 4707 def argsort(reverse: false, nulls_last: false) arg_sort(reverse: reverse, nulls_last: nulls_last) end |
#arr ⇒ ArrayExpr
Create an object namespace of all array related methods.
5989 5990 5991 |
# File 'lib/polars/expr.rb', line 5989 def arr ArrayExpr.new(self) end |
#backward_fill(limit: nil) ⇒ Expr
Fill missing values with the next to be seen values.
1823 1824 1825 |
# File 'lib/polars/expr.rb', line 1823 def backward_fill(limit: nil) _from_rbexpr(_rbexpr.backward_fill(limit)) end |
#bin ⇒ BinaryExpr
Create an object namespace of all binary related methods.
5996 5997 5998 |
# File 'lib/polars/expr.rb', line 5996 def bin BinaryExpr.new(self) end |
#bottom_k(k: 5) ⇒ Expr
Return the k
smallest elements.
If 'reverse: true` the smallest elements will be given.
1387 1388 1389 1390 |
# File 'lib/polars/expr.rb', line 1387 def bottom_k(k: 5) k = Utils.parse_as_expression(k) _from_rbexpr(_rbexpr.bottom_k(k)) end |
#cast(dtype, strict: true) ⇒ Expr
Cast between data types.
1234 1235 1236 1237 |
# File 'lib/polars/expr.rb', line 1234 def cast(dtype, strict: true) dtype = Utils.rb_type_to_dtype(dtype) _from_rbexpr(_rbexpr.cast(dtype, strict)) end |
#cat ⇒ CatExpr
Create an object namespace of all categorical related methods.
6003 6004 6005 |
# File 'lib/polars/expr.rb', line 6003 def cat CatExpr.new(self) end |
#ceil ⇒ Expr
Rounds up to the nearest integer value.
Only works on floating point Series.
1113 1114 1115 |
# File 'lib/polars/expr.rb', line 1113 def ceil _from_rbexpr(_rbexpr.ceil) end |
#clip(lower_bound, upper_bound) ⇒ Expr
Set values outside the given boundaries to the boundary value.
Only works for numeric and temporal columns. If you want to clip other data
types, consider writing a when-then-otherwise
expression.
4929 4930 4931 4932 4933 4934 4935 4936 4937 |
# File 'lib/polars/expr.rb', line 4929 def clip(lower_bound, upper_bound) if !lower_bound.nil? lower_bound = Utils.parse_as_expression(lower_bound, str_as_lit: true) end if !upper_bound.nil? upper_bound = Utils.parse_as_expression(upper_bound, str_as_lit: true) end _from_rbexpr(_rbexpr.clip(lower_bound, upper_bound)) end |
#clip_max(upper_bound) ⇒ Expr
Clip (limit) the values in an array to a max
boundary.
Only works for numerical types.
If you want to clip other dtypes, consider writing a "when, then, otherwise"
expression. See when
for more information.
4997 4998 4999 |
# File 'lib/polars/expr.rb', line 4997 def clip_max(upper_bound) clip(nil, upper_bound) end |
#clip_min(lower_bound) ⇒ Expr
Clip (limit) the values in an array to a min
boundary.
Only works for numerical types.
If you want to clip other dtypes, consider writing a "when, then, otherwise"
expression. See when
for more information.
4966 4967 4968 |
# File 'lib/polars/expr.rb', line 4966 def clip_min(lower_bound) clip(lower_bound, nil) end |
#cos ⇒ Expr
Compute the element-wise value for the cosine.
5107 5108 5109 |
# File 'lib/polars/expr.rb', line 5107 def cos _from_rbexpr(_rbexpr.cos) end |
#cosh ⇒ Expr
Compute the element-wise value for the hyperbolic cosine.
5227 5228 5229 |
# File 'lib/polars/expr.rb', line 5227 def cosh _from_rbexpr(_rbexpr.cosh) end |
#count ⇒ Expr
Count the number of values in this expression.
721 722 723 |
# File 'lib/polars/expr.rb', line 721 def count _from_rbexpr(_rbexpr.count) end |
#cum_count(reverse: false) ⇒ Expr Also known as: cumcount
Get an array with the cumulative count computed at every element.
Counting from 0 to len
1062 1063 1064 |
# File 'lib/polars/expr.rb', line 1062 def cum_count(reverse: false) _from_rbexpr(_rbexpr.cum_count(reverse)) end |
#cum_max(reverse: false) ⇒ Expr Also known as: cummax
Get an array with the cumulative max computed at every element.
1028 1029 1030 |
# File 'lib/polars/expr.rb', line 1028 def cum_max(reverse: false) _from_rbexpr(_rbexpr.cum_max(reverse)) end |
#cum_min(reverse: false) ⇒ Expr Also known as: cummin
Get an array with the cumulative min computed at every element.
996 997 998 |
# File 'lib/polars/expr.rb', line 996 def cum_min(reverse: false) _from_rbexpr(_rbexpr.cum_min(reverse)) end |
#cum_prod(reverse: false) ⇒ Expr Also known as: cumprod
Dtypes in :i8
, :u8
, :i16
, and :u16
are cast to
:i64
before summing to prevent overflow issues.
Get an array with the cumulative product computed at every element.
964 965 966 |
# File 'lib/polars/expr.rb', line 964 def cum_prod(reverse: false) _from_rbexpr(_rbexpr.cum_prod(reverse)) end |
#cum_sum(reverse: false) ⇒ Expr Also known as: cumsum
Dtypes in :i8
, :u8
, :i16
, and :u16
are cast to
:i64
before summing to prevent overflow issues.
Get an array with the cumulative sum computed at every element.
928 929 930 |
# File 'lib/polars/expr.rb', line 928 def cum_sum(reverse: false) _from_rbexpr(_rbexpr.cum_sum(reverse)) end |
#cumulative_eval(expr, min_periods: 1, parallel: false) ⇒ Expr
This functionality is experimental and may change without it being considered a breaking change.
This can be really slow as it can have O(n^2)
complexity. Don't use this
for operations that visit all elements.
Run an expression over a sliding window that increases 1
slot every iteration.
5722 5723 5724 5725 5726 |
# File 'lib/polars/expr.rb', line 5722 def cumulative_eval(expr, min_periods: 1, parallel: false) _from_rbexpr( _rbexpr.cumulative_eval(expr._rbexpr, min_periods, parallel) ) end |
#cut(breaks, labels: nil, left_closed: false, include_breaks: false) ⇒ Expr
Bin continuous values into discrete categories.
2531 2532 2533 |
# File 'lib/polars/expr.rb', line 2531 def cut(breaks, labels: nil, left_closed: false, include_breaks: false) _from_rbexpr(_rbexpr.cut(breaks, labels, left_closed, include_breaks)) end |
#diff(n: 1, null_behavior: "ignore") ⇒ Expr
Calculate the n-th discrete difference.
4800 4801 4802 |
# File 'lib/polars/expr.rb', line 4800 def diff(n: 1, null_behavior: "ignore") _from_rbexpr(_rbexpr.diff(n, null_behavior)) end |
#dot(other) ⇒ Expr
Compute the dot/inner product between two Expressions.
1167 1168 1169 1170 |
# File 'lib/polars/expr.rb', line 1167 def dot(other) other = Utils.expr_to_lit_or_expr(other, str_to_lit: false) _from_rbexpr(_rbexpr.dot(other._rbexpr)) end |
#drop_nans ⇒ Expr
Drop floating point NaN values.
893 894 895 |
# File 'lib/polars/expr.rb', line 893 def drop_nans _from_rbexpr(_rbexpr.drop_nans) end |
#drop_nulls ⇒ Expr
Drop null values.
866 867 868 |
# File 'lib/polars/expr.rb', line 866 def drop_nulls _from_rbexpr(_rbexpr.drop_nulls) end |
#dt ⇒ DateTimeExpr
Create an object namespace of all datetime related methods.
6010 6011 6012 |
# File 'lib/polars/expr.rb', line 6010 def dt DateTimeExpr.new(self) end |
#entropy(base: 2, normalize: true) ⇒ Expr
Computes the entropy.
Uses the formula -sum(pk * log(pk)
where pk
are discrete probabilities.
5675 5676 5677 |
# File 'lib/polars/expr.rb', line 5675 def entropy(base: 2, normalize: true) _from_rbexpr(_rbexpr.entropy(base, normalize)) end |
#eq(other) ⇒ Expr
Method equivalent of equality operator expr == other
.
3047 3048 3049 |
# File 'lib/polars/expr.rb', line 3047 def eq(other) self == other end |
#eq_missing(other) ⇒ Expr
Method equivalent of equality operator expr == other
where None == None
.
This differs from default eq
where null values are propagated.
3085 3086 3087 3088 |
# File 'lib/polars/expr.rb', line 3085 def eq_missing(other) other = Utils.parse_as_expression(other, str_as_lit: true) _from_rbexpr(_rbexpr.eq_missing(other)) end |
#ewm_mean(com: nil, span: nil, half_life: nil, alpha: nil, adjust: true, min_periods: 1, ignore_nulls: true) ⇒ Expr
Exponentially-weighted moving average.
5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 |
# File 'lib/polars/expr.rb', line 5439 def ewm_mean( com: nil, span: nil, half_life: nil, alpha: nil, adjust: true, min_periods: 1, ignore_nulls: true ) alpha = _prepare_alpha(com, span, half_life, alpha) _from_rbexpr(_rbexpr.ewm_mean(alpha, adjust, min_periods, ignore_nulls)) end |
#ewm_std(com: nil, span: nil, half_life: nil, alpha: nil, adjust: true, bias: false, min_periods: 1, ignore_nulls: true) ⇒ Expr
Exponentially-weighted moving standard deviation.
5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 |
# File 'lib/polars/expr.rb', line 5470 def ewm_std( com: nil, span: nil, half_life: nil, alpha: nil, adjust: true, bias: false, min_periods: 1, ignore_nulls: true ) alpha = _prepare_alpha(com, span, half_life, alpha) _from_rbexpr(_rbexpr.ewm_std(alpha, adjust, bias, min_periods, ignore_nulls)) end |
#ewm_var(com: nil, span: nil, half_life: nil, alpha: nil, adjust: true, bias: false, min_periods: 1, ignore_nulls: true) ⇒ Expr
Exponentially-weighted moving variance.
5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 |
# File 'lib/polars/expr.rb', line 5502 def ewm_var( com: nil, span: nil, half_life: nil, alpha: nil, adjust: true, bias: false, min_periods: 1, ignore_nulls: true ) alpha = _prepare_alpha(com, span, half_life, alpha) _from_rbexpr(_rbexpr.ewm_var(alpha, adjust, bias, min_periods, ignore_nulls)) end |
#exclude(columns) ⇒ Expr
Exclude certain columns from a wildcard/regex selection.
You may also use regexes in the exclude list. They must start with ^
and end
with $
.
365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 |
# File 'lib/polars/expr.rb', line 365 def exclude(columns) if columns.is_a?(::String) columns = [columns] return _from_rbexpr(_rbexpr.exclude(columns)) elsif !columns.is_a?(::Array) columns = [columns] return _from_rbexpr(_rbexpr.exclude_dtype(columns)) end if !columns.all? { |a| a.is_a?(::String) } || !columns.all? { |a| Utils.is_polars_dtype(a) } raise ArgumentError, "input should be all string or all DataType" end if columns[0].is_a?(::String) _from_rbexpr(_rbexpr.exclude(columns)) else _from_rbexpr(_rbexpr.exclude_dtype(columns)) end end |
#exp ⇒ Expr
Compute the exponential, element-wise.
289 290 291 |
# File 'lib/polars/expr.rb', line 289 def exp _from_rbexpr(_rbexpr.exp) end |
#explode ⇒ Expr
Explode a list or utf8 Series.
This means that every item is expanded to a new row.
2930 2931 2932 |
# File 'lib/polars/expr.rb', line 2930 def explode _from_rbexpr(_rbexpr.explode) end |
#extend_constant(value, n) ⇒ Expr
Extend the Series with given number of values.
5542 5543 5544 |
# File 'lib/polars/expr.rb', line 5542 def extend_constant(value, n) _from_rbexpr(_rbexpr.extend_constant(value, n)) end |
#fill_nan(fill_value) ⇒ Expr
Fill floating point NaN value with a fill value.
1762 1763 1764 1765 |
# File 'lib/polars/expr.rb', line 1762 def fill_nan(fill_value) fill_value = Utils.expr_to_lit_or_expr(fill_value, str_to_lit: true) _from_rbexpr(_rbexpr.fill_nan(fill_value._rbexpr)) end |
#fill_null(value = nil, strategy: nil, limit: nil) ⇒ Expr
Fill null values using the specified value or strategy.
To interpolate over null values see interpolate.
1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 |
# File 'lib/polars/expr.rb', line 1722 def fill_null(value = nil, strategy: nil, limit: nil) if !value.nil? && !strategy.nil? raise ArgumentError, "cannot specify both 'value' and 'strategy'." elsif value.nil? && strategy.nil? raise ArgumentError, "must specify either a fill 'value' or 'strategy'" elsif ["forward", "backward"].include?(strategy) && !limit.nil? raise ArgumentError, "can only specify 'limit' when strategy is set to 'backward' or 'forward'" end if !value.nil? value = Utils.expr_to_lit_or_expr(value, str_to_lit: true) _from_rbexpr(_rbexpr.fill_null(value._rbexpr)) else _from_rbexpr(_rbexpr.fill_null_with_strategy(strategy, limit)) end end |
#filter(predicate) ⇒ Expr
Filter a single column.
Mostly useful in an aggregation context. If you want to filter on a DataFrame
level, use LazyFrame#filter
.
2714 2715 2716 |
# File 'lib/polars/expr.rb', line 2714 def filter(predicate) _from_rbexpr(_rbexpr.filter(predicate._rbexpr)) end |
#first ⇒ Expr
Get the first value.
2196 2197 2198 |
# File 'lib/polars/expr.rb', line 2196 def first _from_rbexpr(_rbexpr.first) end |
#flatten ⇒ Expr
Explode a list or utf8 Series. This means that every item is expanded to a new row.
Alias for #explode.
2903 2904 2905 |
# File 'lib/polars/expr.rb', line 2903 def flatten _from_rbexpr(_rbexpr.explode) end |
#floor ⇒ Expr
Rounds down to the nearest integer value.
Only works on floating point Series.
1088 1089 1090 |
# File 'lib/polars/expr.rb', line 1088 def floor _from_rbexpr(_rbexpr.floor) end |
#floordiv(other) ⇒ Expr
Method equivalent of integer division operator expr // other
.
3367 3368 3369 |
# File 'lib/polars/expr.rb', line 3367 def floordiv(other) _from_rbexpr(_rbexpr.floordiv(_to_rbexpr(other))) end |
#forward_fill(limit: nil) ⇒ Expr
Fill missing values with the latest seen values.
1793 1794 1795 |
# File 'lib/polars/expr.rb', line 1793 def forward_fill(limit: nil) _from_rbexpr(_rbexpr.forward_fill(limit)) end |
#gather(indices) ⇒ Expr Also known as: take
Take values by index.
1591 1592 1593 1594 1595 1596 1597 1598 |
# File 'lib/polars/expr.rb', line 1591 def gather(indices) if indices.is_a?(::Array) indices_lit = Polars.lit(Series.new("", indices, dtype: :u32)) else indices_lit = Utils.expr_to_lit_or_expr(indices, str_to_lit: false) end _from_rbexpr(_rbexpr.gather(indices_lit._rbexpr)) end |
#gather_every(n, offset = 0) ⇒ Expr Also known as: take_every
Take every nth value in the Series and return as a new Series.
2952 2953 2954 |
# File 'lib/polars/expr.rb', line 2952 def gather_every(n, offset = 0) _from_rbexpr(_rbexpr.gather_every(n, offset)) end |
#ge(other) ⇒ Expr
Method equivalent of "greater than or equal" operator expr >= other
.
3119 3120 3121 |
# File 'lib/polars/expr.rb', line 3119 def ge(other) self >= other end |
#gt(other) ⇒ Expr
Method equivalent of "greater than" operator expr > other
.
3152 3153 3154 |
# File 'lib/polars/expr.rb', line 3152 def gt(other) self > other end |
#head(n = 10) ⇒ Expr
Get the first n
rows.
2978 2979 2980 |
# File 'lib/polars/expr.rb', line 2978 def head(n = 10) _from_rbexpr(_rbexpr.head(n)) end |
#implode ⇒ Expr
Aggregate to list.
5778 5779 5780 |
# File 'lib/polars/expr.rb', line 5778 def implode _from_rbexpr(_rbexpr.implode) end |
#interpolate(method: "linear") ⇒ Expr
Fill nulls with linear interpolation over missing values.
Can also be used to regrid data to a new grid - see examples below.
3855 3856 3857 |
# File 'lib/polars/expr.rb', line 3855 def interpolate(method: "linear") _from_rbexpr(_rbexpr.interpolate(method)) end |
#is_between(start, _end, closed: "both") ⇒ Expr
Check if this expression is between start and end.
3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 |
# File 'lib/polars/expr.rb', line 3702 def is_between(start, _end, closed: "both") start = Utils.expr_to_lit_or_expr(start, str_to_lit: false) _end = Utils.expr_to_lit_or_expr(_end, str_to_lit: false) case closed when "none" (self > start) & (self < _end) when "both" (self >= start) & (self <= _end) when "right" (self > start) & (self <= _end) when "left" (self >= start) & (self < _end) else raise ArgumentError, "closed must be one of 'left', 'right', 'both', or 'none'" end end |
#is_duplicated ⇒ Expr
Get mask of duplicated values.
2353 2354 2355 |
# File 'lib/polars/expr.rb', line 2353 def is_duplicated _from_rbexpr(_rbexpr.is_duplicated) end |
#is_finite ⇒ Expr
Returns a boolean Series indicating which values are finite.
574 575 576 |
# File 'lib/polars/expr.rb', line 574 def is_finite _from_rbexpr(_rbexpr.is_finite) end |
#is_first_distinct ⇒ Expr Also known as: is_first
Get a mask of the first unique value.
2330 2331 2332 |
# File 'lib/polars/expr.rb', line 2330 def is_first_distinct _from_rbexpr(_rbexpr.is_first_distinct) end |
#is_in(other) ⇒ Expr Also known as: in?
Check if elements of this expression are present in the other Series.
3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 |
# File 'lib/polars/expr.rb', line 3587 def is_in(other) if other.is_a?(::Array) if other.length == 0 other = Polars.lit(nil) else other = Polars.lit(Series.new(other)) end else other = Utils.expr_to_lit_or_expr(other, str_to_lit: false) end _from_rbexpr(_rbexpr.is_in(other._rbexpr)) end |
#is_infinite ⇒ Expr
Returns a boolean Series indicating which values are infinite.
600 601 602 |
# File 'lib/polars/expr.rb', line 600 def is_infinite _from_rbexpr(_rbexpr.is_infinite) end |
#is_nan ⇒ Expr
Floating point NaN
(Not A Number) should not be confused
with missing data represented as nil
.
Returns a boolean Series indicating which values are NaN.
633 634 635 |
# File 'lib/polars/expr.rb', line 633 def is_nan _from_rbexpr(_rbexpr.is_nan) end |
#is_not ⇒ Expr Also known as: not_
Negate a boolean expression.
489 490 491 |
# File 'lib/polars/expr.rb', line 489 def is_not _from_rbexpr(_rbexpr.not_) end |
#is_not_nan ⇒ Expr
Floating point NaN
(Not A Number) should not be confused
with missing data represented as nil
.
Returns a boolean Series indicating which values are not NaN.
666 667 668 |
# File 'lib/polars/expr.rb', line 666 def is_not_nan _from_rbexpr(_rbexpr.is_not_nan) end |
#is_not_null ⇒ Expr
Returns a boolean Series indicating which values are not null.
548 549 550 |
# File 'lib/polars/expr.rb', line 548 def is_not_null _from_rbexpr(_rbexpr.is_not_null) end |
#is_null ⇒ Expr
Returns a boolean Series indicating which values are null.
519 520 521 |
# File 'lib/polars/expr.rb', line 519 def is_null _from_rbexpr(_rbexpr.is_null) end |
#is_unique ⇒ Expr
Get mask of unique values.
2302 2303 2304 |
# File 'lib/polars/expr.rb', line 2302 def is_unique _from_rbexpr(_rbexpr.is_unique) end |
#keep_name ⇒ Expr
Keep the original root name of the expression.
407 408 409 |
# File 'lib/polars/expr.rb', line 407 def keep_name name.keep end |
#kurtosis(fisher: true, bias: true) ⇒ Expr
Compute the kurtosis (Fisher or Pearson) of a dataset.
Kurtosis is the fourth central moment divided by the square of the variance. If Fisher's definition is used, then 3.0 is subtracted from the result to give 0.0 for a normal distribution. If bias is False then the kurtosis is calculated using k statistics to eliminate bias coming from biased moment estimators
4898 4899 4900 |
# File 'lib/polars/expr.rb', line 4898 def kurtosis(fisher: true, bias: true) _from_rbexpr(_rbexpr.kurtosis(fisher, bias)) end |
#last ⇒ Expr
Get the last value.
2216 2217 2218 |
# File 'lib/polars/expr.rb', line 2216 def last _from_rbexpr(_rbexpr.last) end |
#le(other) ⇒ Expr
Method equivalent of "less than or equal" operator expr <= other
.
3185 3186 3187 |
# File 'lib/polars/expr.rb', line 3185 def le(other) self <= other end |
#len ⇒ Expr Also known as: length
Count the number of values in this expression.
741 742 743 |
# File 'lib/polars/expr.rb', line 741 def len _from_rbexpr(_rbexpr.len) end |
#limit(n = 10) ⇒ Expr
Get the first n
rows.
Alias for #head.
3015 3016 3017 |
# File 'lib/polars/expr.rb', line 3015 def limit(n = 10) head(n) end |
#list ⇒ ListExpr
Create an object namespace of all list related methods.
5982 5983 5984 |
# File 'lib/polars/expr.rb', line 5982 def list ListExpr.new(self) end |
#log(base = Math::E) ⇒ Expr
Compute the logarithm to a given base.
5636 5637 5638 |
# File 'lib/polars/expr.rb', line 5636 def log(base = Math::E) _from_rbexpr(_rbexpr.log(base)) end |
#log10 ⇒ Expr
Compute the base 10 logarithm of the input array, element-wise.
267 268 269 |
# File 'lib/polars/expr.rb', line 267 def log10 log(10) end |
#lower_bound ⇒ Expr
Calculate the lower bound.
Returns a unit Series with the lowest value possible for the dtype of this expression.
5020 5021 5022 |
# File 'lib/polars/expr.rb', line 5020 def lower_bound _from_rbexpr(_rbexpr.lower_bound) end |
#lt(other) ⇒ Expr
Method equivalent of "less than" operator expr < other
.
3218 3219 3220 |
# File 'lib/polars/expr.rb', line 3218 def lt(other) self < other end |
#map_alias(&f) ⇒ Expr
Rename the output of an expression by mapping a function over the root name.
449 450 451 |
# File 'lib/polars/expr.rb', line 449 def map_alias(&f) name.map(&f) end |
#max ⇒ Expr
Get maximum value.
1896 1897 1898 |
# File 'lib/polars/expr.rb', line 1896 def max _from_rbexpr(_rbexpr.max) end |
#mean ⇒ Expr
Get mean value.
2000 2001 2002 |
# File 'lib/polars/expr.rb', line 2000 def mean _from_rbexpr(_rbexpr.mean) end |
#median ⇒ Expr
Get median value using linear interpolation.
2020 2021 2022 |
# File 'lib/polars/expr.rb', line 2020 def median _from_rbexpr(_rbexpr.median) end |
#meta ⇒ MetaExpr
Create an object namespace of all meta related expression methods.
6017 6018 6019 |
# File 'lib/polars/expr.rb', line 6017 def MetaExpr.new(self) end |
#min ⇒ Expr
Get minimum value.
1916 1917 1918 |
# File 'lib/polars/expr.rb', line 1916 def min _from_rbexpr(_rbexpr.min) end |
#mod(other) ⇒ Expr
Method equivalent of modulus operator expr % other
.
3394 3395 3396 |
# File 'lib/polars/expr.rb', line 3394 def mod(other) self % other end |
#mode ⇒ Expr
Compute the most occurring value(s).
Can return multiple Values.
1196 1197 1198 |
# File 'lib/polars/expr.rb', line 1196 def mode _from_rbexpr(_rbexpr.mode) end |
#mul(other) ⇒ Expr
Method equivalent of multiplication operator expr * other
.
3424 3425 3426 |
# File 'lib/polars/expr.rb', line 3424 def mul(other) self * other end |
#n_unique ⇒ Expr
Count unique values.
2060 2061 2062 |
# File 'lib/polars/expr.rb', line 2060 def n_unique _from_rbexpr(_rbexpr.n_unique) end |
#name ⇒ NameExpr
Create an object namespace of all expressions that modify expression names.
6024 6025 6026 |
# File 'lib/polars/expr.rb', line 6024 def name NameExpr.new(self) end |
#nan_max ⇒ Expr
Get maximum value, but propagate/poison encountered NaN values.
1936 1937 1938 |
# File 'lib/polars/expr.rb', line 1936 def nan_max _from_rbexpr(_rbexpr.nan_max) end |
#nan_min ⇒ Expr
Get minimum value, but propagate/poison encountered NaN values.
1956 1957 1958 |
# File 'lib/polars/expr.rb', line 1956 def nan_min _from_rbexpr(_rbexpr.nan_min) end |
#ne(other) ⇒ Expr
Method equivalent of inequality operator expr != other
.
3251 3252 3253 |
# File 'lib/polars/expr.rb', line 3251 def ne(other) self != other end |
#ne_missing(other) ⇒ Expr
Method equivalent of equality operator expr != other
where None == None
.
This differs from default ne
where null values are propagated.
3289 3290 3291 3292 |
# File 'lib/polars/expr.rb', line 3289 def ne_missing(other) other = Utils.parse_as_expression(other, str_as_lit: true) _from_rbexpr(_rbexpr.neq_missing(other)) end |
#neg ⇒ Expr
Method equivalent of unary minus operator -expr
.
3477 3478 3479 |
# File 'lib/polars/expr.rb', line 3477 def neg -self end |
#null_count ⇒ Expr
Count null values.
2108 2109 2110 |
# File 'lib/polars/expr.rb', line 2108 def null_count _from_rbexpr(_rbexpr.null_count) end |
#over(expr) ⇒ Expr
Apply window function over a subgroup.
This is similar to a group by + aggregation + self join. Or similar to window functions in Postgres.
2279 2280 2281 2282 |
# File 'lib/polars/expr.rb', line 2279 def over(expr) rbexprs = Utils.selection_to_rbexpr_list(expr) _from_rbexpr(_rbexpr.over(rbexprs)) end |
#pct_change(n: 1) ⇒ Expr
Computes percentage change between values.
Percentage change (as fraction) between current element and most-recent
non-null element at least n
period(s) before the current element.
Computes the change from the previous row by default.
4836 4837 4838 4839 |
# File 'lib/polars/expr.rb', line 4836 def pct_change(n: 1) n = Utils.parse_as_expression(n) _from_rbexpr(_rbexpr.pct_change(n)) end |
#peak_max ⇒ Expr
Get a boolean mask of the local maximum peaks.
2377 2378 2379 |
# File 'lib/polars/expr.rb', line 2377 def peak_max _from_rbexpr(_rbexpr.peak_max) end |
#peak_min ⇒ Expr
Get a boolean mask of the local minimum peaks.
2401 2402 2403 |
# File 'lib/polars/expr.rb', line 2401 def peak_min _from_rbexpr(_rbexpr.peak_min) end |
#pow(exponent) ⇒ Expr
Raise expression to the power of exponent.
3532 3533 3534 |
# File 'lib/polars/expr.rb', line 3532 def pow(exponent) self**exponent end |
#prefix(prefix) ⇒ Expr
Add a prefix to the root column name of the expression.
414 415 416 |
# File 'lib/polars/expr.rb', line 414 def prefix(prefix) name.prefix(prefix) end |
#product ⇒ Expr
Compute the product of an expression.
2040 2041 2042 |
# File 'lib/polars/expr.rb', line 2040 def product _from_rbexpr(_rbexpr.product) end |
#qcut(quantiles, labels: nil, left_closed: false, allow_duplicates: false, include_breaks: false) ⇒ Expr
Bin continuous values into discrete categories based on their quantiles.
2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 |
# File 'lib/polars/expr.rb', line 2612 def qcut(quantiles, labels: nil, left_closed: false, allow_duplicates: false, include_breaks: false) if quantiles.is_a?(Integer) rbexpr = _rbexpr.qcut_uniform( quantiles, labels, left_closed, allow_duplicates, include_breaks ) else rbexpr = _rbexpr.qcut( quantiles, labels, left_closed, allow_duplicates, include_breaks ) end _from_rbexpr(rbexpr) end |
#quantile(quantile, interpolation: "nearest") ⇒ Expr
Get quantile value.
2474 2475 2476 2477 |
# File 'lib/polars/expr.rb', line 2474 def quantile(quantile, interpolation: "nearest") quantile = Utils.expr_to_lit_or_expr(quantile, str_to_lit: false) _from_rbexpr(_rbexpr.quantile(quantile._rbexpr, interpolation)) end |
#rank(method: "average", reverse: false, seed: nil) ⇒ Expr
Assign ranks to data, dealing with ties appropriately.
4769 4770 4771 |
# File 'lib/polars/expr.rb', line 4769 def rank(method: "average", reverse: false, seed: nil) _from_rbexpr(_rbexpr.rank(method, reverse, seed)) end |
#rechunk ⇒ Expr
Create a single chunk of memory for this Series.
839 840 841 |
# File 'lib/polars/expr.rb', line 839 def rechunk _from_rbexpr(_rbexpr.rechunk) end |
#reinterpret(signed: false) ⇒ Expr
Reinterpret the underlying bits as a signed/unsigned integer.
This operation is only allowed for 64bit integers. For lower bits integers, you can safely use that cast operation.
3792 3793 3794 |
# File 'lib/polars/expr.rb', line 3792 def reinterpret(signed: false) _from_rbexpr(_rbexpr.reinterpret(signed)) end |
#repeat_by(by) ⇒ Expr
Repeat the elements in this Series as specified in the given expression.
The repeated elements are expanded into a List
.
3631 3632 3633 3634 |
# File 'lib/polars/expr.rb', line 3631 def repeat_by(by) by = Utils.expr_to_lit_or_expr(by, str_to_lit: false) _from_rbexpr(_rbexpr.repeat_by(by._rbexpr)) end |
#replace(old, new = NO_DEFAULT, default: NO_DEFAULT, return_dtype: nil) ⇒ Expr
Replace values by different values.
5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 |
# File 'lib/polars/expr.rb', line 5953 def replace(old, new = NO_DEFAULT, default: NO_DEFAULT, return_dtype: nil) if new.eql?(NO_DEFAULT) && old.is_a?(Hash) new = Series.new(old.values) old = Series.new(old.keys) else if old.is_a?(::Array) old = Series.new(old) end if new.is_a?(::Array) new = Series.new(new) end end old = Utils.parse_as_expression(old, str_as_lit: true) new = Utils.parse_as_expression(new, str_as_lit: true) default = if default.eql?(NO_DEFAULT) nil else Utils.parse_as_expression(default, str_as_lit: true) end _from_rbexpr(_rbexpr.replace(old, new, default, return_dtype)) end |
#reshape(dims) ⇒ Expr
Reshape this Expr to a flat Series or a Series of Lists.
5333 5334 5335 |
# File 'lib/polars/expr.rb', line 5333 def reshape(dims) _from_rbexpr(_rbexpr.reshape(dims)) end |
#reverse ⇒ Expr
Reverse the selection.
1830 1831 1832 |
# File 'lib/polars/expr.rb', line 1830 def reverse _from_rbexpr(_rbexpr.reverse) end |
#rle ⇒ Expr
Get the lengths of runs of identical values.
2647 2648 2649 |
# File 'lib/polars/expr.rb', line 2647 def rle _from_rbexpr(_rbexpr.rle) end |
#rle_id ⇒ Expr
Map values to run IDs.
Similar to RLE, but it maps each value to an ID corresponding to the run into which it falls. This is especially useful when you want to define groups by runs of identical values rather than the values themselves.
2675 2676 2677 |
# File 'lib/polars/expr.rb', line 2675 def rle_id _from_rbexpr(_rbexpr.rle_id) end |
#rolling_max(window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left") ⇒ Expr
This functionality is experimental and may change without it being considered a breaking change.
If you want to compute multiple aggregation statistics over the same dynamic
window, consider using group_by_rolling
this method can cache the window size
computation.
Apply a rolling max (moving max) over the values in this array.
A window of length window_size
will traverse the array. The values that fill
this window will (optionally) be multiplied with the weights given by the
weight
vector. The resulting values will be aggregated to their sum.
4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 |
# File 'lib/polars/expr.rb', line 4019 def rolling_max( window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left" ) window_size, min_periods = _prepare_rolling_window_args( window_size, min_periods ) _from_rbexpr( _rbexpr.rolling_max( window_size, weights, min_periods, center, by, closed ) ) end |
#rolling_mean(window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left") ⇒ Expr
This functionality is experimental and may change without it being considered a breaking change.
If you want to compute multiple aggregation statistics over the same dynamic
window, consider using group_by_rolling
this method can cache the window size
computation.
Apply a rolling mean (moving mean) over the values in this array.
A window of length window_size
will traverse the array. The values that fill
this window will (optionally) be multiplied with the weights given by the
weight
vector. The resulting values will be aggregated to their sum.
4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 |
# File 'lib/polars/expr.rb', line 4108 def rolling_mean( window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left" ) window_size, min_periods = _prepare_rolling_window_args( window_size, min_periods ) _from_rbexpr( _rbexpr.rolling_mean( window_size, weights, min_periods, center, by, closed ) ) end |
#rolling_median(window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left", warn_if_unsorted: true) ⇒ Expr
This functionality is experimental and may change without it being considered a breaking change.
If you want to compute multiple aggregation statistics over the same dynamic
window, consider using group_by_rolling
this method can cache the window size
computation.
Compute a rolling median.
4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 |
# File 'lib/polars/expr.rb', line 4464 def rolling_median( window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left", warn_if_unsorted: true ) window_size, min_periods = _prepare_rolling_window_args( window_size, min_periods ) _from_rbexpr( _rbexpr.rolling_median( window_size, weights, min_periods, center, by, closed, warn_if_unsorted ) ) end |
#rolling_min(window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left") ⇒ Expr
This functionality is experimental and may change without it being considered a breaking change.
If you want to compute multiple aggregation statistics over the same dynamic
window, consider using group_by_rolling
this method can cache the window size
computation.
Apply a rolling min (moving min) over the values in this array.
A window of length window_size
will traverse the array. The values that fill
this window will (optionally) be multiplied with the weights given by the
weight
vector. The resulting values will be aggregated to their sum.
3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 |
# File 'lib/polars/expr.rb', line 3930 def rolling_min( window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left" ) window_size, min_periods = _prepare_rolling_window_args( window_size, min_periods ) _from_rbexpr( _rbexpr.rolling_min( window_size, weights, min_periods, center, by, closed ) ) end |
#rolling_quantile(quantile, interpolation: "nearest", window_size: 2, weights: nil, min_periods: nil, center: false, by: nil, closed: "left", warn_if_unsorted: true) ⇒ Expr
This functionality is experimental and may change without it being considered a breaking change.
If you want to compute multiple aggregation statistics over the same dynamic
window, consider using group_by_rolling
this method can cache the window size
computation.
Compute a rolling quantile.
4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 |
# File 'lib/polars/expr.rb', line 4554 def rolling_quantile( quantile, interpolation: "nearest", window_size: 2, weights: nil, min_periods: nil, center: false, by: nil, closed: "left", warn_if_unsorted: true ) window_size, min_periods = _prepare_rolling_window_args( window_size, min_periods ) _from_rbexpr( _rbexpr.rolling_quantile( quantile, interpolation, window_size, weights, min_periods, center, by, closed, warn_if_unsorted ) ) end |
#rolling_skew(window_size, bias: true) ⇒ Expr
Compute a rolling skew.
4647 4648 4649 |
# File 'lib/polars/expr.rb', line 4647 def rolling_skew(window_size, bias: true) _from_rbexpr(_rbexpr.rolling_skew(window_size, bias)) end |
#rolling_std(window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left", ddof: 1, warn_if_unsorted: true) ⇒ Expr
This functionality is experimental and may change without it being considered a breaking change.
If you want to compute multiple aggregation statistics over the same dynamic
window, consider using group_by_rolling
this method can cache the window size
computation.
Compute a rolling standard deviation.
A window of length window_size
will traverse the array. The values that fill
this window will (optionally) be multiplied with the weights given by the
weight
vector. The resulting values will be aggregated to their sum.
4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 |
# File 'lib/polars/expr.rb', line 4286 def rolling_std( window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left", ddof: 1, warn_if_unsorted: true ) window_size, min_periods = _prepare_rolling_window_args( window_size, min_periods ) _from_rbexpr( _rbexpr.rolling_std( window_size, weights, min_periods, center, by, closed, ddof, warn_if_unsorted ) ) end |
#rolling_sum(window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left") ⇒ Expr
This functionality is experimental and may change without it being considered a breaking change.
If you want to compute multiple aggregation statistics over the same dynamic
window, consider using group_by_rolling
this method can cache the window size
computation.
Apply a rolling sum (moving sum) over the values in this array.
A window of length window_size
will traverse the array. The values that fill
this window will (optionally) be multiplied with the weights given by the
weight
vector. The resulting values will be aggregated to their sum.
4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 |
# File 'lib/polars/expr.rb', line 4197 def rolling_sum( window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left" ) window_size, min_periods = _prepare_rolling_window_args( window_size, min_periods ) _from_rbexpr( _rbexpr.rolling_sum( window_size, weights, min_periods, center, by, closed ) ) end |
#rolling_var(window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left", ddof: 1, warn_if_unsorted: true) ⇒ Expr
This functionality is experimental and may change without it being considered a breaking change.
If you want to compute multiple aggregation statistics over the same dynamic
window, consider using group_by_rolling
this method can cache the window size
computation.
Compute a rolling variance.
A window of length window_size
will traverse the array. The values that fill
this window will (optionally) be multiplied with the weights given by the
weight
vector. The resulting values will be aggregated to their sum.
4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 |
# File 'lib/polars/expr.rb', line 4377 def rolling_var( window_size, weights: nil, min_periods: nil, center: false, by: nil, closed: "left", ddof: 1, warn_if_unsorted: true ) window_size, min_periods = _prepare_rolling_window_args( window_size, min_periods ) _from_rbexpr( _rbexpr.rolling_var( window_size, weights, min_periods, center, by, closed, ddof, warn_if_unsorted ) ) end |
#round(decimals = 0) ⇒ Expr
Round underlying floating point data by decimals
digits.
1139 1140 1141 |
# File 'lib/polars/expr.rb', line 1139 def round(decimals = 0) _from_rbexpr(_rbexpr.round(decimals)) end |
#sample(frac: nil, with_replacement: true, shuffle: false, seed: nil, n: nil) ⇒ Expr
Sample from this expression.
5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 |
# File 'lib/polars/expr.rb', line 5396 def sample( frac: nil, with_replacement: true, shuffle: false, seed: nil, n: nil ) if !n.nil? && !frac.nil? raise ArgumentError, "cannot specify both `n` and `frac`" end if !n.nil? && frac.nil? n = Utils.parse_as_expression(n) return _from_rbexpr(_rbexpr.sample_n(n, with_replacement, shuffle, seed)) end if frac.nil? frac = 1.0 end frac = Utils.parse_as_expression(frac) _from_rbexpr( _rbexpr.sample_frac(frac, with_replacement, shuffle, seed) ) end |
#search_sorted(element, side: "any") ⇒ Expr
Find indices where elements should be inserted to maintain order.
1500 1501 1502 1503 |
# File 'lib/polars/expr.rb', line 1500 def search_sorted(element, side: "any") element = Utils.expr_to_lit_or_expr(element, str_to_lit: false) _from_rbexpr(_rbexpr.search_sorted(element._rbexpr, side)) end |
#set_sorted(descending: false) ⇒ Expr
This can lead to incorrect results if this Series
is not sorted!!
Use with care!
Flags the expression as 'sorted'.
Enables downstream code to user fast paths for sorted arrays.
5753 5754 5755 |
# File 'lib/polars/expr.rb', line 5753 def set_sorted(descending: false) _from_rbexpr(_rbexpr.set_sorted_flag(descending)) end |
#shift(n = 1, fill_value: nil) ⇒ Expr
Shift the values by a given period.
1625 1626 1627 1628 1629 1630 1631 |
# File 'lib/polars/expr.rb', line 1625 def shift(n = 1, fill_value: nil) if !fill_value.nil? fill_value = Utils.parse_as_expression(fill_value, str_as_lit: true) end n = Utils.parse_as_expression(n) _from_rbexpr(_rbexpr.shift(n, fill_value)) end |
#shift_and_fill(periods, fill_value) ⇒ Expr
Shift the values by a given period and fill the resulting null values.
1657 1658 1659 |
# File 'lib/polars/expr.rb', line 1657 def shift_and_fill(periods, fill_value) shift(periods, fill_value: fill_value) end |
#shrink_dtype ⇒ Expr
Shrink numeric columns to the minimal required datatype.
Shrink to the dtype needed to fit the extrema of this Series
.
This can be used to reduce memory pressure.
5813 5814 5815 |
# File 'lib/polars/expr.rb', line 5813 def shrink_dtype _from_rbexpr(_rbexpr.shrink_dtype) end |
#shuffle(seed: nil) ⇒ Expr
Shuffle the contents of this expr.
5359 5360 5361 5362 5363 5364 |
# File 'lib/polars/expr.rb', line 5359 def shuffle(seed: nil) if seed.nil? seed = rand(10000) end _from_rbexpr(_rbexpr.shuffle(seed)) end |
#sign ⇒ Expr
Compute the element-wise indication of the sign.
5067 5068 5069 |
# File 'lib/polars/expr.rb', line 5067 def sign _from_rbexpr(_rbexpr.sign) end |
#sin ⇒ Expr
Compute the element-wise value for the sine.
5087 5088 5089 |
# File 'lib/polars/expr.rb', line 5087 def sin _from_rbexpr(_rbexpr.sin) end |
#sinh ⇒ Expr
Compute the element-wise value for the hyperbolic sine.
5207 5208 5209 |
# File 'lib/polars/expr.rb', line 5207 def sinh _from_rbexpr(_rbexpr.sinh) end |
#skew(bias: true) ⇒ Expr
Compute the sample skewness of a data set.
For normally distributed data, the skewness should be about zero. For
unimodal continuous distributions, a skewness value greater than zero means
that there is more weight in the right tail of the distribution. The
function skewtest
can be used to determine if the skewness value
is close enough to zero, statistically speaking.
4866 4867 4868 |
# File 'lib/polars/expr.rb', line 4866 def skew(bias: true) _from_rbexpr(_rbexpr.skew(bias)) end |
#slice(offset, length = nil) ⇒ Expr
Get a slice of this expression.
774 775 776 777 778 779 780 781 782 |
# File 'lib/polars/expr.rb', line 774 def slice(offset, length = nil) if !offset.is_a?(Expr) offset = Polars.lit(offset) end if !length.is_a?(Expr) length = Polars.lit(length) end _from_rbexpr(_rbexpr.slice(offset._rbexpr, length._rbexpr)) end |
#sort(reverse: false, nulls_last: false) ⇒ Expr
Sort this column. In projection/ selection context the whole column is sorted.
If used in a group by context, the groups are sorted.
1310 1311 1312 |
# File 'lib/polars/expr.rb', line 1310 def sort(reverse: false, nulls_last: false) _from_rbexpr(_rbexpr.sort_with(reverse, nulls_last)) end |
#sort_by(by, reverse: false) ⇒ Expr
Sort this column by the ordering of another column, or multiple other columns.
In projection/ selection context the whole column is sorted. If used in a group by context, the groups are sorted.
1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 |
# File 'lib/polars/expr.rb', line 1547 def sort_by(by, reverse: false) if !by.is_a?(::Array) by = [by] end if !reverse.is_a?(::Array) reverse = [reverse] end by = Utils.selection_to_rbexpr_list(by) _from_rbexpr(_rbexpr.sort_by(by, reverse)) end |
#sqrt ⇒ Expr
Compute the square root of the elements.
245 246 247 |
# File 'lib/polars/expr.rb', line 245 def sqrt self**0.5 end |
#std(ddof: 1) ⇒ Expr
Get standard deviation.
1853 1854 1855 |
# File 'lib/polars/expr.rb', line 1853 def std(ddof: 1) _from_rbexpr(_rbexpr.std(ddof)) end |
#str ⇒ StringExpr
Create an object namespace of all string related methods.
6031 6032 6033 |
# File 'lib/polars/expr.rb', line 6031 def str StringExpr.new(self) end |
#struct ⇒ StructExpr
Create an object namespace of all struct related methods.
6038 6039 6040 |
# File 'lib/polars/expr.rb', line 6038 def struct StructExpr.new(self) end |
#sub(other) ⇒ Expr
Method equivalent of subtraction operator expr - other
.
3454 3455 3456 |
# File 'lib/polars/expr.rb', line 3454 def sub(other) self - other end |
#suffix(suffix) ⇒ Expr
Add a suffix to the root column name of the expression.
421 422 423 |
# File 'lib/polars/expr.rb', line 421 def suffix(suffix) name.suffix(suffix) end |
#sum ⇒ Expr
Dtypes in :i8
, :u8
, :i16
, and :u16
are cast to
:i64
before summing to prevent overflow issues.
Get sum value.
1980 1981 1982 |
# File 'lib/polars/expr.rb', line 1980 def sum _from_rbexpr(_rbexpr.sum) end |
#tail(n = 10) ⇒ Expr
Get the last n
rows.
3003 3004 3005 |
# File 'lib/polars/expr.rb', line 3003 def tail(n = 10) _from_rbexpr(_rbexpr.tail(n)) end |
#tan ⇒ Expr
Compute the element-wise value for the tangent.
5127 5128 5129 |
# File 'lib/polars/expr.rb', line 5127 def tan _from_rbexpr(_rbexpr.tan) end |
#tanh ⇒ Expr
Compute the element-wise value for the hyperbolic tangent.
5247 5248 5249 |
# File 'lib/polars/expr.rb', line 5247 def tanh _from_rbexpr(_rbexpr.tanh) end |
#to_physical ⇒ Expr
Cast to physical representation of the logical dtype.
:date
->:i32
:datetime
->:i64
:time
->:i64
:duration
->:i64
:cat
->:u32
- Other data types will be left unchanged.
178 179 180 |
# File 'lib/polars/expr.rb', line 178 def to_physical _from_rbexpr(_rbexpr.to_physical) end |
#to_s ⇒ String Also known as: inspect
Returns a string representing the Expr.
20 21 22 |
# File 'lib/polars/expr.rb', line 20 def to_s _rbexpr.to_str end |
#top_k(k: 5) ⇒ Expr
Return the k
largest elements.
If 'reverse: true` the smallest elements will be given.
1348 1349 1350 1351 |
# File 'lib/polars/expr.rb', line 1348 def top_k(k: 5) k = Utils.parse_as_expression(k) _from_rbexpr(_rbexpr.top_k(k)) end |
#truediv(other) ⇒ Expr
Method equivalent of float division operator expr / other
.
3509 3510 3511 |
# File 'lib/polars/expr.rb', line 3509 def truediv(other) self / other end |
#unique(maintain_order: false) ⇒ Expr
Get unique values of this expression.
2172 2173 2174 2175 2176 2177 2178 |
# File 'lib/polars/expr.rb', line 2172 def unique(maintain_order: false) if maintain_order _from_rbexpr(_rbexpr.unique_stable) else _from_rbexpr(_rbexpr.unique) end end |
#unique_counts ⇒ Expr
Return a count of the unique values in the order of appearance.
This method differs from value_counts
in that it does not return the
values, only the counts and might be faster
5611 5612 5613 |
# File 'lib/polars/expr.rb', line 5611 def unique_counts _from_rbexpr(_rbexpr.unique_counts) end |
#upper_bound ⇒ Expr
Calculate the upper bound.
Returns a unit Series with the highest value possible for the dtype of this expression.
5043 5044 5045 |
# File 'lib/polars/expr.rb', line 5043 def upper_bound _from_rbexpr(_rbexpr.upper_bound) end |
#value_counts(multithreaded: false, sort: false) ⇒ Expr
Count all unique values and create a struct mapping value to count.
5578 5579 5580 |
# File 'lib/polars/expr.rb', line 5578 def value_counts(multithreaded: false, sort: false) _from_rbexpr(_rbexpr.value_counts(multithreaded, sort)) end |
#var(ddof: 1) ⇒ Expr
Get variance.
1876 1877 1878 |
# File 'lib/polars/expr.rb', line 1876 def var(ddof: 1) _from_rbexpr(_rbexpr.var(ddof)) end |
#where(predicate) ⇒ Expr
Filter a single column.
Alias for #filter.
2752 2753 2754 |
# File 'lib/polars/expr.rb', line 2752 def where(predicate) filter(predicate) end |
#xor(other) ⇒ Expr
Method equivalent of bitwise exclusive-or operator expr ^ other
.
3560 3561 3562 |
# File 'lib/polars/expr.rb', line 3560 def xor(other) self ^ other end |
#|(other) ⇒ Expr
Bitwise OR.
42 43 44 |
# File 'lib/polars/expr.rb', line 42 def |(other) _from_rbexpr(_rbexpr._or(_to_rbexpr(other))) end |