polars-df 0.6.0-aarch64-linux → 0.8.0-aarch64-linux

data/lib/polars/expr.rb

@@ -131,6 +131,13 @@ module Polars
       wrap_expr(_rbexpr.gt(_to_expr(other)._rbexpr))
     end
 
+    # Performs boolean not.
+    #
+    # @return [Expr]
+    def !
+      is_not
+    end
+
     # Performs negation.
     #
     # @return [Expr]
@@ -191,8 +198,8 @@ module Polars
     #   # ╞══════╪═══════╡
     #   # │ true ┆ false │
     #   # └──────┴───────┘
-    def any
-      wrap_expr(_rbexpr.any)
+    def any(drop_nulls: true)
+      wrap_expr(_rbexpr.any(drop_nulls))
     end
 
     # Check if all boolean values in a Boolean column are `true`.
@@ -216,8 +223,8 @@ module Polars
     #   # ╞══════╪═══════╪═══════╡
     #   # │ true ┆ false ┆ false │
     #   # └──────┴───────┴───────┘
-    def all
-      wrap_expr(_rbexpr.all)
+    def all(drop_nulls: true)
+      wrap_expr(_rbexpr.all(drop_nulls))
     end
 
     # Compute the square root of the elements.
@@ -359,7 +366,7 @@ module Polars
     #   # │ 3   ┆ 1.5  │
     #   # └─────┴──────┘
     def exclude(columns)
-      if columns.is_a?(String)
+      if columns.is_a?(::String)
         columns = [columns]
         return wrap_expr(_rbexpr.exclude(columns))
       elsif !columns.is_a?(::Array)
@@ -367,11 +374,11 @@ module Polars
         return wrap_expr(_rbexpr.exclude_dtype(columns))
       end
 
-      if !columns.all? { |a| a.is_a?(String) } || !columns.all? { |a| Utils.is_polars_dtype(a) }
+      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)
+      if columns[0].is_a?(::String)
         wrap_expr(_rbexpr.exclude(columns))
       else
         wrap_expr(_rbexpr.exclude_dtype(columns))
@@ -401,21 +408,21 @@ module Polars
     #   # │ 18  ┆ 4   │
     #   # └─────┴─────┘
     def keep_name
-      wrap_expr(_rbexpr.keep_name)
+      name.keep
     end
 
     # Add a prefix to the root column name of the expression.
     #
     # @return [Expr]
     def prefix(prefix)
-      wrap_expr(_rbexpr.prefix(prefix))
+      name.prefix(prefix)
     end
 
     # Add a suffix to the root column name of the expression.
     #
     # @return [Expr]
     def suffix(suffix)
-      wrap_expr(_rbexpr.suffix(suffix))
+      name.suffix(suffix)
     end
 
     # Rename the output of an expression by mapping a function over the root name.
@@ -443,7 +450,7 @@ module Polars
     #   # │ 1         ┆ 3         │
     #   # └───────────┴───────────┘
     def map_alias(&f)
-      Utils.wrap_expr(_rbexpr.map_alias(f))
+      name.map(&f)
     end
 
     # Negate a boolean expression.
@@ -682,7 +689,7 @@ module Polars
     #       "value" => [94, 95, 96, 97, 97, 99]
     #     }
     #   )
-    #   df.groupby("group", maintain_order: true).agg(Polars.col("value").agg_groups)
+    #   df.group_by("group", maintain_order: true).agg(Polars.col("value").agg_groups)
     #   # =>
     #   # shape: (2, 2)
     #   # ┌───────┬───────────┐
@@ -714,13 +721,13 @@ module Polars
     #   # │ 3   ┆ 3   │
     #   # └─────┴─────┘
     def count
-      wrap_expr(_rbexpr.count)
+      warn "`Expr#count` will exclude null values in 0.9.0. Use `Expr#length` instead."
+      # wrap_expr(_rbexpr.count)
+      wrap_expr(_rbexpr.len)
     end
 
     # Count the number of values in this expression.
     #
-    # Alias for {#count}.
-    #
     # @return [Expr]
     #
     # @example
@@ -736,8 +743,9 @@ module Polars
     #   # │ 3   ┆ 3   │
     #   # └─────┴─────┘
     def len
-      count
+      wrap_expr(_rbexpr.len)
     end
+    alias_method :length, :len
 
     # Get a slice of this expression.
     #
@@ -905,8 +913,8 @@ module Polars
     #   df = Polars::DataFrame.new({"a" => [1, 2, 3, 4]})
     #   df.select(
     #     [
-    #       Polars.col("a").cumsum,
-    #       Polars.col("a").cumsum(reverse: true).alias("a_reverse")
+    #       Polars.col("a").cum_sum,
+    #       Polars.col("a").cum_sum(reverse: true).alias("a_reverse")
     #     ]
     #   )
     #   # =>
@@ -921,9 +929,10 @@ module Polars
     #   # │ 6   ┆ 7         │
     #   # │ 10  ┆ 4         │
     #   # └─────┴───────────┘
-    def cumsum(reverse: false)
-      wrap_expr(_rbexpr.cumsum(reverse))
+    def cum_sum(reverse: false)
+      wrap_expr(_rbexpr.cum_sum(reverse))
     end
+    alias_method :cumsum, :cum_sum
 
     # Get an array with the cumulative product computed at every element.
     #
@@ -940,8 +949,8 @@ module Polars
     #   df = Polars::DataFrame.new({"a" => [1, 2, 3, 4]})
     #   df.select(
     #     [
-    #       Polars.col("a").cumprod,
-    #       Polars.col("a").cumprod(reverse: true).alias("a_reverse")
+    #       Polars.col("a").cum_prod,
+    #       Polars.col("a").cum_prod(reverse: true).alias("a_reverse")
     #     ]
     #   )
     #   # =>
@@ -956,9 +965,10 @@ module Polars
     #   # │ 6   ┆ 12        │
     #   # │ 24  ┆ 4         │
     #   # └─────┴───────────┘
-    def cumprod(reverse: false)
-      wrap_expr(_rbexpr.cumprod(reverse))
+    def cum_prod(reverse: false)
+      wrap_expr(_rbexpr.cum_prod(reverse))
     end
+    alias_method :cumprod, :cum_prod
 
     # Get an array with the cumulative min computed at every element.
     #
@@ -971,8 +981,8 @@ module Polars
     #   df = Polars::DataFrame.new({"a" => [1, 2, 3, 4]})
     #   df.select(
     #     [
-    #       Polars.col("a").cummin,
-    #       Polars.col("a").cummin(reverse: true).alias("a_reverse")
+    #       Polars.col("a").cum_min,
+    #       Polars.col("a").cum_min(reverse: true).alias("a_reverse")
     #     ]
     #   )
     #   # =>
@@ -987,9 +997,10 @@ module Polars
     #   # │ 1   ┆ 3         │
     #   # │ 1   ┆ 4         │
     #   # └─────┴───────────┘
-    def cummin(reverse: false)
-      wrap_expr(_rbexpr.cummin(reverse))
+    def cum_min(reverse: false)
+      wrap_expr(_rbexpr.cum_min(reverse))
     end
+    alias_method :cummin, :cum_min
 
     # Get an array with the cumulative max computed at every element.
     #
@@ -1002,8 +1013,8 @@ module Polars
     #   df = Polars::DataFrame.new({"a" => [1, 2, 3, 4]})
     #   df.select(
     #     [
-    #       Polars.col("a").cummax,
-    #       Polars.col("a").cummax(reverse: true).alias("a_reverse")
+    #       Polars.col("a").cum_max,
+    #       Polars.col("a").cum_max(reverse: true).alias("a_reverse")
     #     ]
     #   )
     #   # =>
@@ -1018,9 +1029,10 @@ module Polars
     #   # │ 3   ┆ 4         │
     #   # │ 4   ┆ 4         │
     #   # └─────┴───────────┘
-    def cummax(reverse: false)
-      wrap_expr(_rbexpr.cummax(reverse))
+    def cum_max(reverse: false)
+      wrap_expr(_rbexpr.cum_max(reverse))
     end
+    alias_method :cummax, :cum_max
 
     # Get an array with the cumulative count computed at every element.
     #
@@ -1035,8 +1047,8 @@ module Polars
     #   df = Polars::DataFrame.new({"a" => [1, 2, 3, 4]})
     #   df.select(
     #     [
-    #       Polars.col("a").cumcount,
-    #       Polars.col("a").cumcount(reverse: true).alias("a_reverse")
+    #       Polars.col("a").cum_count,
+    #       Polars.col("a").cum_count(reverse: true).alias("a_reverse")
     #     ]
     #   )
     #   # =>
@@ -1051,9 +1063,10 @@ module Polars
     #   # │ 2   ┆ 1         │
     #   # │ 3   ┆ 0         │
     #   # └─────┴───────────┘
-    def cumcount(reverse: false)
-      wrap_expr(_rbexpr.cumcount(reverse))
+    def cum_count(reverse: false)
+      wrap_expr(_rbexpr.cum_count(reverse))
     end
+    alias_method :cumcount, :cum_count
 
     # Rounds down to the nearest integer value.
     #
@@ -1229,7 +1242,7 @@ module Polars
 
     # Sort this column. In projection/ selection context the whole column is sorted.
     #
-    # If used in a groupby context, the groups are sorted.
+    # If used in a group by context, the groups are sorted.
     #
     # @param reverse [Boolean]
     #   false -> order from small to large.
@@ -1287,7 +1300,7 @@ module Polars
     #   # └───────┘
     #
     # @example
-    #   df.groupby("group").agg(Polars.col("value").sort)
+    #   df.group_by("group").agg(Polars.col("value").sort)
     #   # =>
     #   # shape: (2, 2)
     #   # ┌───────┬────────────┐
@@ -1337,6 +1350,7 @@ module Polars
     #   # │ 2     ┆ 98       │
     #   # └───────┴──────────┘
     def top_k(k: 5)
+      k = Utils.parse_as_expression(k)
       wrap_expr(_rbexpr.top_k(k))
     end
 
@@ -1375,6 +1389,7 @@ module Polars
     #   # │ 2     ┆ 98       │
     #   # └───────┴──────────┘
     def bottom_k(k: 5)
+      k = Utils.parse_as_expression(k)
       wrap_expr(_rbexpr.bottom_k(k))
     end
 
@@ -1494,7 +1509,7 @@ module Polars
     # 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 groupby context, the groups are sorted.
+    # If used in a group by context, the groups are sorted.
     #
     # @param by [Object]
     #   The column(s) used for sorting.
@@ -1566,30 +1581,33 @@ module Polars
     #       "value" => [1, 98, 2, 3, 99, 4]
     #     }
     #   )
-    #   df.groupby("group", maintain_order: true).agg(Polars.col("value").take(1))
+    #   df.group_by("group", maintain_order: true).agg(Polars.col("value").take([2, 1]))
     #   # =>
     #   # shape: (2, 2)
-    #   # ┌───────┬───────┐
-    #   # │ group ┆ value │
-    #   # │ ---   ┆ ---   │
-    #   # │ str   ┆ i64   │
-    #   # ╞═══════╪═══════╡
-    #   # │ one   ┆ 98    │
-    #   # │ two   ┆ 99    │
-    #   # └───────┴───────┘
-    def take(indices)
+    #   # ┌───────┬───────────┐
+    #   # │ group ┆ value     │
+    #   # │ ---   ┆ ---       │
+    #   # │ str   ┆ list[i64] │
+    #   # ╞═══════╪═══════════╡
+    #   # │ one   ┆ [2, 98]   │
+    #   # │ two   ┆ [4, 99]   │
+    #   # └───────┴───────────┘
+    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
-      wrap_expr(_rbexpr.take(indices_lit._rbexpr))
+      wrap_expr(_rbexpr.gather(indices_lit._rbexpr))
     end
+    alias_method :take, :gather
 
     # Shift the values by a given period.
     #
-    # @param periods [Integer]
+    # @param n [Integer]
     #   Number of places to shift (may be negative).
+    # @param fill_value [Object]
+    #   Fill the resulting null values with this value.
     #
     # @return [Expr]
     #
@@ -1608,8 +1626,12 @@ module Polars
     #   # │ 2    │
     #   # │ 3    │
     #   # └──────┘
-    def shift(periods = 1)
-      wrap_expr(_rbexpr.shift(periods))
+    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)
+      wrap_expr(_rbexpr.shift(n, fill_value))
     end
 
     # Shift the values by a given period and fill the resulting null values.
@@ -1637,8 +1659,7 @@ module Polars
     #   # │ 3   │
     #   # └─────┘
     def shift_and_fill(periods, fill_value)
-      fill_value = Utils.expr_to_lit_or_expr(fill_value, str_to_lit: true)
-      wrap_expr(_rbexpr.shift_and_fill(periods, fill_value._rbexpr))
+      shift(periods, fill_value: fill_value)
     end
 
     # Fill null values using the specified value or strategy.
@@ -2063,7 +2084,7 @@ module Polars
     #   # │ 2   │
     #   # └─────┘
     def approx_unique
-      wrap_expr(_rbexpr.approx_unique)
+      wrap_expr(_rbexpr.approx_n_unique)
     end
 
     # Count null values.
@@ -2201,7 +2222,7 @@ module Polars
 
     # Apply window function over a subgroup.
     #
-    # This is similar to a groupby + aggregation + self join.
+    # This is similar to a group by + aggregation + self join.
     # Or similar to [window functions in Postgres](https://www.postgresql.org/docs/current/tutorial-window.html).
     #
     # @param expr [Object]
@@ -2309,9 +2330,10 @@ module Polars
     #   # │ 1   ┆ false    │
     #   # │ 5   ┆ true     │
     #   # └─────┴──────────┘
-    def is_first
-      wrap_expr(_rbexpr.is_first)
+    def is_first_distinct
+      wrap_expr(_rbexpr.is_first_distinct)
     end
+    alias_method :is_first, :is_first_distinct
 
     # Get mask of duplicated values.
     #
@@ -2335,6 +2357,54 @@ module Polars
       wrap_expr(_rbexpr.is_duplicated)
     end
 
+    # Get a boolean mask of the local maximum peaks.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1, 2, 3, 4, 5]})
+    #   df.select(Polars.col("a").peak_max)
+    #   # =>
+    #   # shape: (5, 1)
+    #   # ┌───────┐
+    #   # │ a     │
+    #   # │ ---   │
+    #   # │ bool  │
+    #   # ╞═══════╡
+    #   # │ false │
+    #   # │ false │
+    #   # │ false │
+    #   # │ false │
+    #   # │ true  │
+    #   # └───────┘
+    def peak_max
+      wrap_expr(_rbexpr.peak_max)
+    end
+
+    # Get a boolean mask of the local minimum peaks.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [4, 1, 3, 2, 5]})
+    #   df.select(Polars.col("a").peak_min)
+    #   # =>
+    #   # shape: (5, 1)
+    #   # ┌───────┐
+    #   # │ a     │
+    #   # │ ---   │
+    #   # │ bool  │
+    #   # ╞═══════╡
+    #   # │ false │
+    #   # │ true  │
+    #   # │ false │
+    #   # │ true  │
+    #   # │ false │
+    #   # └───────┘
+    def peak_min
+      wrap_expr(_rbexpr.peak_min)
+    end
+
     # Get quantile value.
     #
     # @param quantile [Float]
@@ -2354,7 +2424,7 @@ module Polars
     #   # │ --- │
     #   # │ f64 │
     #   # ╞═════╡
-    #   # │ 1.0 │
+    #   # │ 2.0 │
     #   # └─────┘
     #
     # @example
@@ -2409,6 +2479,206 @@ module Polars
       wrap_expr(_rbexpr.quantile(quantile._rbexpr, interpolation))
     end
 
+    # Bin continuous values into discrete categories.
+    #
+    # @param breaks [Array]
+    #   List of unique cut points.
+    # @param labels [Array]
+    #   Names of the categories. The number of labels must be equal to the number
+    #   of cut points plus one.
+    # @param left_closed [Boolean]
+    #   Set the intervals to be left-closed instead of right-closed.
+    # @param include_breaks [Boolean]
+    #   Include a column with the right endpoint of the bin each observation falls
+    #   in. This will change the data type of the output from a
+    #   `Categorical` to a `Struct`.
+    #
+    # @return [Expr]
+    #
+    # @example Divide a column into three categories.
+    #   df = Polars::DataFrame.new({"foo" => [-2, -1, 0, 1, 2]})
+    #   df.with_columns(
+    #     Polars.col("foo").cut([-1, 1], labels: ["a", "b", "c"]).alias("cut")
+    #   )
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌─────┬─────┐
+    #   # │ foo ┆ cut │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ cat │
+    #   # ╞═════╪═════╡
+    #   # │ -2  ┆ a   │
+    #   # │ -1  ┆ a   │
+    #   # │ 0   ┆ b   │
+    #   # │ 1   ┆ b   │
+    #   # │ 2   ┆ c   │
+    #   # └─────┴─────┘
+    #
+    # @example Add both the category and the breakpoint.
+    #   df.with_columns(
+    #     Polars.col("foo").cut([-1, 1], include_breaks: true).alias("cut")
+    #   ).unnest("cut")
+    #   # =>
+    #   # shape: (5, 3)
+    #   # ┌─────┬──────┬────────────┐
+    #   # │ foo ┆ brk  ┆ foo_bin    │
+    #   # │ --- ┆ ---  ┆ ---        │
+    #   # │ i64 ┆ f64  ┆ cat        │
+    #   # ╞═════╪══════╪════════════╡
+    #   # │ -2  ┆ -1.0 ┆ (-inf, -1] │
+    #   # │ -1  ┆ -1.0 ┆ (-inf, -1] │
+    #   # │ 0   ┆ 1.0  ┆ (-1, 1]    │
+    #   # │ 1   ┆ 1.0  ┆ (-1, 1]    │
+    #   # │ 2   ┆ inf  ┆ (1, inf]   │
+    #   # └─────┴──────┴────────────┘
+    def cut(breaks, labels: nil, left_closed: false, include_breaks: false)
+      wrap_expr(_rbexpr.cut(breaks, labels, left_closed, include_breaks))
+    end
+
+    # Bin continuous values into discrete categories based on their quantiles.
+    #
+    # @param quantiles [Array]
+    #   Either a list of quantile probabilities between 0 and 1 or a positive
+    #   integer determining the number of bins with uniform probability.
+    # @param labels [Array]
+    #   Names of the categories. The number of labels must be equal to the number
+    #   of categories.
+    # @param left_closed [Boolean]
+    #   Set the intervals to be left-closed instead of right-closed.
+    # @param allow_duplicates [Boolean]
+    #   If set to `true`, duplicates in the resulting quantiles are dropped,
+    #   rather than raising a `DuplicateError`. This can happen even with unique
+    #   probabilities, depending on the data.
+    # @param include_breaks [Boolean]
+    #   Include a column with the right endpoint of the bin each observation falls
+    #   in. This will change the data type of the output from a
+    #   `Categorical` to a `Struct`.
+    #
+    # @return [Expr]
+    #
+    # @example Divide a column into three categories according to pre-defined quantile probabilities.
+    #   df = Polars::DataFrame.new({"foo" => [-2, -1, 0, 1, 2]})
+    #   df.with_columns(
+    #     Polars.col("foo").qcut([0.25, 0.75], labels: ["a", "b", "c"]).alias("qcut")
+    #   )
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌─────┬──────┐
+    #   # │ foo ┆ qcut │
+    #   # │ --- ┆ ---  │
+    #   # │ i64 ┆ cat  │
+    #   # ╞═════╪══════╡
+    #   # │ -2  ┆ a    │
+    #   # │ -1  ┆ a    │
+    #   # │ 0   ┆ b    │
+    #   # │ 1   ┆ b    │
+    #   # │ 2   ┆ c    │
+    #   # └─────┴──────┘
+    #
+    # @example Divide a column into two categories using uniform quantile probabilities.
+    #   df.with_columns(
+    #     Polars.col("foo")
+    #       .qcut(2, labels: ["low", "high"], left_closed: true)
+    #       .alias("qcut")
+    #   )
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌─────┬──────┐
+    #   # │ foo ┆ qcut │
+    #   # │ --- ┆ ---  │
+    #   # │ i64 ┆ cat  │
+    #   # ╞═════╪══════╡
+    #   # │ -2  ┆ low  │
+    #   # │ -1  ┆ low  │
+    #   # │ 0   ┆ high │
+    #   # │ 1   ┆ high │
+    #   # │ 2   ┆ high │
+    #   # └─────┴──────┘
+    #
+    # @example Add both the category and the breakpoint.
+    #   df.with_columns(
+    #     Polars.col("foo").qcut([0.25, 0.75], include_breaks: true).alias("qcut")
+    #   ).unnest("qcut")
+    #   # =>
+    #   # shape: (5, 3)
+    #   # ┌─────┬──────┬────────────┐
+    #   # │ foo ┆ brk  ┆ foo_bin    │
+    #   # │ --- ┆ ---  ┆ ---        │
+    #   # │ i64 ┆ f64  ┆ cat        │
+    #   # ╞═════╪══════╪════════════╡
+    #   # │ -2  ┆ -1.0 ┆ (-inf, -1] │
+    #   # │ -1  ┆ -1.0 ┆ (-inf, -1] │
+    #   # │ 0   ┆ 1.0  ┆ (-1, 1]    │
+    #   # │ 1   ┆ 1.0  ┆ (-1, 1]    │
+    #   # │ 2   ┆ inf  ┆ (1, inf]   │
+    #   # └─────┴──────┴────────────┘
+    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
+
+      wrap_expr(rbexpr)
+    end
+
+    # Get the lengths of runs of identical values.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(Polars::Series.new("s", [1, 1, 2, 1, nil, 1, 3, 3]))
+    #   df.select(Polars.col("s").rle).unnest("s")
+    #   # =>
+    #   # shape: (6, 2)
+    #   # ┌─────────┬────────┐
+    #   # │ lengths ┆ values │
+    #   # │ ---     ┆ ---    │
+    #   # │ i32     ┆ i64    │
+    #   # ╞═════════╪════════╡
+    #   # │ 2       ┆ 1      │
+    #   # │ 1       ┆ 2      │
+    #   # │ 1       ┆ 1      │
+    #   # │ 1       ┆ null   │
+    #   # │ 1       ┆ 1      │
+    #   # │ 2       ┆ 3      │
+    #   # └─────────┴────────┘
+    def rle
+      wrap_expr(_rbexpr.rle)
+    end
+
+    # 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.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1, 2, 1, 1, 1], "b" => ["x", "x", nil, "y", "y"]})
+    #   df.with_columns([Polars.col("a").rle_id.alias("a_r"), Polars.struct(["a", "b"]).rle_id.alias("ab_r")])
+    #   # =>
+    #   # shape: (5, 4)
+    #   # ┌─────┬──────┬─────┬──────┐
+    #   # │ a   ┆ b    ┆ a_r ┆ ab_r │
+    #   # │ --- ┆ ---  ┆ --- ┆ ---  │
+    #   # │ i64 ┆ str  ┆ u32 ┆ u32  │
+    #   # ╞═════╪══════╪═════╪══════╡
+    #   # │ 1   ┆ x    ┆ 0   ┆ 0    │
+    #   # │ 2   ┆ x    ┆ 1   ┆ 1    │
+    #   # │ 1   ┆ null ┆ 2   ┆ 2    │
+    #   # │ 1   ┆ y    ┆ 2   ┆ 3    │
+    #   # │ 1   ┆ y    ┆ 2   ┆ 3    │
+    #   # └─────┴──────┴─────┴──────┘
+    def rle_id
+      wrap_expr(_rbexpr.rle_id)
+    end
+
     # Filter a single column.
     #
     # Mostly useful in an aggregation context. If you want to filter on a DataFrame
@@ -2427,7 +2697,7 @@ module Polars
     #     }
     #   )
     #   (
-    #     df.groupby("group_col").agg(
+    #     df.group_by("group_col").agg(
     #       [
     #         Polars.col("b").filter(Polars.col("b") < 2).sum.alias("lt"),
     #         Polars.col("b").filter(Polars.col("b") >= 2).sum.alias("gte")
@@ -2465,7 +2735,7 @@ module Polars
     #     }
     #   )
     #   (
-    #     df.groupby("group_col").agg(
+    #     df.group_by("group_col").agg(
     #       [
     #         Polars.col("b").where(Polars.col("b") < 2).sum.alias("lt"),
     #         Polars.col("b").where(Polars.col("b") >= 2).sum.alias("gte")
@@ -2583,7 +2853,7 @@ module Polars
     #
     # @example In a GroupBy context the function is applied by group:
     #   df.lazy
-    #     .groupby("b", maintain_order: true)
+    #     .group_by("b", maintain_order: true)
     #     .agg(
     #       [
     #         Polars.col("a").apply { |x| x.sum }
@@ -2622,7 +2892,7 @@ module Polars
     #      "values" => [[1, 2], [2, 3], [4]]
     #    }
     #  )
-    #  df.groupby("group").agg(Polars.col("values").flatten)
+    #  df.group_by("group").agg(Polars.col("values").flatten)
     #  # =>
     #  # shape: (2, 2)
     #  # ┌───────┬───────────┐
@@ -2670,7 +2940,7 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"foo" => [1, 2, 3, 4, 5, 6, 7, 8, 9]})
-    #   df.select(Polars.col("foo").take_every(3))
+    #   df.select(Polars.col("foo").gather_every(3))
     #   # =>
     #   # shape: (3, 1)
     #   # ┌─────┐
@@ -2682,9 +2952,10 @@ module Polars
     #   # │ 4   │
     #   # │ 7   │
     #   # └─────┘
-    def take_every(n)
-      wrap_expr(_rbexpr.take_every(n))
+    def gather_every(n, offset = 0)
+      wrap_expr(_rbexpr.gather_every(n, offset))
     end
+    alias_method :take_every, :gather_every
 
     # Get the first `n` rows.
     #
@@ -3057,11 +3328,11 @@ module Polars
     #   # ┌─────┬─────┐
     #   # │ a   ┆ b   │
     #   # │ --- ┆ --- │
-    #   # │ i64 ┆ f64 │
+    #   # │ f64 ┆ f64 │
     #   # ╞═════╪═════╡
-    #   # │ 1   ┆ 1.0 │
-    #   # │ 2   ┆ NaN │
-    #   # │ 3   ┆ 3.0 │
+    #   # │ 1.0 ┆ 1.0 │
+    #   # │ 2.0 ┆ NaN │
+    #   # │ 3.0 ┆ 3.0 │
     #   # └─────┴─────┘
     def interpolate(method: "linear")
       wrap_expr(_rbexpr.interpolate(method))
@@ -3112,7 +3383,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `groupby_rolling` this method can cache the window size
+    #   window, consider using `group_by_rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -3201,7 +3472,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `groupby_rolling` this method can cache the window size
+    #   window, consider using `group_by_rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -3290,7 +3561,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `groupby_rolling` this method can cache the window size
+    #   window, consider using `group_by_rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -3379,7 +3650,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `groupby_rolling` this method can cache the window size
+    #   window, consider using `group_by_rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -3468,7 +3739,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `groupby_rolling` this method can cache the window size
+    #   window, consider using `group_by_rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -3501,14 +3772,15 @@ module Polars
       center: false,
       by: nil,
       closed: "left",
-      ddof: 1
+      ddof: 1,
+      warn_if_unsorted: true
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
       wrap_expr(
         _rbexpr.rolling_std(
-          window_size, weights, min_periods, center, by, closed, ddof
+          window_size, weights, min_periods, center, by, closed, ddof, warn_if_unsorted
         )
       )
     end
@@ -3558,7 +3830,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `groupby_rolling` this method can cache the window size
+    #   window, consider using `group_by_rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -3591,14 +3863,15 @@ module Polars
       center: false,
       by: nil,
       closed: "left",
-      ddof: 1
+      ddof: 1,
+      warn_if_unsorted: true
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
       wrap_expr(
         _rbexpr.rolling_var(
-          window_size, weights, min_periods, center, by, closed, ddof
+          window_size, weights, min_periods, center, by, closed, ddof, warn_if_unsorted
         )
       )
     end
@@ -3644,7 +3917,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `groupby_rolling` this method can cache the window size
+    #   window, consider using `group_by_rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -3676,14 +3949,15 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left"
+      closed: "left",
+      warn_if_unsorted: true
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
       wrap_expr(
         _rbexpr.rolling_median(
-          window_size, weights, min_periods, center, by, closed
+          window_size, weights, min_periods, center, by, closed, warn_if_unsorted
         )
       )
     end
@@ -3733,7 +4007,7 @@ module Polars
     #
     # @note
     #   If you want to compute multiple aggregation statistics over the same dynamic
-    #   window, consider using `groupby_rolling` this method can cache the window size
+    #   window, consider using `group_by_rolling` this method can cache the window size
     #   computation.
     #
     # @return [Expr]
@@ -3767,14 +4041,15 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left"
+      closed: "left",
+      warn_if_unsorted: true
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
       wrap_expr(
         _rbexpr.rolling_quantile(
-          quantile, interpolation, window_size, weights, min_periods, center, by, closed
+          quantile, interpolation, window_size, weights, min_periods, center, by, closed, warn_if_unsorted
         )
       )
     end
@@ -3948,7 +4223,7 @@ module Polars
     #   # ┌─────┐
     #   # │ a   │
     #   # │ --- │
-    #   # │ f32 │
+    #   # │ f64 │
     #   # ╞═════╡
     #   # │ 3.0 │
     #   # │ 4.5 │
@@ -4041,6 +4316,7 @@ module Polars
     #   # │ 12   ┆ 0.0        │
     #   # └──────┴────────────┘
     def pct_change(n: 1)
+      n = Utils.parse_as_expression(n)
       wrap_expr(_rbexpr.pct_change(n))
     end
 
@@ -4105,16 +4381,14 @@ module Polars
       wrap_expr(_rbexpr.kurtosis(fisher, bias))
     end
 
-    # Clip (limit) the values in an array to a `min` and `max` boundary.
-    #
-    # Only works for numerical types.
+    # Set values outside the given boundaries to the boundary value.
     #
-    # If you want to clip other dtypes, consider writing a "when, then, otherwise"
-    # expression. See `when` for more information.
+    # Only works for numeric and temporal columns. If you want to clip other data
+    # types, consider writing a `when-then-otherwise` expression.
     #
-    # @param min_val [Numeric]
+    # @param lower_bound [Numeric]
     #   Minimum value.
-    # @param max_val [Numeric]
+    # @param upper_bound [Numeric]
     #   Maximum value.
     #
     # @return [Expr]
@@ -4134,8 +4408,14 @@ module Polars
     #   # │ null ┆ null        │
     #   # │ 50   ┆ 10          │
     #   # └──────┴─────────────┘
-    def clip(min_val, max_val)
-      wrap_expr(_rbexpr.clip(min_val, max_val))
+    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
+      wrap_expr(_rbexpr.clip(lower_bound, upper_bound))
     end
 
     # Clip (limit) the values in an array to a `min` boundary.
@@ -4145,7 +4425,7 @@ module Polars
     # If you want to clip other dtypes, consider writing a "when, then, otherwise"
     # expression. See `when` for more information.
     #
-    # @param min_val [Numeric]
+    # @param lower_bound [Numeric]
     #   Minimum value.
     #
     # @return [Expr]
@@ -4165,8 +4445,8 @@ module Polars
     #   # │ null ┆ null        │
     #   # │ 50   ┆ 50          │
     #   # └──────┴─────────────┘
-    def clip_min(min_val)
-      wrap_expr(_rbexpr.clip_min(min_val))
+    def clip_min(lower_bound)
+      clip(lower_bound, nil)
     end
 
     # Clip (limit) the values in an array to a `max` boundary.
@@ -4176,7 +4456,7 @@ module Polars
     # If you want to clip other dtypes, consider writing a "when, then, otherwise"
     # expression. See `when` for more information.
     #
-    # @param max_val [Numeric]
+    # @param upper_bound [Numeric]
     #   Maximum value.
     #
     # @return [Expr]
@@ -4196,8 +4476,8 @@ module Polars
     #   # │ null ┆ null        │
     #   # │ 50   ┆ 0           │
     #   # └──────┴─────────────┘
-    def clip_max(max_val)
-      wrap_expr(_rbexpr.clip_max(max_val))
+    def clip_max(upper_bound)
+      clip(nil, upper_bound)
     end
 
     # Calculate the lower bound.
@@ -4558,11 +4838,11 @@ module Polars
     #   # │ 1   │
     #   # │ 3   │
     #   # └─────┘
-    def shuffle(seed: nil, fixed_seed: false)
+    def shuffle(seed: nil)
       if seed.nil?
         seed = rand(10000)
       end
-      wrap_expr(_rbexpr.shuffle(seed, fixed_seed))
+      wrap_expr(_rbexpr.shuffle(seed))
     end
 
     # Sample from this expression.
@@ -4600,22 +4880,23 @@ module Polars
       with_replacement: true,
       shuffle: false,
       seed: nil,
-      n: nil,
-      fixed_seed: false
+      n: nil
     )
       if !n.nil? && !frac.nil?
         raise ArgumentError, "cannot specify both `n` and `frac`"
       end
 
       if !n.nil? && frac.nil?
-        return wrap_expr(_rbexpr.sample_n(n, with_replacement, shuffle, seed, fixed_seed))
+        n = Utils.parse_as_expression(n)
+        return wrap_expr(_rbexpr.sample_n(n, with_replacement, shuffle, seed))
       end
 
       if frac.nil?
         frac = 1.0
       end
+      frac = Utils.parse_as_expression(frac)
       wrap_expr(
-        _rbexpr.sample_frac(frac, with_replacement, shuffle, seed, fixed_seed)
+        _rbexpr.sample_frac(frac, with_replacement, shuffle, seed)
       )
     end
 
@@ -4885,7 +5166,7 @@ module Polars
     #   Number of valid values there should be in the window before the expression
     #   is evaluated. valid values = `length - null_count`
     # @param parallel [Boolean]
-    #   Run in parallel. Don't do this in a groupby or another operation that
+    #   Run in parallel. Don't do this in a group by or another operation that
     #   already has much parallelization.
     #
     # @return [Expr]
@@ -5057,6 +5338,13 @@ module Polars
       MetaExpr.new(self)
     end
 
+    # Create an object namespace of all expressions that modify expression names.
+    #
+    # @return [NameExpr]
+    def name
+      NameExpr.new(self)
+    end
+
     # Create an object namespace of all string related methods.
     #
     # @return [StringExpr]