polars-df 0.5.0-arm64-darwin → 0.7.0-arm64-darwin

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.
@@ -362,7 +369,7 @@ module Polars
       if columns.is_a?(String)
         columns = [columns]
         return wrap_expr(_rbexpr.exclude(columns))
-      elsif !columns.is_a?(Array)
+      elsif !columns.is_a?(::Array)
         columns = [columns]
         return wrap_expr(_rbexpr.exclude_dtype(columns))
       end
@@ -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)
     #   # ┌───────┬───────────┐
@@ -820,18 +827,18 @@ module Polars
     #   df.select(Polars.repeat(nil, 3).append(Polars.col("a")).rechunk)
     #   # =>
     #   # shape: (6, 1)
-    #   # ┌─────────┐
-    #   # │ literal │
-    #   # │ ---     │
-    #   # │ i64     │
-    #   # ╞═════════╡
-    #   # │ null    │
-    #   # │ null    │
-    #   # │ null    │
-    #   # │ 1       │
-    #   # │ 1       │
-    #   # │ 2       │
-    #   # └─────────┘
+    #   # ┌────────┐
+    #   # │ repeat │
+    #   # │ ---    │
+    #   # │ i64    │
+    #   # ╞════════╡
+    #   # │ null   │
+    #   # │ null   │
+    #   # │ null   │
+    #   # │ 1      │
+    #   # │ 1      │
+    #   # │ 2      │
+    #   # └────────┘
     def rechunk
       wrap_expr(_rbexpr.rechunk)
     end
@@ -905,8 +912,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 +928,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 +948,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 +964,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 +980,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 +996,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 +1012,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 +1028,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 +1046,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 +1062,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 +1241,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 +1299,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 +1349,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 +1388,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 +1508,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.
@@ -1534,10 +1548,10 @@ module Polars
     #   # │ two   │
     #   # └───────┘
     def sort_by(by, reverse: false)
-      if !by.is_a?(Array)
+      if !by.is_a?(::Array)
         by = [by]
       end
-      if !reverse.is_a?(Array)
+      if !reverse.is_a?(::Array)
         reverse = [reverse]
       end
       by = Utils.selection_to_rbexpr_list(by)
@@ -1566,30 +1580,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)
-      if indices.is_a?(Array)
+    #   # ┌───────┬───────────┐
+    #   # │ 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 +1625,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 +1658,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 +2083,7 @@ module Polars
     #   # │ 2   │
     #   # └─────┘
     def approx_unique
-      wrap_expr(_rbexpr.approx_unique)
+      wrap_expr(_rbexpr.approx_n_unique)
     end
 
     # Count null values.
@@ -2201,7 +2221,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 +2329,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 +2356,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]
@@ -2427,7 +2496,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")
@@ -2436,14 +2505,14 @@ module Polars
     #   ).sort("group_col")
     #   # =>
     #   # shape: (2, 3)
-    #   # ┌───────────┬──────┬─────┐
-    #   # │ group_col ┆ lt   ┆ gte │
-    #   # │ ---       ┆ ---  ┆ --- │
-    #   # │ str       ┆ i64  ┆ i64 │
-    #   # ╞═══════════╪══════╪═════╡
-    #   # │ g1        ┆ 1    ┆ 2   │
-    #   # │ g2        ┆ null ┆ 3   │
-    #   # └───────────┴──────┴─────┘
+    #   # ┌───────────┬─────┬─────┐
+    #   # │ group_col ┆ lt  ┆ gte │
+    #   # │ ---       ┆ --- ┆ --- │
+    #   # │ str       ┆ i64 ┆ i64 │
+    #   # ╞═══════════╪═════╪═════╡
+    #   # │ g1        ┆ 1   ┆ 2   │
+    #   # │ g2        ┆ 0   ┆ 3   │
+    #   # └───────────┴─────┴─────┘
     def filter(predicate)
       wrap_expr(_rbexpr.filter(predicate._rbexpr))
     end
@@ -2465,7 +2534,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")
@@ -2474,14 +2543,14 @@ module Polars
     #   ).sort("group_col")
     #   # =>
     #   # shape: (2, 3)
-    #   # ┌───────────┬──────┬─────┐
-    #   # │ group_col ┆ lt   ┆ gte │
-    #   # │ ---       ┆ ---  ┆ --- │
-    #   # │ str       ┆ i64  ┆ i64 │
-    #   # ╞═══════════╪══════╪═════╡
-    #   # │ g1        ┆ 1    ┆ 2   │
-    #   # │ g2        ┆ null ┆ 3   │
-    #   # └───────────┴──────┴─────┘
+    #   # ┌───────────┬─────┬─────┐
+    #   # │ group_col ┆ lt  ┆ gte │
+    #   # │ ---       ┆ --- ┆ --- │
+    #   # │ str       ┆ i64 ┆ i64 │
+    #   # ╞═══════════╪═════╪═════╡
+    #   # │ g1        ┆ 1   ┆ 2   │
+    #   # │ g2        ┆ 0   ┆ 3   │
+    #   # └───────────┴─────┴─────┘
     def where(predicate)
       filter(predicate)
     end
@@ -2583,7 +2652,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 }
@@ -2616,25 +2685,23 @@ module Polars
     # @return [Expr]
     #
     # @example
-    #   df = Polars::DataFrame.new({"foo" => ["hello", "world"]})
-    #   df.select(Polars.col("foo").flatten)
-    #   # =>
-    #   # shape: (10, 1)
-    #   # ┌─────┐
-    #   # │ foo │
-    #   # │ --- │
-    #   # │ str │
-    #   # ╞═════╡
-    #   # │ h   │
-    #   # │ e   │
-    #   # │ l   │
-    #   # │ l   │
-    #   # │ …   │
-    #   # │ o   │
-    #   # │ r   │
-    #   # │ l   │
-    #   # │ d   │
-    #   # └─────┘
+    #  df = Polars::DataFrame.new(
+    #    {
+    #      "group" => ["a", "b", "b"],
+    #      "values" => [[1, 2], [2, 3], [4]]
+    #    }
+    #  )
+    #  df.group_by("group").agg(Polars.col("values").flatten)
+    #  # =>
+    #  # shape: (2, 2)
+    #  # ┌───────┬───────────┐
+    #  # │ group ┆ values    │
+    #  # │ ---   ┆ ---       │
+    #  # │ str   ┆ list[i64] │
+    #  # ╞═══════╪═══════════╡
+    #  # │ a     ┆ [1, 2]    │
+    #  # │ b     ┆ [2, 3, 4] │
+    #  # └───────┴───────────┘
     def flatten
       wrap_expr(_rbexpr.explode)
     end
@@ -2672,7 +2739,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)
     #   # ┌─────┐
@@ -2684,9 +2751,10 @@ module Polars
     #   # │ 4   │
     #   # │ 7   │
     #   # └─────┘
-    def take_every(n)
-      wrap_expr(_rbexpr.take_every(n))
+    def gather_every(n)
+      wrap_expr(_rbexpr.gather_every(n))
     end
+    alias_method :take_every, :gather_every
 
     # Get the first `n` rows.
     #
@@ -2798,7 +2866,7 @@ module Polars
     #   # │ false    │
     #   # └──────────┘
     def is_in(other)
-      if other.is_a?(Array)
+      if other.is_a?(::Array)
         if other.length == 0
           other = Polars.lit(nil)
         else
@@ -3059,11 +3127,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))
@@ -3114,7 +3182,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]
@@ -3203,7 +3271,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]
@@ -3292,7 +3360,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]
@@ -3381,7 +3449,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]
@@ -3470,7 +3538,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]
@@ -3502,14 +3570,15 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left"
+      closed: "left",
+      ddof: 1
     )
       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
+          window_size, weights, min_periods, center, by, closed, ddof
         )
       )
     end
@@ -3559,7 +3628,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 +3660,15 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left"
+      closed: "left",
+      ddof: 1
     )
       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
+          window_size, weights, min_periods, center, by, closed, ddof
         )
       )
     end
@@ -3644,7 +3714,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]
@@ -3733,7 +3803,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]
@@ -3948,7 +4018,7 @@ module Polars
     #   # ┌─────┐
     #   # │ a   │
     #   # │ --- │
-    #   # │ f32 │
+    #   # │ f64 │
     #   # ╞═════╡
     #   # │ 3.0 │
     #   # │ 4.5 │
@@ -4041,6 +4111,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 +4176,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 +4203,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 +4220,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 +4240,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 +4251,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 +4271,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.
@@ -4607,12 +4682,14 @@ module Polars
       end
 
       if !n.nil? && frac.nil?
+        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)
       )
@@ -4884,7 +4961,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]
@@ -4929,8 +5006,8 @@ module Polars
     #
     # Enables downstream code to user fast paths for sorted arrays.
     #
-    # @param reverse [Boolean]
-    #   If the `Series` order is reversed, e.g. descending.
+    # @param descending [Boolean]
+    #   Whether the `Series` order is descending.
     #
     # @return [Expr]
     #
@@ -4950,9 +5027,9 @@ module Polars
     #   # ╞════════╡
     #   # │ 3      │
     #   # └────────┘
-    # def set_sorted(reverse: false)
-    #   map { |s| s.set_sorted(reverse) }
-    # end
+    def set_sorted(descending: false)
+      wrap_expr(_rbexpr.set_sorted_flag(descending))
+    end
 
     # Aggregate to list.
     #
@@ -4965,7 +5042,7 @@ module Polars
     #       "b" => [4, 5, 6]
     #     }
     #   )
-    #   df.select(Polars.all.list)
+    #   df.select(Polars.all.implode)
     #   # =>
     #   # shape: (1, 2)
     #   # ┌───────────┬───────────┐
@@ -4978,7 +5055,6 @@ module Polars
     def implode
       wrap_expr(_rbexpr.implode)
     end
-    alias_method :list, :implode
 
     # Shrink numeric columns to the minimal required datatype.
     #
@@ -5018,10 +5094,17 @@ module Polars
     # Create an object namespace of all list related methods.
     #
     # @return [ListExpr]
-    def arr
+    def list
       ListExpr.new(self)
     end
 
+    # Create an object namespace of all array related methods.
+    #
+    # @return [ArrayExpr]
+    def arr
+      ArrayExpr.new(self)
+    end
+
     # Create an object namespace of all binary related methods.
     #
     # @return [BinaryExpr]
@@ -5050,6 +5133,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]