polars-df 0.14.0-x64-mingw-ucrt → 0.16.0-x64-mingw-ucrt

data/lib/polars/data_type_group.rb

@@ -0,0 +1,28 @@
+module Polars
+  class DataTypeGroup < Set
+  end
+
+  SIGNED_INTEGER_DTYPES = DataTypeGroup.new(
+    [
+      Int8,
+      Int16,
+      Int32,
+      Int64
+    ]
+  )
+  UNSIGNED_INTEGER_DTYPES = DataTypeGroup.new(
+    [
+      UInt8,
+      UInt16,
+      UInt32,
+      UInt64
+    ]
+  )
+  INTEGER_DTYPES = (
+    SIGNED_INTEGER_DTYPES | UNSIGNED_INTEGER_DTYPES
+  )
+  FLOAT_DTYPES = DataTypeGroup.new([Float32, Float64])
+  NUMERIC_DTYPES = DataTypeGroup.new(
+    FLOAT_DTYPES + INTEGER_DTYPES | [Decimal]
+  )
+end

data/lib/polars/data_types.rb

@@ -292,6 +292,8 @@ module Polars
 
   # A categorical encoding of a set of strings.
   class Categorical < DataType
+    attr_reader :ordering
+
     def initialize(ordering = "physical")
       @ordering = ordering
     end
@@ -309,7 +311,7 @@ module Polars
       end
 
       if categories.empty?
-        self.categories = Series.new("category", [], dtype: String)
+        @categories = Series.new("category", [], dtype: String)
         return
       end
 

data/lib/polars/date_time_expr.rb

@@ -269,6 +269,50 @@ module Polars
     # See [chrono strftime/strptime](https://docs.rs/chrono/latest/chrono/format/strftime/index.html).
     #
     # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "datetime" => [
+    #         Time.utc(2020, 3, 1),
+    #         Time.utc(2020, 4, 1),
+    #         Time.utc(2020, 5, 1)
+    #       ]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     Polars.col("datetime")
+    #     .dt.strftime("%Y/%m/%d %H:%M:%S")
+    #     .alias("datetime_string")
+    #   )
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────────────────────┬─────────────────────┐
+    #   # │ datetime            ┆ datetime_string     │
+    #   # │ ---                 ┆ ---                 │
+    #   # │ datetime[ns]        ┆ str                 │
+    #   # ╞═════════════════════╪═════════════════════╡
+    #   # │ 2020-03-01 00:00:00 ┆ 2020/03/01 00:00:00 │
+    #   # │ 2020-04-01 00:00:00 ┆ 2020/04/01 00:00:00 │
+    #   # │ 2020-05-01 00:00:00 ┆ 2020/05/01 00:00:00 │
+    #   # └─────────────────────┴─────────────────────┘
+    #
+    # @example If you're interested in the day name / month name, you can use `'%A'` / `'%B'`:
+    #   df.with_columns(
+    #     day_name: Polars.col("datetime").dt.strftime("%A"),
+    #     month_name: Polars.col("datetime").dt.strftime("%B")
+    #   )
+    #   # =>
+    #   # shape: (3, 3)
+    #   # ┌─────────────────────┬───────────┬────────────┐
+    #   # │ datetime            ┆ day_name  ┆ month_name │
+    #   # │ ---                 ┆ ---       ┆ ---        │
+    #   # │ datetime[ns]        ┆ str       ┆ str        │
+    #   # ╞═════════════════════╪═══════════╪════════════╡
+    #   # │ 2020-03-01 00:00:00 ┆ Sunday    ┆ March      │
+    #   # │ 2020-04-01 00:00:00 ┆ Wednesday ┆ April      │
+    #   # │ 2020-05-01 00:00:00 ┆ Friday    ┆ May        │
+    #   # └─────────────────────┴───────────┴────────────┘
     def strftime(fmt)
       Utils.wrap_expr(_rbexpr.strftime(fmt))
     end
@@ -574,6 +618,29 @@ module Polars
     # Date
     #
     # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "datetime" => [
+    #         Time.utc(1978, 1, 1, 1, 1, 1, 0),
+    #         Time.utc(2024, 10, 13, 5, 30, 14, 500_000),
+    #         Time.utc(2065, 1, 1, 10, 20, 30, 60_000)
+    #       ]
+    #     }
+    #   )
+    #   df.with_columns(Polars.col("datetime").dt.date.alias("date"))
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────────────────────────┬────────────┐
+    #   # │ datetime                ┆ date       │
+    #   # │ ---                     ┆ ---        │
+    #   # │ datetime[ns]            ┆ date       │
+    #   # ╞═════════════════════════╪════════════╡
+    #   # │ 1978-01-01 01:01:01     ┆ 1978-01-01 │
+    #   # │ 2024-10-13 05:30:14.500 ┆ 2024-10-13 │
+    #   # │ 2065-01-01 10:20:30.060 ┆ 2065-01-01 │
+    #   # └─────────────────────────┴────────────┘
     def date
       Utils.wrap_expr(_rbexpr.dt_date)
     end
@@ -732,6 +799,34 @@ module Polars
     # Applies to Datetime columns.
     #
     # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "datetime": [
+    #         Time.utc(1978, 1, 1, 1, 1, 1, 0),
+    #         Time.utc(2024, 10, 13, 5, 30, 14, 500_000),
+    #         Time.utc(2065, 1, 1, 10, 20, 30, 60_000),
+    #       ]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     Polars.col("datetime").dt.hour.alias("hour"),
+    #     Polars.col("datetime").dt.minute.alias("minute"),
+    #     Polars.col("datetime").dt.second.alias("second"),
+    #     Polars.col("datetime").dt.millisecond.alias("millisecond")
+    #   )
+    #   # =>
+    #   # shape: (3, 5)
+    #   # ┌─────────────────────────┬──────┬────────┬────────┬─────────────┐
+    #   # │ datetime                ┆ hour ┆ minute ┆ second ┆ millisecond │
+    #   # │ ---                     ┆ ---  ┆ ---    ┆ ---    ┆ ---         │
+    #   # │ datetime[ns]            ┆ i8   ┆ i8     ┆ i8     ┆ i32         │
+    #   # ╞═════════════════════════╪══════╪════════╪════════╪═════════════╡
+    #   # │ 1978-01-01 01:01:01     ┆ 1    ┆ 1      ┆ 1      ┆ 0           │
+    #   # │ 2024-10-13 05:30:14.500 ┆ 5    ┆ 30     ┆ 14     ┆ 500         │
+    #   # │ 2065-01-01 10:20:30.060 ┆ 10   ┆ 20     ┆ 30     ┆ 60          │
+    #   # └─────────────────────────┴──────┴────────┴────────┴─────────────┘
     def millisecond
       Utils.wrap_expr(_rbexpr.dt_millisecond)
     end
@@ -741,6 +836,34 @@ module Polars
     # Applies to Datetime columns.
     #
     # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "datetime": [
+    #         Time.utc(1978, 1, 1, 1, 1, 1, 0),
+    #         Time.utc(2024, 10, 13, 5, 30, 14, 500_000),
+    #         Time.utc(2065, 1, 1, 10, 20, 30, 60_000),
+    #       ]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     Polars.col("datetime").dt.hour.alias("hour"),
+    #     Polars.col("datetime").dt.minute.alias("minute"),
+    #     Polars.col("datetime").dt.second.alias("second"),
+    #     Polars.col("datetime").dt.microsecond.alias("microsecond")
+    #   )
+    #   # =>
+    #   # shape: (3, 5)
+    #   # ┌─────────────────────────┬──────┬────────┬────────┬─────────────┐
+    #   # │ datetime                ┆ hour ┆ minute ┆ second ┆ microsecond │
+    #   # │ ---                     ┆ ---  ┆ ---    ┆ ---    ┆ ---         │
+    #   # │ datetime[ns]            ┆ i8   ┆ i8     ┆ i8     ┆ i32         │
+    #   # ╞═════════════════════════╪══════╪════════╪════════╪═════════════╡
+    #   # │ 1978-01-01 01:01:01     ┆ 1    ┆ 1      ┆ 1      ┆ 0           │
+    #   # │ 2024-10-13 05:30:14.500 ┆ 5    ┆ 30     ┆ 14     ┆ 500000      │
+    #   # │ 2065-01-01 10:20:30.060 ┆ 10   ┆ 20     ┆ 30     ┆ 60000       │
+    #   # └─────────────────────────┴──────┴────────┴────────┴─────────────┘
     def microsecond
       Utils.wrap_expr(_rbexpr.dt_microsecond)
     end
@@ -750,6 +873,34 @@ module Polars
     # Applies to Datetime columns.
     #
     # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "datetime": [
+    #         Time.utc(1978, 1, 1, 1, 1, 1, 0),
+    #         Time.utc(2024, 10, 13, 5, 30, 14, 500_000),
+    #         Time.utc(2065, 1, 1, 10, 20, 30, 60_000),
+    #       ]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     Polars.col("datetime").dt.hour.alias("hour"),
+    #     Polars.col("datetime").dt.minute.alias("minute"),
+    #     Polars.col("datetime").dt.second.alias("second"),
+    #     Polars.col("datetime").dt.nanosecond.alias("nanosecond")
+    #   )
+    #   # =>
+    #   # shape: (3, 5)
+    #   # ┌─────────────────────────┬──────┬────────┬────────┬────────────┐
+    #   # │ datetime                ┆ hour ┆ minute ┆ second ┆ nanosecond │
+    #   # │ ---                     ┆ ---  ┆ ---    ┆ ---    ┆ ---        │
+    #   # │ datetime[ns]            ┆ i8   ┆ i8     ┆ i8     ┆ i32        │
+    #   # ╞═════════════════════════╪══════╪════════╪════════╪════════════╡
+    #   # │ 1978-01-01 01:01:01     ┆ 1    ┆ 1      ┆ 1      ┆ 0          │
+    #   # │ 2024-10-13 05:30:14.500 ┆ 5    ┆ 30     ┆ 14     ┆ 500000000  │
+    #   # │ 2065-01-01 10:20:30.060 ┆ 10   ┆ 20     ┆ 30     ┆ 60000000   │
+    #   # └─────────────────────────┴──────┴────────┴────────┴────────────┘
     def nanosecond
       Utils.wrap_expr(_rbexpr.dt_nanosecond)
     end
@@ -835,6 +986,34 @@ module Polars
     #   Time unit for the `Datetime` Series.
     #
     # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "date" => Polars.datetime_range(
+    #         Time.utc(2001, 1, 1),
+    #         Time.utc(2001, 1, 3),
+    #         "1d",
+    #         time_unit: "ns",
+    #         eager: true
+    #       )
+    #     }
+    #   )
+    #   df.select(
+    #     Polars.col("date"),
+    #     Polars.col("date").dt.with_time_unit("us").alias("time_unit_us")
+    #   )
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────────────────────┬───────────────────────┐
+    #   # │ date                ┆ time_unit_us          │
+    #   # │ ---                 ┆ ---                   │
+    #   # │ datetime[ns]        ┆ datetime[μs]          │
+    #   # ╞═════════════════════╪═══════════════════════╡
+    #   # │ 2001-01-01 00:00:00 ┆ +32971-04-28 00:00:00 │
+    #   # │ 2001-01-02 00:00:00 ┆ +32974-01-22 00:00:00 │
+    #   # │ 2001-01-03 00:00:00 ┆ +32976-10-18 00:00:00 │
+    #   # └─────────────────────┴───────────────────────┘
     def with_time_unit(time_unit)
       Utils.wrap_expr(_rbexpr.dt_with_time_unit(time_unit))
     end
@@ -931,6 +1110,71 @@ module Polars
     #     Determine how to deal with non-existent datetimes.
     #
     # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "london_timezone": Polars.datetime_range(
+    #         Time.utc(2020, 3, 1),
+    #         Time.utc(2020, 7, 1),
+    #         "1mo",
+    #         time_zone: "UTC",
+    #         eager: true,
+    #       ).dt.convert_time_zone("Europe/London")
+    #     }
+    #   )
+    #   df.select(
+    #     [
+    #       Polars.col("london_timezone"),
+    #       Polars.col("london_timezone")
+    #       .dt.replace_time_zone("Europe/Amsterdam")
+    #       .alias("London_to_Amsterdam")
+    #     ]
+    #   )
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌─────────────────────────────┬────────────────────────────────┐
+    #   # │ london_timezone             ┆ London_to_Amsterdam            │
+    #   # │ ---                         ┆ ---                            │
+    #   # │ datetime[ns, Europe/London] ┆ datetime[ns, Europe/Amsterdam] │
+    #   # ╞═════════════════════════════╪════════════════════════════════╡
+    #   # │ 2020-03-01 00:00:00 GMT     ┆ 2020-03-01 00:00:00 CET        │
+    #   # │ 2020-04-01 01:00:00 BST     ┆ 2020-04-01 01:00:00 CEST       │
+    #   # │ 2020-05-01 01:00:00 BST     ┆ 2020-05-01 01:00:00 CEST       │
+    #   # │ 2020-06-01 01:00:00 BST     ┆ 2020-06-01 01:00:00 CEST       │
+    #   # │ 2020-07-01 01:00:00 BST     ┆ 2020-07-01 01:00:00 CEST       │
+    #   # └─────────────────────────────┴────────────────────────────────┘
+    #
+    # @example You can use `ambiguous` to deal with ambiguous datetimes:
+    #   dates = [
+    #     "2018-10-28 01:30",
+    #     "2018-10-28 02:00",
+    #     "2018-10-28 02:30",
+    #     "2018-10-28 02:00"
+    #   ]
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "ts" => Polars::Series.new(dates).str.strptime(Polars::Datetime),
+    #       "ambiguous" => ["earliest", "earliest", "latest", "latest"]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     ts_localized: Polars.col("ts").dt.replace_time_zone(
+    #       "Europe/Brussels", ambiguous: Polars.col("ambiguous")
+    #     )
+    #   )
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌─────────────────────┬───────────┬───────────────────────────────┐
+    #   # │ ts                  ┆ ambiguous ┆ ts_localized                  │
+    #   # │ ---                 ┆ ---       ┆ ---                           │
+    #   # │ datetime[μs]        ┆ str       ┆ datetime[μs, Europe/Brussels] │
+    #   # ╞═════════════════════╪═══════════╪═══════════════════════════════╡
+    #   # │ 2018-10-28 01:30:00 ┆ earliest  ┆ 2018-10-28 01:30:00 CEST      │
+    #   # │ 2018-10-28 02:00:00 ┆ earliest  ┆ 2018-10-28 02:00:00 CEST      │
+    #   # │ 2018-10-28 02:30:00 ┆ latest    ┆ 2018-10-28 02:30:00 CET       │
+    #   # │ 2018-10-28 02:00:00 ┆ latest    ┆ 2018-10-28 02:00:00 CET       │
+    #   # └─────────────────────┴───────────┴───────────────────────────────┘
     def replace_time_zone(time_zone, ambiguous: "raise", non_existent: "raise")
       unless ambiguous.is_a?(Expr)
         ambiguous = Polars.lit(ambiguous)

data/lib/polars/date_time_name_space.rb

@@ -1150,6 +1150,47 @@ module Polars
     #   Every interval start and period length.
     #
     # @return [Series]
+    #
+    # @example
+    #   s = Polars.datetime_range(
+    #     Time.utc(2001, 1, 1),
+    #     Time.utc(2001, 1, 2),
+    #     "165m",
+    #     eager: true
+    #   ).alias("datetime")
+    #   s.dt.truncate("1h")
+    #   # =>
+    #   # shape: (9,)
+    #   # Series: 'datetime' [datetime[ns]]
+    #   # [
+    #   #         2001-01-01 00:00:00
+    #   #         2001-01-01 02:00:00
+    #   #         2001-01-01 05:00:00
+    #   #         2001-01-01 08:00:00
+    #   #         2001-01-01 11:00:00
+    #   #         2001-01-01 13:00:00
+    #   #         2001-01-01 16:00:00
+    #   #         2001-01-01 19:00:00
+    #   #         2001-01-01 22:00:00
+    #   # ]
+    #
+    # @example
+    #   s = Polars.datetime_range(
+    #     Time.utc(2001, 1, 1), Time.utc(2001, 1, 1, 1), "10m", eager: true
+    #   ).alias("datetime")
+    #   s.dt.truncate("30m")
+    #   # =>
+    #   # shape: (7,)
+    #   # Series: 'datetime' [datetime[ns]]
+    #   # [
+    #   #         2001-01-01 00:00:00
+    #   #         2001-01-01 00:00:00
+    #   #         2001-01-01 00:00:00
+    #   #         2001-01-01 00:30:00
+    #   #         2001-01-01 00:30:00
+    #   #         2001-01-01 00:30:00
+    #   #         2001-01-01 01:00:00
+    #   # ]
     def truncate(every)
       super
     end
@@ -1185,6 +1226,52 @@ module Polars
     # @note
     #   This functionality is currently experimental and may
     #   change without it being considered a breaking change.
+    #
+    # @example
+    #   start = Time.utc(2001, 1, 1)
+    #   stop = Time.utc(2001, 1, 2)
+    #   s = Polars.datetime_range(
+    #     start, stop, "165m", eager: true
+    #   ).alias("datetime")
+    #   s.dt.round("1h")
+    #   # =>
+    #   # shape: (9,)
+    #   # Series: 'datetime' [datetime[ns]]
+    #   # [
+    #   #         2001-01-01 00:00:00
+    #   #         2001-01-01 03:00:00
+    #   #         2001-01-01 06:00:00
+    #   #         2001-01-01 08:00:00
+    #   #         2001-01-01 11:00:00
+    #   #         2001-01-01 14:00:00
+    #   #         2001-01-01 17:00:00
+    #   #         2001-01-01 19:00:00
+    #   #         2001-01-01 22:00:00
+    #   # ]
+    #
+    # @example
+    #   round_str = s.dt.round("1h")
+    #   round_td = s.dt.round("1h")
+    #   round_str.equals(round_td)
+    #   # => true
+    #
+    # @example
+    #   start = Time.utc(2001, 1, 1)
+    #   stop = Time.utc(2001, 1, 1, 1)
+    #   s = Polars.datetime_range(start, stop, "10m", eager: true).alias("datetime")
+    #   s.dt.round("30m")
+    #   # =>
+    #   # shape: (7,)
+    #   # Series: 'datetime' [datetime[ns]]
+    #   # [
+    #   #         2001-01-01 00:00:00
+    #   #         2001-01-01 00:00:00
+    #   #         2001-01-01 00:30:00
+    #   #         2001-01-01 00:30:00
+    #   #         2001-01-01 00:30:00
+    #   #         2001-01-01 01:00:00
+    #   #         2001-01-01 01:00:00
+    #   # ]
     def round(every)
       super
     end

data/lib/polars/expr.rb

@@ -411,6 +411,26 @@ module Polars
     # Add a prefix to the root column name of the expression.
     #
     # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 2, 3],
+    #       "b" => ["x", "y", "z"]
+    #     }
+    #   )
+    #   df.with_columns(Polars.all.reverse.name.prefix("reverse_"))
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌─────┬─────┬───────────┬───────────┐
+    #   # │ a   ┆ b   ┆ reverse_a ┆ reverse_b │
+    #   # │ --- ┆ --- ┆ ---       ┆ ---       │
+    #   # │ i64 ┆ str ┆ i64       ┆ str       │
+    #   # ╞═════╪═════╪═══════════╪═══════════╡
+    #   # │ 1   ┆ x   ┆ 3         ┆ z         │
+    #   # │ 2   ┆ y   ┆ 2         ┆ y         │
+    #   # │ 3   ┆ z   ┆ 1         ┆ x         │
+    #   # └─────┴─────┴───────────┴───────────┘
     def prefix(prefix)
       name.prefix(prefix)
     end
@@ -418,6 +438,26 @@ module Polars
     # Add a suffix to the root column name of the expression.
     #
     # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 2, 3],
+    #       "b" => ["x", "y", "z"]
+    #     }
+    #   )
+    #   df.with_columns(Polars.all.reverse.name.suffix("_reverse"))
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌─────┬─────┬───────────┬───────────┐
+    #   # │ a   ┆ b   ┆ a_reverse ┆ b_reverse │
+    #   # │ --- ┆ --- ┆ ---       ┆ ---       │
+    #   # │ i64 ┆ str ┆ i64       ┆ str       │
+    #   # ╞═════╪═════╪═══════════╪═══════════╡
+    #   # │ 1   ┆ x   ┆ 3         ┆ z         │
+    #   # │ 2   ┆ y   ┆ 2         ┆ y         │
+    #   # │ 3   ┆ z   ┆ 1         ┆ x         │
+    #   # └─────┴─────┴───────────┴───────────┘
     def suffix(suffix)
       name.suffix(suffix)
     end
@@ -1863,6 +1903,35 @@ module Polars
     # Reverse the selection.
     #
     # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "A" => [1, 2, 3, 4, 5],
+    #       "fruits" => ["banana", "banana", "apple", "apple", "banana"],
+    #       "B" => [5, 4, 3, 2, 1],
+    #       "cars" => ["beetle", "audi", "beetle", "beetle", "beetle"]
+    #     }
+    #   )
+    #   df.select(
+    #     [
+    #       Polars.all,
+    #       Polars.all.reverse.name.suffix("_reverse")
+    #     ]
+    #   )
+    #   # =>
+    #   # shape: (5, 8)
+    #   # ┌─────┬────────┬─────┬────────┬───────────┬────────────────┬───────────┬──────────────┐
+    #   # │ A   ┆ fruits ┆ B   ┆ cars   ┆ A_reverse ┆ fruits_reverse ┆ B_reverse ┆ cars_reverse │
+    #   # │ --- ┆ ---    ┆ --- ┆ ---    ┆ ---       ┆ ---            ┆ ---       ┆ ---          │
+    #   # │ i64 ┆ str    ┆ i64 ┆ str    ┆ i64       ┆ str            ┆ i64       ┆ str          │
+    #   # ╞═════╪════════╪═════╪════════╪═══════════╪════════════════╪═══════════╪══════════════╡
+    #   # │ 1   ┆ banana ┆ 5   ┆ beetle ┆ 5         ┆ banana         ┆ 1         ┆ beetle       │
+    #   # │ 2   ┆ banana ┆ 4   ┆ audi   ┆ 4         ┆ apple          ┆ 2         ┆ beetle       │
+    #   # │ 3   ┆ apple  ┆ 3   ┆ beetle ┆ 3         ┆ apple          ┆ 3         ┆ beetle       │
+    #   # │ 4   ┆ apple  ┆ 2   ┆ beetle ┆ 2         ┆ banana         ┆ 4         ┆ audi         │
+    #   # │ 5   ┆ banana ┆ 1   ┆ beetle ┆ 1         ┆ banana         ┆ 5         ┆ beetle       │
+    #   # └─────┴────────┴─────┴────────┴───────────┴────────────────┴───────────┴──────────────┘
     def reverse
       _from_rbexpr(_rbexpr.reverse)
     end
@@ -2825,7 +2894,7 @@ module Polars
     #   # ╞══════╪════════╡
     #   # │ 1    ┆ 0      │
     #   # └──────┴────────┘
-    # def map_batches(return_dtype: nil, agg_list: false, is_elementwise: false, &f)
+    # def map_batches(return_dtype: nil, agg_list: false, is_elementwise: false, returns_scalar: false, &f)
     #   if !return_dtype.nil?
     #     return_dtype = Utils.rb_type_to_dtype(return_dtype)
     #   end
@@ -2835,7 +2904,8 @@ module Polars
     #       f,
     #       return_dtype,
     #       agg_list,
-    #       is_elementwise
+    #       is_elementwise,
+    #       returns_scalar
     #     )
     #   )
     # end
@@ -3071,6 +3141,21 @@ module Polars
     #   Number of rows to return.
     #
     # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"foo" => [1, 2, 3, 4, 5, 6, 7]})
+    #   df.select(Polars.col("foo").limit(3))
+    #   # =>
+    #   # shape: (3, 1)
+    #   # ┌─────┐
+    #   # │ foo │
+    #   # │ --- │
+    #   # │ i64 │
+    #   # ╞═════╡
+    #   # │ 1   │
+    #   # │ 2   │
+    #   # │ 3   │
+    #   # └─────┘
     def limit(n = 10)
       head(n)
     end
@@ -5601,6 +5686,22 @@ module Polars
     #   If false, the calculations are corrected for statistical bias.
     #
     # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1, 4, 2, 9]})
+    #   df.select(Polars.col("a").rolling_skew(3))
+    #   # =>
+    #   # shape: (4, 1)
+    #   # ┌──────────┐
+    #   # │ a        │
+    #   # │ ---      │
+    #   # │ f64      │
+    #   # ╞══════════╡
+    #   # │ null     │
+    #   # │ null     │
+    #   # │ 0.381802 │
+    #   # │ 0.47033  │
+    #   # └──────────┘
     def rolling_skew(window_size, bias: true)
       _from_rbexpr(_rbexpr.rolling_skew(window_size, bias))
     end

data/lib/polars/functions/aggregation/horizontal.rb

@@ -143,6 +143,9 @@ module Polars
     # @param exprs [Array]
     #   Column(s) to use in the aggregation. Accepts expression input. Strings are
     #   parsed as column names, other non-expression inputs are parsed as literals.
+    # @param ignore_nulls [Boolean]
+    #   Ignore null values (default).
+    #   If set to `false`, any null value in the input will lead to a null output.
     #
     # @return [Expr]
     #
@@ -166,9 +169,9 @@ module Polars
     #   # │ 8   ┆ 5    ┆ y   ┆ 13  │
     #   # │ 3   ┆ null ┆ z   ┆ 3   │
     #   # └─────┴──────┴─────┴─────┘
-    def sum_horizontal(*exprs)
+    def sum_horizontal(*exprs, ignore_nulls: true)
       rbexprs = Utils.parse_into_list_of_expressions(*exprs)
-      Utils.wrap_expr(Plr.sum_horizontal(rbexprs))
+      Utils.wrap_expr(Plr.sum_horizontal(rbexprs, ignore_nulls))
     end
 
     # Compute the mean of all values horizontally across columns.
@@ -176,6 +179,9 @@ module Polars
     # @param exprs [Array]
     #   Column(s) to use in the aggregation. Accepts expression input. Strings are
     #   parsed as column names, other non-expression inputs are parsed as literals.
+    # @param ignore_nulls [Boolean]
+    #   Ignore null values (default).
+    #   If set to `false`, any null value in the input will lead to a null output.
     #
     # @return [Expr]
     #
@@ -199,9 +205,9 @@ module Polars
     #   # │ 8   ┆ 5    ┆ y   ┆ 6.5  │
     #   # │ 3   ┆ null ┆ z   ┆ 3.0  │
     #   # └─────┴──────┴─────┴──────┘
-    def mean_horizontal(*exprs)
+    def mean_horizontal(*exprs, ignore_nulls: true)
       rbexprs = Utils.parse_into_list_of_expressions(*exprs)
-      Utils.wrap_expr(Plr.mean_horizontal(rbexprs))
+      Utils.wrap_expr(Plr.mean_horizontal(rbexprs, ignore_nulls))
     end
 
     # Cumulatively sum all values horizontally across columns.