polars-df 0.15.0 → 0.26.0

data/lib/polars/series.rb

@@ -16,9 +16,6 @@ module Polars
     #   Throw error on numeric overflow.
     # @param nan_to_null [Boolean]
     #   Not used.
-    # @param dtype_if_empty [Symbol, nil]
-    #   If no dtype is specified and values contains `nil` or an empty array,
-    #   set the Polars dtype of the Series data. If not specified, Float32 is used.
     #
     # @example Constructing a Series by specifying name and values positionally:
     #   s = Polars::Series.new("a", [1, 2, 3])
@@ -28,53 +25,56 @@ module Polars
     #   # => Polars::Int64
     #
     # @example Constructing a Series with a specific dtype:
-    #   s2 = Polars::Series.new("a", [1, 2, 3], dtype: :f32)
+    #   s2 = Polars::Series.new("a", [1, 2, 3], dtype: Polars::Float32)
     #
     # @example It is possible to construct a Series with values as the first positional argument. This syntax considered an anti-pattern, but it can be useful in certain scenarios. You must specify any other arguments through keywords.
     #   s3 = Polars::Series.new([1, 2, 3])
-    def initialize(name = nil, values = nil, dtype: nil, strict: true, nan_to_null: false, dtype_if_empty: nil)
+    def initialize(name = nil, values = nil, dtype: nil, strict: true, nan_to_null: false)
+      # If 'Unknown' treat as nil to trigger type inference
+      if dtype == Unknown
+        dtype = nil
+      elsif !dtype.nil? && !Utils.is_polars_dtype(dtype)
+        dtype = Utils.parse_into_dtype(dtype)
+      end
+
       # Handle case where values are passed as the first argument
-      if !name.nil? && !name.is_a?(::String)
+      original_name = nil
+      if name.nil?
+        name = ""
+      elsif name.is_a?(::String)
+        original_name = name
+      else
         if values.nil?
           values = name
-          name = nil
+          name = ""
         else
-          raise ArgumentError, "Series name must be a string."
+          raise TypeError, "Series name must be a string"
         end
       end
 
-      name = "" if name.nil?
-
-      # TODO improve
-      if values.is_a?(Range) && values.begin.is_a?(::String)
-        values = values.to_a
-      end
-
-      if values.nil?
-        self._s = sequence_to_rbseries(name, [], dtype: dtype, dtype_if_empty: dtype_if_empty)
-      elsif values.is_a?(Series)
-        self._s = series_to_rbseries(name, values)
-      elsif values.is_a?(Range)
-        self._s =
-          Polars.arange(
-            values.first,
-            values.last + (values.exclude_end? ? 0 : 1),
-            step: 1,
-            eager: true,
-            dtype: dtype
-          )
-          .rename(name, in_place: true)
-          ._s
-      elsif values.is_a?(::Array)
-        self._s = sequence_to_rbseries(name, values, dtype: dtype, strict: strict, dtype_if_empty: dtype_if_empty)
+      if values.is_a?(::Array) || values.is_a?(Range)
+        self._s = Utils.sequence_to_rbseries(
+          name,
+          values,
+          dtype: dtype,
+          strict: strict
+        )
+      elsif values.nil?
+        self._s = Utils.sequence_to_rbseries(name, [], dtype: dtype)
       elsif defined?(Numo::NArray) && values.is_a?(Numo::NArray)
-        self._s = numo_to_rbseries(name, values, strict: strict, nan_to_null: nan_to_null)
+        self._s = Utils.numo_to_rbseries(name, values, strict: strict, nan_to_null: nan_to_null)
 
         if !dtype.nil?
-          self._s = self.cast(dtype, strict: true)._s
+          self._s = cast(dtype, strict: strict)._s
         end
+      elsif values.is_a?(Series)
+        self._s = Utils.series_to_rbseries(original_name, values, dtype: dtype, strict: strict)
+      elsif values.is_a?(DataFrame)
+        self._s = Utils.dataframe_to_rbseries(
+          original_name, values, dtype: dtype, strict: strict
+        )
       else
-        raise ArgumentError, "Series constructor called with unsupported type; got #{values.class.name}"
+        raise TypeError, "Series constructor called with unsupported type; got #{values.class.name}"
       end
     end
 
@@ -287,7 +287,7 @@ module Polars
       self != other
     end
 
-    # Method equivalent of equality operator `series != other` where `None == None`.
+    # Method equivalent of equality operator `series != other` where `nil == nil`.
     #
     # This differs from the standard `ne` where null values are propagated.
     #
@@ -358,7 +358,7 @@ module Polars
     #
     # @return [Series]
     def *(other)
-      if is_temporal
+      if dtype.temporal?
         raise ArgumentError, "first cast to integer before multiplying datelike dtypes"
       elsif other.is_a?(DataFrame)
         other * self
@@ -371,11 +371,11 @@ module Polars
     #
     # @return [Series]
     def /(other)
-      if is_temporal
+      if dtype.temporal?
         raise ArgumentError, "first cast to integer before dividing datelike dtypes"
       end
 
-      if is_float
+      if dtype.float?
         return _arithmetic(other, :div)
       end
 
@@ -386,7 +386,7 @@ module Polars
     #
     # @return [Series]
     def %(other)
-      if is_datelike
+      if dtype.temporal?
         raise ArgumentError, "first cast to integer before applying modulo on datelike dtypes"
       end
       _arithmetic(other, :rem)
@@ -396,7 +396,7 @@ module Polars
     #
     # @return [Series]
     def **(power)
-      if is_datelike
+      if dtype.temporal?
         raise ArgumentError, "first cast to integer before raising datelike dtypes to a power"
       end
       to_frame.select(Polars.col(name).pow(power)).to_series
@@ -407,7 +407,7 @@ module Polars
     # @return [Series]
     def !
       if dtype == Boolean
-        return Utils.wrap_s(_s.not)
+        return Utils.wrap_s(_s.not_)
       end
       raise NotImplementedError
     end
@@ -435,7 +435,7 @@ module Polars
     # @return [Object]
     def [](item)
       if item.is_a?(Series) && [UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64].include?(item.dtype)
-        return Utils.wrap_s(_s.take_with_series(_pos_idxs(item)._s))
+        return Utils.wrap_s(_s.gather_with_series(_pos_idxs(item)._s))
       end
 
       if item.is_a?(Series) && item.bool?
@@ -447,7 +447,7 @@ module Polars
           item = len + item
         end
 
-        return _s.get_idx(item)
+        return _s.get_index(item)
       end
 
       if item.is_a?(Range)
@@ -455,7 +455,7 @@ module Polars
       end
 
       if Utils.is_int_sequence(item)
-        return Utils.wrap_s(_s.take_with_series(_pos_idxs(Series.new("", item))._s))
+        return Utils.wrap_s(_s.gather_with_series(_pos_idxs(Series.new("", item))._s))
       end
 
       raise ArgumentError, "Cannot get item of type: #{item.class.name}"
@@ -466,7 +466,7 @@ module Polars
     # @return [Object]
     def []=(key, value)
       if value.is_a?(::Array)
-        if is_numeric || is_datelike
+        if dtype.numeric? || dtype.temporal?
           scatter(key, value)
           return
         end
@@ -484,7 +484,7 @@ module Polars
           raise Todo
         end
       elsif key.is_a?(::Array)
-        s = Utils.wrap_s(sequence_to_rbseries("", key, dtype: UInt32))
+        s = Utils.wrap_s(Utils.sequence_to_rbseries("", key, dtype: UInt32))
         self[s] = value
       elsif key.is_a?(Range)
         s = Series.new("", key, dtype: UInt32)
@@ -496,6 +496,37 @@ module Polars
       end
     end
 
+    # Return the Series as a scalar, or return the element at the given index.
+    #
+    # If no index is provided, this is equivalent to `s[0]`, with a check
+    # that the shape is (1,). With an index, this is equivalent to `s[index]`.
+    #
+    # @return [Object]
+    #
+    # @example
+    #   s1 = Polars::Series.new("a", [1])
+    #   s1.item
+    #   # => 1
+    #
+    # @example
+    #   s2 = Polars::Series.new("a", [9, 8, 7])
+    #   s2.cum_sum.item(-1)
+    #   # => 24
+    def item(index = nil)
+      if index.nil?
+        if len != 1
+          msg = (
+            "can only call '.item' if the Series is of length 1," +
+            " or an explicit index is provided (Series is of length #{len})"
+          )
+          raise ArgumentError, msg
+        end
+        return _s.get_index(0)
+      end
+
+      _s.get_index_signed(index)
+    end
+
     # Return an estimation of the total (heap) allocated size of the Series.
     #
     # Estimated size is given in the specified unit (bytes by default).
@@ -517,7 +548,7 @@ module Polars
     # @return [Numeric]
     #
     # @example
-    #   s = Polars::Series.new("values", 1..1_000_000, dtype: :u32)
+    #   s = Polars::Series.new("values", 1..1_000_000, dtype: Polars::UInt32)
     #   s.estimated_size
     #   # => 4000000
     #   s.estimated_size("mb")
@@ -543,7 +574,26 @@ module Polars
     #   #         1.732051
     #   # ]
     def sqrt
-      self**0.5
+      super
+    end
+
+    # Compute the cube root of the elements.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new([1, 2, 3])
+    #   s.cbrt
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: '' [f64]
+    #   # [
+    #   #         1.0
+    #   #         1.259921
+    #   #         1.44225
+    #   # ]
+    def cbrt
+      super
     end
 
     # Check if any boolean value in the column is `true`.
@@ -563,7 +613,7 @@ module Polars
     #   # => false
     def any?(ignore_nulls: true, &block)
       if block_given?
-        apply(skip_nulls: ignore_nulls, &block).any?
+        map_elements(return_dtype: Boolean, skip_nulls: ignore_nulls, &block).any?
       else
         _s.any(ignore_nulls)
       end
@@ -587,7 +637,7 @@ module Polars
     #   # => true
     def all?(ignore_nulls: true, &block)
       if block_given?
-        apply(skip_nulls: ignore_nulls, &block).all?
+        map_elements(return_dtype: Boolean, skip_nulls: ignore_nulls, &block).all?
       else
         _s.all(ignore_nulls)
       end
@@ -611,7 +661,7 @@ module Polars
     #   # => true
     def none?(&block)
       if block_given?
-        apply(&block).none?
+        map_elements(return_dtype: Boolean, &block).none?
       else
         to_frame.select(Polars.col(name).is_not.all).to_series[0]
       end
@@ -640,6 +690,25 @@ module Polars
       super
     end
 
+    # Compute the natural logarithm of the input array plus one, element-wise.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new([1, 2, 3])
+    #   s.log1p
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: '' [f64]
+    #   # [
+    #   #         0.693147
+    #   #         1.098612
+    #   #         1.386294
+    #   # ]
+    def log1p
+      super
+    end
+
     # Compute the base 10 logarithm of the input array, element-wise.
     #
     # @return [Series]
@@ -758,81 +827,60 @@ module Polars
     # Series with mixed datatypes will return summary statistics for the datatype of
     # the first value.
     #
+    # @param percentiles [Array]
+    #   One or more percentiles to include in the summary statistics (if the
+    #   Series has a numeric dtype). All values must be in the range `[0, 1]`.
+    # @param interpolation ['nearest', 'higher', 'lower', 'midpoint', 'linear', 'equiprobable']
+    #   Interpolation method used when calculating percentiles.
+    #
     # @return [DataFrame]
     #
     # @example
-    #   series_num = Polars::Series.new([1, 2, 3, 4, 5])
-    #   series_num.describe
+    #   s = Polars::Series.new([1, 2, 3, 4, 5])
+    #   s.describe
     #   # =>
-    #   # shape: (6, 2)
+    #   # shape: (9, 2)
     #   # ┌────────────┬──────────┐
     #   # │ statistic  ┆ value    │
     #   # │ ---        ┆ ---      │
     #   # │ str        ┆ f64      │
     #   # ╞════════════╪══════════╡
-    #   # │ min        ┆ 1.0      │
-    #   # │ max        ┆ 5.0      │
+    #   # │ count      ┆ 5.0      │
     #   # │ null_count ┆ 0.0      │
     #   # │ mean       ┆ 3.0      │
     #   # │ std        ┆ 1.581139 │
-    #   # │ count      ┆ 5.0      │
+    #   # │ min        ┆ 1.0      │
+    #   # │ 25%        ┆ 2.0      │
+    #   # │ 50%        ┆ 3.0      │
+    #   # │ 75%        ┆ 4.0      │
+    #   # │ max        ┆ 5.0      │
     #   # └────────────┴──────────┘
     #
-    # @example
-    #   series_str = Polars::Series.new(["a", "a", nil, "b", "c"])
-    #   series_str.describe
+    # @example Non-numeric data types may not have all statistics available.
+    #   s = Polars::Series.new(["aa", "aa", nil, "bb", "cc"])
+    #   s.describe
     #   # =>
-    #   # shape: (3, 2)
+    #   # shape: (4, 2)
     #   # ┌────────────┬───────┐
     #   # │ statistic  ┆ value │
     #   # │ ---        ┆ ---   │
-    #   # │ str        ┆ i64   │
+    #   # │ str        ┆ str   │
     #   # ╞════════════╪═══════╡
-    #   # │ unique     ┆ 4     │
+    #   # │ count      ┆ 4     │
     #   # │ null_count ┆ 1     │
-    #   # │ count      ┆ 5     │
+    #   # │ min        ┆ aa    │
+    #   # │ max        ┆ cc    │
     #   # └────────────┴───────┘
-    def describe
-      if len == 0
-        raise ArgumentError, "Series must contain at least one value"
-      elsif is_numeric
-        s = cast(:f64)
-        stats = {
-          "min" => s.min,
-          "max" => s.max,
-          "null_count" => s.null_count,
-          "mean" => s.mean,
-          "std" => s.std,
-          "count" => s.len
-        }
-      elsif is_boolean
-        stats = {
-          "sum" => sum,
-          "null_count" => null_count,
-          "count" => len
-        }
-      elsif is_utf8
-        stats = {
-          "unique" => unique.length,
-          "null_count" => null_count,
-          "count" => len
-        }
-      elsif is_datelike
-        # we coerce all to string, because a polars column
-        # only has a single dtype and dates: datetime and count: int don't match
-        stats = {
-          "min" => dt.min.to_s,
-          "max" => dt.max.to_s,
-          "null_count" => null_count.to_s,
-          "count" => len.to_s
-        }
-      else
-        raise TypeError, "This type is not supported"
-      end
-
-      Polars::DataFrame.new(
-        {"statistic" => stats.keys, "value" => stats.values}
+    def describe(
+      percentiles: [0.25, 0.5, 0.75],
+      interpolation: "nearest"
+    )
+      stats = to_frame.describe(
+        percentiles: percentiles,
+        interpolation: interpolation
       )
+      stats.columns = ["statistic", "value"]
+      stats.filter(F.col("value").is_not_null)
     end
 
     # Reduce this Series to the sum value.
@@ -840,8 +888,8 @@ module Polars
     # @return [Numeric]
     #
     # @note
-    #   Dtypes `:i8`, `:u8`, `:i16`, and `:u16` are cast to
-    #   `:i64` before summing to prevent overflow issues.
+    #   Dtypes in \\\\{Int8, UInt8, Int16, UInt16} are cast to
+    #   Int64 before summing to prevent overflow issues.
     #
     # @example
     #   s = Polars::Series.new("a", [1, 2, 3])
@@ -875,6 +923,44 @@ module Polars
       to_frame.select(Polars.col(name).product).to_series[0]
     end
 
+    # Raise to the power of the given exponent.
+    #
+    # If the exponent is float, the result follows the dtype of exponent.
+    # Otherwise, it follows dtype of base.
+    #
+    # @param exponent [Numeric]
+    #   The exponent. Accepts Series input.
+    #
+    # @return [Series]
+    #
+    # @example Raising integers to positive integers results in integers:
+    #   s = Polars::Series.new("foo", [1, 2, 3, 4])
+    #   s.pow(3)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'foo' [i64]
+    #   # [
+    #   #         1
+    #   #         8
+    #   #         27
+    #   #         64
+    #   # ]
+    #
+    # @example In order to raise integers to negative integers, you can cast either the base or the exponent to float:
+    #   s.pow(-3.0)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'foo' [f64]
+    #   # [
+    #   #         1.0
+    #   #         0.125
+    #   #         0.037037
+    #   #         0.015625
+    #   # ]
+    def pow(exponent)
+      to_frame.select_seq(F.col(name).pow(exponent)).to_series
+    end
+
     # Get the minimal value in this Series.
     #
     # @return [Object]
@@ -887,6 +973,29 @@ module Polars
       _s.min
     end
 
+    # Get the minimum value in this Series, ordered by an expression.
+    #
+    # If the by expression has multiple values equal to the minimum it is not
+    # defined which value will be chosen.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # @param by [Object]
+    #   Column used to determine the smallest element.
+    #   Accepts expression input. Strings are parsed as column names.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [-2.0, Float::NAN, 1.0])
+    #   s.min_by(Polars.col("a").abs)
+    #   # => 1.0
+    def min_by(by)
+      to_frame.select_seq(F.col(name).min_by(by)).item
+    end
+
     # Get the maximum value in this Series.
     #
     # @return [Object]
@@ -899,6 +1008,29 @@ module Polars
       _s.max
     end
 
+    # Get the maximum value in this Series, ordered by an expression.
+    #
+    # If the by expression has multiple values equal to the maximum it is not
+    # defined which value will be chosen.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # @param by [Object]
+    #   Column used to determine the largest element.
+    #   Accepts expression input. Strings are parsed as column names.
+    #
+    # @return [Object]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [-2.0, Float::NAN, 1.0])
+    #   s.max_by(Polars.col("a").abs)
+    #   # => -2.0
+    def max_by(by)
+      to_frame.select_seq(F.col(name).max_by(by)).item
+    end
+
     # Get maximum value, but propagate/poison encountered NaN values.
     #
     # @return [Object]
@@ -946,7 +1078,7 @@ module Polars
     #   s.std
     #   # => 1.0
     def std(ddof: 1)
-      if !is_numeric
+      if !dtype.numeric?
         nil
       else
         to_frame.select(Polars.col(name).std(ddof: ddof)).to_series[0]
@@ -966,7 +1098,7 @@ module Polars
     #   s.var
     #   # => 1.0
     def var(ddof: 1)
-      if !is_numeric
+      if !dtype.numeric?
         nil
       else
         to_frame.select(Polars.col(name).var(ddof: ddof)).to_series[0]
@@ -1004,6 +1136,13 @@ module Polars
 
     # Get dummy variables.
     #
+    # @param separator [String]
+    #   Separator/delimiter used when generating column names.
+    # @param drop_first [Boolean]
+    #   Remove the first category from the variable being encoded.
+    # @param drop_nulls [Boolean]
+    #   If there are `nil` values in the series, a `null` column is not generated.
+    #
     # @return [DataFrame]
     #
     # @example
@@ -1020,8 +1159,8 @@ module Polars
     #   # │ 0   ┆ 1   ┆ 0   │
     #   # │ 0   ┆ 0   ┆ 1   │
     #   # └─────┴─────┴─────┘
-    def to_dummies(separator: "_", drop_first: false)
-      Utils.wrap_df(_s.to_dummies(separator, drop_first))
+    def to_dummies(separator: "_", drop_first: false, drop_nulls: false)
+      Utils.wrap_df(_s.to_dummies(separator, drop_first, drop_nulls))
     end
 
     # Bin continuous values into discrete categories.
@@ -1045,7 +1184,7 @@ module Polars
     #   s.cut([-1, 1], labels: ["a", "b", "c"])
     #   # =>
     #   # shape: (5,)
-    #   # Series: 'foo' [cat]
+    #   # Series: 'foo' [enum]
     #   # [
     #   #         "a"
     #   #         "a"
@@ -1062,7 +1201,7 @@ module Polars
     #   # ┌─────┬─────────────┬────────────┐
     #   # │ foo ┆ break_point ┆ category   │
     #   # │ --- ┆ ---         ┆ ---        │
-    #   # │ i64 ┆ f64         ┆ cat        │
+    #   # │ i64 ┆ f64         ┆ enum       │
     #   # ╞═════╪═════════════╪════════════╡
     #   # │ -2  ┆ -1.0        ┆ (-inf, -1] │
     #   # │ -1  ┆ -1.0        ┆ (-inf, -1] │
@@ -1093,8 +1232,8 @@ module Polars
 
     # 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
+    # @param quantiles [Object]
+    #   Either an array 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
@@ -1230,10 +1369,76 @@ module Polars
       super
     end
 
+    # Bin values into buckets and count their occurrences.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # @param bins [Object]
+    #   Bin edges. If nil given, we determine the edges based on the data.
+    # @param bin_count [Integer]
+    #   If `bins` is not provided, `bin_count` uniform bins are created that fully
+    #   encompass the data.
+    # @param include_category [Boolean]
+    #   Include a column that shows the intervals as categories.
+    # @param include_breakpoint [Boolean]
+    #   Include a column that indicates the upper breakpoint.
+    #
+    # @return [DataFrame]
+    #
+    # @example
+    #   a = Polars::Series.new("a", [1, 3, 8, 8, 2, 1, 3])
+    #   a.hist(bin_count: 4)
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌────────────┬─────────────┬───────┐
+    #   # │ breakpoint ┆ category    ┆ count │
+    #   # │ ---        ┆ ---         ┆ ---   │
+    #   # │ f64        ┆ cat         ┆ u32   │
+    #   # ╞════════════╪═════════════╪═══════╡
+    #   # │ 2.75       ┆ [1.0, 2.75] ┆ 3     │
+    #   # │ 4.5        ┆ (2.75, 4.5] ┆ 2     │
+    #   # │ 6.25       ┆ (4.5, 6.25] ┆ 0     │
+    #   # │ 8.0        ┆ (6.25, 8.0] ┆ 2     │
+    #   # └────────────┴─────────────┴───────┘
+    def hist(
+      bins: nil,
+      bin_count: nil,
+      include_category: true,
+      include_breakpoint: true
+    )
+      out = (
+        to_frame
+        .select_seq(
+          F.col(name).hist(
+            bins: bins,
+            bin_count: bin_count,
+            include_category: include_category,
+            include_breakpoint: include_breakpoint
+          )
+        )
+        .to_series
+      )
+      if !include_breakpoint && !include_category
+        out.to_frame
+      else
+        out.struct.unnest
+      end
+    end
+
     # Count the unique values in a Series.
     #
     # @param sort [Boolean]
     #   Ensure the output is sorted from most values to least.
+    # @param parallel [Boolean]
+    #   Execute the computation in parallel.
+    # @param name [String]
+    #   Give the resulting count column a specific name; if `normalize` is
+    #   true this defaults to "proportion", otherwise defaults to "count".
+    # @param normalize [Boolean]
+    #   If true, the count is returned as the relative frequency of unique
+    #   values normalized to 1.0.
     #
     # @return [DataFrame]
     #
@@ -1310,7 +1515,7 @@ module Polars
     #   b = Polars::Series.new([0.65, 0.10, 0.25])
     #   b.entropy(normalize: true)
     #   # => 0.8568409950394724
-    def entropy(base: Math::E, normalize: false)
+    def entropy(base: Math::E, normalize: true)
       Polars.select(Polars.lit(self).entropy(base: base, normalize: normalize)).to_series[0]
     end
 
@@ -1318,12 +1523,9 @@ module Polars
     #
     # @param expr [Expr]
     #   Expression to evaluate
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   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 group by or another operation that
-    #   already has much parallelization.
     #
     # @return [Series]
     #
@@ -1348,7 +1550,7 @@ module Polars
     #   #         -15
     #   #         -24
     #   # ]
-    def cumulative_eval(expr, min_periods: 1, parallel: false)
+    def cumulative_eval(expr, min_samples: 1)
       super
     end
 
@@ -1360,8 +1562,16 @@ module Polars
     # @return [Series]
     #
     # @example
-    #   s = Polars::Series.new("x", [1, 2, 3])
-    #   s.alias("y")
+    #   s = Polars::Series.new("a", [1, 2, 3])
+    #   s.alias("b")
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'b' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   # ]
     def alias(name)
       s = dup
       s._s.rename(name)
@@ -1372,21 +1582,22 @@ module Polars
     #
     # @param name [String]
     #   New name.
-    # @param in_place [Boolean]
-    #   Modify the Series in-place.
     #
     # @return [Series]
     #
     # @example
     #   s = Polars::Series.new("a", [1, 2, 3])
     #   s.rename("b")
-    def rename(name, in_place: false)
-      if in_place
-        _s.rename(name)
-        self
-      else
-        self.alias(name)
-      end
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'b' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   # ]
+    def rename(name)
+      self.alias(name)
     end
 
     # Get the length of each individual chunk.
@@ -1398,7 +1609,7 @@ module Polars
     #   s2 = Polars::Series.new("b", [4, 5, 6])
     #
     # @example Concatenate Series with rechunk: true
-    #   Polars.concat([s, s2]).chunk_lengths
+    #   Polars.concat([s, s2], rechunk: true).chunk_lengths
     #   # => [6]
     #
     # @example Concatenate Series with rechunk: false
@@ -1417,7 +1628,7 @@ module Polars
     #   s2 = Polars::Series.new("b", [4, 5, 6])
     #
     # @example Concatenate Series with rechunk: true
-    #   Polars.concat([s, s2]).n_chunks
+    #   Polars.concat([s, s2], rechunk: true).n_chunks
     #   # => 1
     #
     # @example Concatenate Series with rechunk: false
@@ -1435,8 +1646,8 @@ module Polars
     # @return [Series]
     #
     # @note
-    #   Dtypes `:i8`, `:u8`, `:i16`, and `:u16` are cast to
-    #   `:i64` before summing to prevent overflow issues.
+    #   Dtypes in \\\\{Int8, UInt8, Int16, UInt16} are cast to
+    #   Int64 before summing to prevent overflow issues.
     #
     # @example
     #   s = Polars::Series.new("a", [1, 2, 3])
@@ -1452,7 +1663,29 @@ module Polars
     def cum_sum(reverse: false)
       super
     end
-    alias_method :cumsum, :cum_sum
+
+    # Return the cumulative count of the non-null values in the column.
+    #
+    # @param reverse [Boolean]
+    #   Reverse the operation.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(["x", "k", nil, "d"])
+    #   s.cum_count
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [u32]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         2
+    #   #         3
+    #   # ]
+    def cum_count(reverse: false)
+      super
+    end
 
     # Get an array with the cumulative min computed at every element.
     #
@@ -1475,7 +1708,6 @@ module Polars
     def cum_min(reverse: false)
       super
     end
-    alias_method :cummin, :cum_min
 
     # Get an array with the cumulative max computed at every element.
     #
@@ -1498,7 +1730,6 @@ module Polars
     def cum_max(reverse: false)
       super
     end
-    alias_method :cummax, :cum_max
 
     # Get an array with the cumulative product computed at every element.
     #
@@ -1508,8 +1739,8 @@ module Polars
     # @return [Series]
     #
     # @note
-    #   Dtypes `:i8`, `:u8`, `:i16`, and `:u16` are cast to
-    #   `:i64` before multiplying to prevent overflow issues.
+    #   Dtypes in \\\\{Int8, UInt8, Int16, UInt16} are cast to
+    #   Int64 before summing to prevent overflow issues.
     #
     # @example
     #   s = Polars::Series.new("a", [1, 2, 3])
@@ -1525,30 +1756,6 @@ module Polars
     def cum_prod(reverse: false)
       super
     end
-    alias_method :cumprod, :cum_prod
-
-    # Get the first `n` rows.
-    #
-    # Alias for {#head}.
-    #
-    # @param n [Integer]
-    #   Number of rows to return.
-    #
-    # @return [Series]
-    #
-    # @example
-    #   s = Polars::Series.new("a", [1, 2, 3])
-    #   s.limit(2)
-    #   # =>
-    #   # shape: (2,)
-    #   # Series: 'a' [i64]
-    #   # [
-    #   #         1
-    #   #         2
-    #   # ]
-    def limit(n = 10)
-      to_frame.select(F.col(name).limit(n)).to_series
-    end
 
     # Get a slice of this Series.
     #
@@ -1578,29 +1785,6 @@ module Polars
     #
     # @param other [Series]
     #   Series to append.
-    # @param append_chunks [Boolean]
-    #   If set to `true` the append operation will add the chunks from `other` to
-    #   self. This is super cheap.
-    #
-    #   If set to `false` the append operation will do the same as
-    #   {DataFrame#extend} which extends the memory backed by this Series with
-    #   the values from `other`.
-    #
-    #   Different from `append_chunks`, `extend` appends the data from `other` to
-    #   the underlying memory locations and thus may cause a reallocation (which is
-    #   expensive).
-    #
-    #   If this does not cause a reallocation, the resulting data structure will not
-    #   have any extra chunks and thus will yield faster queries.
-    #
-    #   Prefer `extend` over `append_chunks` when you want to do a query after a
-    #   single append. For instance during online operations where you add `n` rows
-    #   and rerun a query.
-    #
-    #   Prefer `append_chunks` over `extend` when you want to append many times
-    #   before doing a query. For instance, when you read in multiple files and when
-    #   to store them in a single Series. In the latter case, finish the sequence
-    #   of `append_chunks` operations with a `rechunk`.
     #
     # @return [Series]
     #
@@ -1619,20 +1803,60 @@ module Polars
     #   #         5
     #   #         6
     #   # ]
-    def append(other, append_chunks: true)
-      begin
-        if append_chunks
-          _s.append(other._s)
-        else
-          _s.extend(other._s)
-        end
-      rescue => e
-        if e.message == "Already mutably borrowed"
-          append(other.clone, append_chunks)
-        else
-          raise e
-        end
-      end
+    def append(other)
+      Utils.require_same_type(self, other)
+      _s.append(other._s)
+      self
+    end
+
+    # Extend the memory backed by this Series with the values from another.
+    #
+    # Different from `append`, which adds the chunks from `other` to the chunks of
+    # this series, `extend` appends the data from `other` to the underlying memory
+    # locations and thus may cause a reallocation (which is expensive).
+    #
+    # If this does `not` cause a reallocation, the resulting data structure will not
+    # have any extra chunks and thus will yield faster queries.
+    #
+    # Prefer `extend` over `append` when you want to do a query after a single
+    # append. For instance, during online operations where you add `n` rows
+    # and rerun a query.
+    #
+    # Prefer `append` over `extend` when you want to append many times
+    # before doing a query. For instance, when you read in multiple files and want
+    # to store them in a single `Series`. In the latter case, finish the sequence
+    # of `append` operations with a `rechunk`.
+    #
+    # @param other [Series]
+    #   Series to extend the series with.
+    #
+    # @return [Series]
+    #
+    # @note
+    #   This method modifies the series in-place. The series is returned for
+    #   convenience only.
+    #
+    # @example
+    #   a = Polars::Series.new("a", [1, 2, 3])
+    #   b = Polars::Series.new("b", [4, 5])
+    #   a.extend(b)
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   #         4
+    #   #         5
+    #   # ]
+    #
+    # @example The resulting series will consist of a single chunk.
+    #   a.n_chunks
+    #   # => 1
+    def extend(other)
+      Utils.require_same_type(self, other)
+      _s.extend(other._s)
       self
     end
 
@@ -1679,7 +1903,10 @@ module Polars
     #   #         2
     #   # ]
     def head(n = 10)
-      to_frame.select(F.col(name).head(n)).to_series
+      if n < 0
+        n = [0, len + n].max
+      end
+      self.class._from_rbseries(_s.head(n))
     end
 
     # Get the last `n` rows.
@@ -1700,33 +1927,147 @@ module Polars
     #   #         3
     #   # ]
     def tail(n = 10)
-      to_frame.select(F.col(name).tail(n)).to_series
+      if n < 0
+        n = [0, len + n].max
+      end
+      self.class._from_rbseries(_s.tail(n))
     end
 
-    # Take every nth value in the Series and return as new Series.
+    # Get the first `n` rows.
+    #
+    # Alias for {#head}.
+    #
+    # @param n [Integer]
+    #   Number of rows to return.
     #
     # @return [Series]
     #
     # @example
-    #   s = Polars::Series.new("a", [1, 2, 3, 4])
-    #   s.take_every(2)
+    #   s = Polars::Series.new("a", [1, 2, 3])
+    #   s.limit(2)
     #   # =>
     #   # shape: (2,)
     #   # Series: 'a' [i64]
     #   # [
     #   #         1
-    #   #         3
+    #   #         2
     #   # ]
-    def take_every(n)
-      super
+    def limit(n = 10)
+      head(n)
     end
 
-    # Sort this Series.
-    #
-    # @param reverse [Boolean]
-    #   Reverse sort.
-    # @param in_place [Boolean]
-    #   Sort in place.
+    # Take every nth value in the Series and return as new Series.
+    #
+    # @param n [Integer]
+    #   Gather every *n*-th row.
+    # @param offset [Integer]
+    #   Start the row index at this offset.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3, 4])
+    #   s.gather_every(2)
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         3
+    #   # ]
+    #
+    # @example
+    #   s.gather_every(2, 1)
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         2
+    #   #         4
+    #   # ]
+    def gather_every(n, offset = 0)
+      super
+    end
+
+    # Execute a SQL query against the Series.
+    #
+    # @note
+    #   This functionality is considered **unstable**, although it is close to
+    #   being considered stable. It may be changed at any point without it being
+    #   considered a breaking change.
+    #
+    # @param query [String]
+    #   SQL query to execute.
+    # @param table_name [String]
+    #   Optionally provide an explicit name for the table that represents the
+    #   calling frame (defaults to "self").
+    #
+    # @return [DataFrame]
+    #
+    # @note
+    #   * The calling Series is automatically registered as a table in the SQLContext
+    #     under the name "self". If you want access to the DataFrames, LazyFrames, and
+    #     other Series found in the current globals, use :meth:`pl.sql <polars.sql>`.
+    #   * More control over registration and execution behaviour is available by
+    #     using the :class:`SQLContext` object.
+    #   * The SQL query executes in lazy mode before being collected and returned
+    #     as a DataFrame.
+    #   * It is recommended to name your Series for use with SQL, otherwise the default
+    #     Series name (an empty string) is used; while `""` is valid, it is awkward.
+    #
+    # @example Query the Series using SQL:
+    #   s = Polars::Series.new(
+    #     "dt",
+    #     [Date.new(1999, 12, 31), Date.new(2099, 2, 14), Date.new(2026, 3, 5)]
+    #   )
+    #   s.sql("
+    #     SELECT
+    #       EXTRACT('year',dt) AS y,
+    #       EXTRACT('month',dt) AS m,
+    #       EXTRACT('day',dt) AS d,
+    #     FROM self
+    #     WHERE dt > '2020-01-01'
+    #     ORDER BY dt DESC
+    #   ")
+    #   # =>
+    #   # shape: (2, 3)
+    #   # ┌──────┬─────┬─────┐
+    #   # │ y    ┆ m   ┆ d   │
+    #   # │ ---  ┆ --- ┆ --- │
+    #   # │ i32  ┆ i8  ┆ i8  │
+    #   # ╞══════╪═════╪═════╡
+    #   # │ 2099 ┆ 2   ┆ 14  │
+    #   # │ 2026 ┆ 3   ┆ 5   │
+    #   # └──────┴─────┴─────┘
+    #
+    # @example While you can refer to an unnamed Series column using the default empty string, it is not recommended:
+    #   s = Polars::Series.new([1, 2, 3])
+    #   s.sql('SELECT "" AS x, "" * 2 AS "2x" FROM self')
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬─────┐
+    #   # │ x   ┆ 2x  │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ i64 │
+    #   # ╞═════╪═════╡
+    #   # │ 1   ┆ 2   │
+    #   # │ 2   ┆ 4   │
+    #   # │ 3   ┆ 6   │
+    #   # └─────┴─────┘
+    def sql(query, table_name: "self")
+      to_frame.sql(query, table_name: table_name)
+    end
+
+    # Sort this Series.
+    #
+    # @param descending [Boolean]
+    #   Reverse sort.
+    # @param nulls_last [Boolean]
+    #   Place null values last instead of first.
+    # @param multithreaded [Boolean]
+    #   Sort using multiple threads.
+    # @param in_place [Boolean]
+    #   Sort in place.
     #
     # @return [Series]
     #
@@ -1742,7 +2083,7 @@ module Polars
     #   #         3
     #   #         4
     #   # ]
-    #   s.sort(reverse: true)
+    #   s.sort(descending: true)
     #   # =>
     #   # shape: (4,)
     #   # Series: 'a' [i64]
@@ -1752,12 +2093,12 @@ module Polars
     #   #         2
     #   #         1
     #   # ]
-    def sort(reverse: false, nulls_last: false, multithreaded: true, in_place: false)
+    def sort(descending: false, nulls_last: false, multithreaded: true, in_place: false)
       if in_place
-        self._s = _s.sort(reverse, nulls_last, multithreaded)
+        self._s = _s.sort(descending, nulls_last, multithreaded)
         self
       else
-        Utils.wrap_s(_s.sort(reverse, nulls_last, multithreaded))
+        Utils.wrap_s(_s.sort(descending, nulls_last, multithreaded))
       end
     end
 
@@ -1783,6 +2124,44 @@ module Polars
       super
     end
 
+    # Return the `k` largest elements of the `by` column.
+    #
+    # Non-null elements are always preferred over null elements, regardless of
+    # the value of `reverse`. The output is not guaranteed to be in any
+    # particular order, call `sort` after this function if you wish the
+    # output to be sorted.
+    #
+    # @param by [Object]
+    #   Column used to determine the largest elements.
+    #   Accepts expression input. Strings are parsed as column names.
+    # @param k [Integer]
+    #   Number of elements to return.
+    # @param reverse [Object]
+    #   Consider the `k` smallest elements of the `by` column (instead of the `k`
+    #   largest). This can be specified per column by passing an array of
+    #   booleans.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [2, 5, 1, 4, 3])
+    #   s.top_k_by("a", k: 3)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         5
+    #   #         4
+    #   #         3
+    #   # ]
+    def top_k_by(
+      by,
+      k: 5,
+      reverse: false
+    )
+      super
+    end
+
     # Return the `k` smallest elements.
     #
     # @param k [Integer]
@@ -1805,9 +2184,47 @@ module Polars
       super
     end
 
+    # Return the `k` smallest elements of the `by` column.
+    #
+    # Non-null elements are always preferred over null elements, regardless of
+    # the value of `reverse`. The output is not guaranteed to be in any
+    # particular order, call `sort` after this function if you wish the
+    # output to be sorted.
+    #
+    # @param by [Object]
+    #   Column used to determine the smallest elements.
+    #   Accepts expression input. Strings are parsed as column names.
+    # @param k [Integer]
+    #   Number of elements to return.
+    # @param reverse [Object]
+    #   Consider the `k` largest elements of the `by` column( (instead of the `k`
+    #   smallest). This can be specified per column by passing an array of
+    #   booleans.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [2, 5, 1, 4, 3])
+    #   s.bottom_k_by("a", k: 3)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   # ]
+    def bottom_k_by(
+      by,
+      k: 5,
+      reverse: false
+    )
+      super
+    end
+
     # Get the index values that would sort this Series.
     #
-    # @param reverse [Boolean]
+    # @param descending [Boolean]
     #   Sort in reverse (descending) order.
     # @param nulls_last [Boolean]
     #   Place null values last instead of first.
@@ -1827,10 +2244,9 @@ module Polars
     #   #         2
     #   #         0
     #   # ]
-    def arg_sort(reverse: false, nulls_last: false)
+    def arg_sort(descending: false, nulls_last: false)
       super
     end
-    alias_method :argsort, :arg_sort
 
     # Get unique index as Series.
     #
@@ -1879,6 +2295,13 @@ module Polars
     #
     # @param element [Object]
     #   Expression or scalar value.
+    # @param side ['any', 'left', 'right']
+    #   If 'any', the index of the first suitable location found is given.
+    #   If 'left', the index of the leftmost suitable location found is given.
+    #   If 'right', return the rightmost suitable location found is given.
+    # @param descending [Boolean]
+    #   Boolean indicating whether the values are descending or not (they
+    #   are required to be sorted either way).
     #
     # @return [Integer]
     #
@@ -1927,12 +2350,12 @@ module Polars
     #   #         5
     #   #         6
     #   # ]
-    def search_sorted(element, side: "any")
+    def search_sorted(element, side: "any", descending: false)
       if element.is_a?(Integer) || element.is_a?(Float)
-        return Polars.select(Polars.lit(self).search_sorted(element, side: side)).item
+        return Polars.select(Polars.lit(self).search_sorted(element, side: side, descending: descending)).item
       end
       element = Series.new(element)
-      Polars.select(Polars.lit(self).search_sorted(element, side: side)).to_series
+      Polars.select(Polars.lit(self).search_sorted(element, side: side, descending: descending)).to_series
     end
 
     # Get unique elements in series.
@@ -1962,12 +2385,17 @@ module Polars
     #
     # @param indices [Array]
     #   Index location used for selection.
+    # @param null_on_oob [Boolean]
+    #   Behavior if an index is out of bounds:
+    #
+    #   - true  -> set the result to null
+    #   - false -> raise an error
     #
     # @return [Series]
     #
     # @example
     #   s = Polars::Series.new("a", [1, 2, 3, 4])
-    #   s.take([1, 3])
+    #   s.gather([1, 3])
     #   # =>
     #   # shape: (2,)
     #   # Series: 'a' [i64]
@@ -1975,8 +2403,8 @@ module Polars
     #   #         2
     #   #         4
     #   # ]
-    def take(indices)
-      to_frame.select(Polars.col(name).take(indices)).to_series
+    def gather(indices, null_on_oob: false)
+      super
     end
 
     # Count the null values in this Series.
@@ -2009,21 +2437,71 @@ module Polars
     def has_nulls
       _s.has_nulls
     end
-    alias_method :has_validity, :has_nulls
 
     # Check if the Series is empty.
     #
+    # @param ignore_nulls [Boolean]
+    #   If true a series containing only nulls will also be considered empty.
+    #   The default is false.
+    #
     # @return [Boolean]
     #
     # @example
     #   s = Polars::Series.new("a", [])
     #   s.is_empty
     #   # => true
-    def is_empty
-      len == 0
+    def is_empty(ignore_nulls: false)
+      if ignore_nulls
+        msg = "the `ignore_nulls` parameter of `Series.is_empty()` is considered unstable."
+        Utils.issue_unstable_warning(msg)
+      end
+
+      _s.is_empty(ignore_nulls: ignore_nulls)
     end
     alias_method :empty?, :is_empty
 
+    # Check if the Series is sorted.
+    #
+    # @param descending [Boolean]
+    #   Check if the Series is sorted in descending order
+    # @param nulls_last [Boolean]
+    #   Set nulls at the end of the Series in sorted check.
+    #
+    # @return [Boolean]
+    #
+    # @example
+    #   s = Polars::Series.new([1, 3, 2])
+    #   s.is_sorted
+    #   # => false
+    #
+    # @example
+    #   s = Polars::Series.new([3, 2, 1])
+    #   s.is_sorted(descending: true)
+    #   # => true
+    def is_sorted(descending: false, nulls_last: false)
+      _s.is_sorted(descending, nulls_last)
+    end
+    alias_method :sorted?, :is_sorted
+
+    # Negate a boolean Series.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [true, false, false])
+    #   s.not_
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [bool]
+    #   # [
+    #   #         false
+    #   #         true
+    #   #         true
+    #   # ]
+    def not_
+      self.class._from_rbseries(_s.not_)
+    end
+
     # Returns a boolean Series indicating which values are null.
     #
     # @return [Series]
@@ -2144,18 +2622,33 @@ module Polars
 
     # Check if elements of this Series are in the other Series.
     #
+    # @param nulls_equal [Boolean]
+    #   If true, treat null as a distinct value. Null values will not propagate.
+    #
     # @return [Series]
     #
     # @example
-    #   s = Polars::Series.new("a", [1, 2, 3])
-    #   s2 = Polars::Series.new("b", [2, 4])
+    #   s = Polars::Series.new("a", [[1, 2, 3]])
+    #   s2 = Polars::Series.new("b", [2, 4, nil])
     #   s2.is_in(s)
     #   # =>
-    #   # shape: (2,)
+    #   # shape: (3,)
+    #   # Series: 'b' [bool]
+    #   # [
+    #   #         true
+    #   #         false
+    #   #         null
+    #   # ]
+    #
+    # @example
+    #   s2.is_in(s, nulls_equal: true)
+    #   # =>
+    #   # shape: (3,)
     #   # Series: 'b' [bool]
     #   # [
     #   #         true
     #   #         false
+    #   #         false
     #   # ]
     #
     # @example
@@ -2190,7 +2683,7 @@ module Polars
     #   #         true
     #   #         false
     #   # ]
-    def is_in(other)
+    def is_in(other, nulls_equal: false)
       super
     end
     alias_method :in?, :is_in
@@ -2252,7 +2745,27 @@ module Polars
     def is_first_distinct
       super
     end
-    alias_method :is_first, :is_first_distinct
+
+    # Return a boolean mask indicating the last occurrence of each distinct value.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new([1, 1, 2, 3, 2])
+    #   s.is_last_distinct
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: '' [bool]
+    #   # [
+    #   #         false
+    #   #         true
+    #   #         false
+    #   #         true
+    #   #         true
+    #   # ]
+    def is_last_distinct
+      super
+    end
 
     # Get mask of all duplicated values.
     #
@@ -2278,6 +2791,11 @@ module Polars
     #
     # This means that every item is expanded to a new row.
     #
+    # @param empty_as_null [Boolean]
+    #   Explode an empty list into a `null`.
+    # @param keep_nulls [Boolean]
+    #   Explode a `null` list into a `null`.
+    #
     # @return [Series]
     #
     # @example
@@ -2294,7 +2812,7 @@ module Polars
     #   #         9
     #   #         10
     #   # ]
-    def explode
+    def explode(empty_as_null: true, keep_nulls: true)
       super
     end
 
@@ -2302,7 +2820,7 @@ module Polars
     #
     # @param other [Series]
     #   Series to compare with.
-    # @param strict [Boolean]
+    # @param check_dtypes [Boolean]
     #   Require data types to match.
     # @param check_names [Boolean]
     #   Require names to match.
@@ -2318,10 +2836,9 @@ module Polars
     #   # => true
     #   s.equals(s2)
     #   # => false
-    def equals(other, strict: false, check_names: false, null_equal: false)
-      _s.equals(other._s, strict, check_names, null_equal)
+    def equals(other, check_dtypes: false, check_names: false, null_equal: true)
+      _s.equals(other._s, check_dtypes, check_names, null_equal)
     end
-    alias_method :series_equal, :equals
 
     # Return the number of elements in the Series.
     #
@@ -2351,16 +2868,19 @@ module Polars
 
     # Cast between data types.
     #
-    # @param dtype [Symbol]
+    # @param dtype [Object]
     #   DataType to cast to
     # @param strict [Boolean]
     #   Throw an error if a cast could not be done for instance due to an overflow
+    # @param wrap_numerical [Boolean]
+    #   If true numeric casts wrap overflowing values instead of
+    #   marking the cast as invalid.
     #
     # @return [Series]
     #
     # @example
     #   s = Polars::Series.new("a", [true, false, true])
-    #   s.cast(:u32)
+    #   s.cast(Polars::UInt32)
     #   # =>
     #   # shape: (3,)
     #   # Series: 'a' [u32]
@@ -2369,24 +2889,18 @@ module Polars
     #   #         0
     #   #         1
     #   # ]
-    def cast(dtype, strict: true)
-      super
+    def cast(dtype, strict: true, wrap_numerical: false)
+      dtype = Utils.parse_into_dtype(dtype)
+      self.class._from_rbseries(_s.cast(dtype, strict, wrap_numerical))
     end
 
     # 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.
-    #
     # @return [Series]
     #
     # @example
     #   s = Polars::Series.new("values", ["a", nil, "x", "a"])
-    #   s.cast(:cat).to_physical
+    #   s.cast(Polars::Categorical).to_physical
     #   # =>
     #   # shape: (4,)
     #   # Series: 'values' [u32]
@@ -2457,7 +2971,7 @@ module Polars
     # @return [Series]
     #
     # @example
-    #   s = Polars::Series.new("a", [1, 2, 3], dtype: :i8)
+    #   s = Polars::Series.new("a", [1, 2, 3], dtype: Polars::Int8)
     #   s.reverse
     #   # =>
     #   # shape: (3,)
@@ -2471,77 +2985,123 @@ module Polars
       super
     end
 
-    # Check if this Series datatype is numeric.
+    # Get a boolean mask of the values that are between the given lower/upper bounds.
     #
-    # @return [Boolean]
+    # @param lower_bound [Object]
+    #   Lower bound value. Accepts expression input. Non-expression inputs
+    #   (including strings) are parsed as literals.
+    # @param upper_bound [Object]
+    #   Upper bound value. Accepts expression input. Non-expression inputs
+    #   (including strings) are parsed as literals.
+    # @param closed ['both', 'left', 'right', 'none']
+    #   Define which sides of the interval are closed (inclusive).
     #
-    # @example
-    #   s = Polars::Series.new("a", [1, 2, 3])
-    #   s.is_numeric
-    #   # => true
-    def is_numeric
-      [Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64, Float32, Float64].include?(dtype)
-    end
-    alias_method :numeric?, :is_numeric
-
-    # Check if this Series datatype is datelike.
+    # @return [Series]
     #
-    # @return [Boolean]
+    # @note
+    #   If the value of the `lower_bound` is greater than that of the `upper_bound`
+    #   then the result will be false, as no value can satisfy the condition.
     #
     # @example
-    #   s = Polars::Series.new([Date.new(2021, 1, 1), Date.new(2021, 1, 2), Date.new(2021, 1, 3)])
-    #   s.is_datelike
-    #   # => true
-    def is_datelike
-      [Date, Time].include?(dtype) || dtype.is_a?(Datetime) || dtype.is_a?(Duration)
-    end
-    alias_method :datelike?, :is_datelike
-    alias_method :is_temporal, :is_datelike
-    alias_method :temporal?, :is_datelike
-
-    # Check if this Series has floating point numbers.
+    #   s = Polars::Series.new("num", [1, 2, 3, 4, 5])
+    #   s.is_between(2, 4)
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'num' [bool]
+    #   # [
+    #   #         false
+    #   #         true
+    #   #         true
+    #   #         true
+    #   #         false
+    #   # ]
     #
-    # @return [Boolean]
+    # @example Use the `closed` argument to include or exclude the values at the bounds:
+    #   s.is_between(2, 4, closed: "left")
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'num' [bool]
+    #   # [
+    #   #         false
+    #   #         true
+    #   #         true
+    #   #         false
+    #   #         false
+    #   # ]
     #
-    # @example
-    #   s = Polars::Series.new("a", [1.0, 2.0, 3.0])
-    #   s.is_float
-    #   # => true
-    def is_float
-      [Float32, Float64].include?(dtype)
-    end
-    alias_method :float?, :is_float
+    # @example You can also use strings as well as numeric/temporal values:
+    #   s = Polars::Series.new("s", ["a", "b", "c", "d", "e"])
+    #   s.is_between("b", "d", closed: "both")
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 's' [bool]
+    #   # [
+    #   #         false
+    #   #         true
+    #   #         true
+    #   #         true
+    #   #         false
+    #   # ]
+    def is_between(
+      lower_bound,
+      upper_bound,
+      closed: "both"
+    )
+      if closed == "none"
+        out = (self > lower_bound) & (self < upper_bound)
+      elsif closed == "both"
+        out = (self >= lower_bound) & (self <= upper_bound)
+      elsif closed == "right"
+        out = (self > lower_bound) & (self <= upper_bound)
+      elsif closed == "left"
+        out = (self >= lower_bound) & (self < upper_bound)
+      end
 
-    # Check if this Series is a Boolean.
-    #
-    # @return [Boolean]
-    #
-    # @example
-    #   s = Polars::Series.new("a", [true, false, true])
-    #   s.is_boolean
-    #   # => true
-    def is_boolean
-      dtype == Boolean
+      if out.is_a?(Expr)
+        out = F.select(out).to_series
+      end
+
+      out
     end
-    alias_method :boolean?, :is_boolean
-    alias_method :is_bool, :is_boolean
-    alias_method :bool?, :is_boolean
 
-    # Check if this Series datatype is a Utf8.
+    # Get a boolean mask of the values being close to the other values.
     #
-    # @return [Boolean]
+    # @param abs_tol [Float]
+    #   Absolute tolerance. This is the maximum allowed absolute difference between
+    #   two values. Must be non-negative.
+    # @param rel_tol [Float]
+    #   Relative tolerance. This is the maximum allowed difference between two
+    #   values, relative to the larger absolute value. Must be in the range [0, 1).
+    # @param nans_equal [Boolean]
+    #   Whether NaN values should be considered equal.
+    #
+    # @return [Series]
     #
     # @example
-    #   s = Polars::Series.new("x", ["a", "b", "c"])
-    #   s.is_utf8
-    #   # => true
-    def is_utf8
-      dtype == String
+    #   s = Polars::Series.new("s", [1.0, 1.2, 1.4, 1.45, 1.6])
+    #   s.is_close(1.4, abs_tol: 0.1)
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 's' [bool]
+    #   # [
+    #   #         false
+    #   #         false
+    #   #         true
+    #   #         true
+    #   #         false
+    #   # ]
+    def is_close(
+      other,
+      abs_tol: 0.0,
+      rel_tol: 1.0e-09,
+      nans_equal: false
+    )
+      F.select(
+        F.lit(self).is_close(
+          other, abs_tol: abs_tol, rel_tol: rel_tol, nans_equal: nans_equal
+        )
+      ).to_series
     end
-    alias_method :utf8?, :is_utf8
-
-    # def view
-    # end
 
     # Convert this Series to a Numo array. This operation clones data but is completely safe.
     #
@@ -2554,29 +3114,7 @@ module Polars
     #   # Numo::Int64#shape=[3]
     #   # [1, 2, 3]
     def to_numo
-      if !has_validity
-        if is_datelike
-          Numo::RObject.cast(to_a)
-        elsif is_numeric
-          # TODO make more efficient
-          {
-            UInt8 => Numo::UInt8,
-            UInt16 => Numo::UInt16,
-            UInt32 => Numo::UInt32,
-            UInt64 => Numo::UInt64,
-            Int8 => Numo::Int8,
-            Int16 => Numo::Int16,
-            Int32 => Numo::Int32,
-            Int64 => Numo::Int64,
-            Float32 => Numo::SFloat,
-            Float64 => Numo::DFloat
-          }.fetch(dtype.class).cast(to_a)
-        elsif is_boolean
-          Numo::Bit.cast(to_a)
-        else
-          _s.to_numo
-        end
-      elsif is_datelike
+      if dtype.temporal?
         Numo::RObject.cast(to_a)
       else
         _s.to_numo
@@ -2614,16 +3152,16 @@ module Polars
 
     # Set values at the index locations.
     #
-    # @param idx [Object]
+    # @param indices [Object]
     #   Integers representing the index locations.
-    # @param value [Object]
+    # @param values [Object]
     #   Replacement values.
     #
     # @return [Series]
     #
     # @example
     #   s = Polars::Series.new("a", [1, 2, 3])
-    #   s.set_at_idx(1, 10)
+    #   s.scatter(1, 10)
     #   # =>
     #   # shape: (3,)
     #   # Series: 'a' [i64]
@@ -2632,56 +3170,100 @@ module Polars
     #   #         10
     #   #         3
     #   # ]
-    def scatter(idx, value)
-      if idx.is_a?(Integer)
-        idx = [idx]
+    def scatter(indices, values)
+      if indices.is_a?(Integer)
+        indices = [indices]
       end
-      if idx.length == 0
+      if indices.length == 0
         return self
       end
 
-      idx = Series.new("", idx)
-      if value.is_a?(Integer) || value.is_a?(Float) || Utils.bool?(value) || value.is_a?(::String) || value.nil?
-        value = Series.new("", [value])
+      indices = Series.new("", indices)
+      if values.is_a?(Integer) || values.is_a?(Float) || Utils.bool?(values) || values.is_a?(::String) || values.nil?
+        values = Series.new("", [values])
 
         # if we need to set more than a single value, we extend it
-        if idx.length > 0
-          value = value.extend_constant(value[0], idx.length - 1)
+        if indices.length > 0
+          values = values.extend_constant(values[0], indices.length - 1)
         end
-      elsif !value.is_a?(Series)
-        value = Series.new("", value)
+      elsif !values.is_a?(Series)
+        values = Series.new("", values)
       end
-      _s.scatter(idx._s, value._s)
+      _s.scatter(indices._s, values._s)
       self
     end
-    alias_method :set_at_idx, :scatter
+
+    # Get the index of the first occurrence of a value, or `nil` if it's not found.
+    #
+    # @param element [Object]
+    #   Value to find.
+    #
+    # @return [Object]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, nil, 17])
+    #   s.index_of(17)
+    #   # => 2
+    #
+    # @example
+    #   s.index_of(nil) # search for a null
+    #   # => 1
+    #
+    # @example
+    #   s.index_of(55).nil?
+    #   # => true
+    def index_of(element)
+      F.select(F.lit(self).index_of(element)).item
+    end
 
     # Create an empty copy of the current Series.
     #
     # The copy has identical name/dtype but no data.
     #
+    # @param n [Integer]
+    #   Number of (empty) elements to return in the cleared frame.
+    #
     # @return [Series]
     #
     # @example
     #   s = Polars::Series.new("a", [nil, true, false])
-    #   s.cleared
+    #   s.clear
     #   # =>
     #   # shape: (0,)
     #   # Series: 'a' [bool]
     #   # [
     #   # ]
-    def cleared
-      len > 0 ? limit(0) : clone
-    end
-
-    # clone handled by initialize_copy
-
-    # Fill floating point NaN value with a fill value.
     #
-    # @param fill_value [Object]
-    #   Value used to fill nan values.
-    #
-    # @return [Series]
+    # @example
+    #   s.clear(n: 2)
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [bool]
+    #   # [
+    #   #         null
+    #   #         null
+    #   # ]
+    def clear(n: 0)
+      if n < 0
+        msg = "`n` should be greater than or equal to 0, got #{n}"
+        raise ArgumentError, msg
+      end
+      # faster path
+      if n == 0
+        return self.class._from_rbseries(_s.clear)
+      end
+      s = len > 0 ? self.class.new(name, [], dtype: dtype) : clone
+      n > 0 ? s.extend_constant(nil, n) : s
+    end
+
+    # clone handled by initialize_copy
+
+    # Fill floating point NaN value with a fill value.
+    #
+    # @param value [Object]
+    #   Value used to fill nan values.
+    #
+    # @return [Series]
     #
     # @example
     #   s = Polars::Series.new("a", [1.0, 2.0, 3.0, Float::NAN])
@@ -2695,7 +3277,7 @@ module Polars
     #   #         3.0
     #   #         0.0
     #   # ]
-    def fill_nan(fill_value)
+    def fill_nan(value)
       super
     end
 
@@ -2751,6 +3333,30 @@ module Polars
       super
     end
 
+    # Fill missing values with the next non-null value.
+    #
+    # This is an alias of `.fill_null(strategy: "backward")`.
+    #
+    # @param limit [Integer]
+    #   The number of consecutive null values to backward fill.
+    #
+    # @return [Series]
+    def backward_fill(limit: nil)
+      fill_null(strategy: "backward", limit: limit)
+    end
+
+    # Fill missing values with the next non-null value.
+    #
+    # This is an alias of `.fill_null(strategy: "forward")`.
+    #
+    # @param limit [Integer]
+    #   The number of consecutive null values to forward fill.
+    #
+    # @return [Series]
+    def forward_fill(limit: nil)
+      fill_null(strategy: "forward", limit: limit)
+    end
+
     # Rounds down to the nearest integer value.
     #
     # Only works on floating point Series.
@@ -2793,10 +3399,59 @@ module Polars
       super
     end
 
+    # Truncate numeric data toward zero to `decimals` number of decimal places.
+    #
+    # @param decimals [Integer]
+    #   Number of decimal places to truncate to.
+    #
+    # @return [Series]
+    #
+    # @note
+    #   Truncation discards the fractional part beyond the given number of decimals.
+    #   For example, when rounding to 0 decimals 0.25, -0.25, 0.99, and -0.99 will
+    #   all round to 0. When rounding to 1 decimal 1.9999 rounds to 1.9 and -1.9999
+    #   rounds to -1.9. There is no tiebreak behaviour at midpoint values as there
+    #   is with :meth:`round` so 0.5 and -0.5 will also round to 0 when decimals=1.
+    #
+    # @note
+    #   This method performs numeric truncation. For truncating temporal
+    #   data (dates/datetimes), use :func:`Series.dt.truncate` instead.
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.12345, 2.56789, 3.991234])
+    #   s.truncate(2)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         1.12
+    #   #         2.56
+    #   #         3.99
+    #   # ]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [-1.78, 2.56, -3.99])
+    #   s.truncate(0)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         -1.0
+    #   #         2.0
+    #   #         -3.0
+    #   # ]
+    def truncate(decimals = 0)
+      super
+    end
+
     # Round underlying floating point data by `decimals` digits.
     #
+    # The default rounding mode is "half to even" (also known as "bankers' rounding").
+    #
     # @param decimals [Integer]
-    #   number of decimals to round by.
+    #   Number of decimals to round by.
+    # @param mode ['half_to_even', 'half_away_from_zero']
+    #   Rounding mode.
     #
     # @return [Series]
     #
@@ -2811,7 +3466,29 @@ module Polars
     #   #         2.57
     #   #         3.9
     #   # ]
-    def round(decimals = 0)
+    def round(decimals = 0, mode: "half_to_even")
+      super
+    end
+
+    # Round to a number of significant figures.
+    #
+    # @param digits [Integer]
+    #   Number of significant figures to round to.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new([0.01234, 3.333, 3450.0])
+    #   s.round_sig_figs(2)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: '' [f64]
+    #   # [
+    #   #         0.012
+    #   #         3.3
+    #   #         3500.0
+    #   # ]
+    def round_sig_figs(digits)
       super
     end
 
@@ -2842,6 +3519,9 @@ module Polars
     #
     # Can return multiple Values.
     #
+    # @param maintain_order [Boolean]
+    #   Maintain order of data. This requires more work.
+    #
     # @return [Series]
     #
     # @example
@@ -2853,7 +3533,7 @@ module Polars
     #   # [
     #   #         2
     #   # ]
-    def mode
+    def mode(maintain_order: false)
       super
     end
 
@@ -2935,6 +3615,25 @@ module Polars
       super
     end
 
+    # Compute the element-wise value for the cotangent.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [0.0, Math::PI / 2.0, Math::PI])
+    #   s.cot
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         inf
+    #   #         6.1232e-17
+    #   #         -8.1656e15
+    #   # ]
+    def cot
+      super
+    end
+
     # Compute the element-wise value for the inverse sine.
     #
     # @return [Series]
@@ -2953,7 +3652,6 @@ module Polars
     def arcsin
       super
     end
-    alias_method :asin, :arcsin
 
     # Compute the element-wise value for the inverse cosine.
     #
@@ -2973,7 +3671,6 @@ module Polars
     def arccos
       super
     end
-    alias_method :acos, :arccos
 
     # Compute the element-wise value for the inverse tangent.
     #
@@ -2993,7 +3690,6 @@ module Polars
     def arctan
       super
     end
-    alias_method :atan, :arctan
 
     # Compute the element-wise value for the inverse hyperbolic sine.
     #
@@ -3013,7 +3709,6 @@ module Polars
     def arcsinh
       super
     end
-    alias_method :asinh, :arcsinh
 
     # Compute the element-wise value for the inverse hyperbolic cosine.
     #
@@ -3034,7 +3729,6 @@ module Polars
     def arccosh
       super
     end
-    alias_method :acosh, :arccosh
 
     # Compute the element-wise value for the inverse hyperbolic tangent.
     #
@@ -3058,7 +3752,6 @@ module Polars
     def arctanh
       super
     end
-    alias_method :atanh, :arctanh
 
     # Compute the element-wise value for the hyperbolic sine.
     #
@@ -3135,7 +3828,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new("a", [1, 2, 3])
-    #   s.map_elements { |x| x + 10 }
+    #   s.map_elements(return_dtype: Polars::Int64) { |x| x + 10 }
     #   # =>
     #   # shape: (3,)
     #   # Series: 'a' [i64]
@@ -3144,21 +3837,23 @@ module Polars
     #   #         12
     #   #         13
     #   # ]
-    def map_elements(return_dtype: nil, skip_nulls: true, &func)
+    def map_elements(return_dtype: nil, skip_nulls: true, &function)
       if return_dtype.nil?
         pl_return_dtype = nil
       else
-        pl_return_dtype = Utils.rb_type_to_dtype(return_dtype)
+        pl_return_dtype = Utils.parse_into_dtype(return_dtype)
       end
-      Utils.wrap_s(_s.apply_lambda(func, pl_return_dtype, skip_nulls))
+      Utils.wrap_s(_s.map_elements(function, pl_return_dtype, skip_nulls))
     end
     alias_method :map, :map_elements
-    alias_method :apply, :map_elements
 
     # 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. Accepts scalar expression
+    #   input. Non-expression inputs are parsed as literals.
     #
     # @return [Series]
     #
@@ -3184,19 +3879,7 @@ module Polars
     #   #         3
     #   #         null
     #   # ]
-    def shift(periods = 1)
-      super
-    end
-
-    # Shift the values by a given period and fill the resulting null values.
-    #
-    # @param periods [Integer]
-    #   Number of places to shift (may be negative).
-    # @param fill_value [Object]
-    #   Fill None values with the result of this expression.
-    #
-    # @return [Series]
-    def shift_and_fill(periods, fill_value)
+    def shift(n = 1, fill_value: nil)
       super
     end
 
@@ -3244,6 +3927,90 @@ module Polars
       Utils.wrap_s(_s.zip_with(mask._s, other._s))
     end
 
+    # Compute a rolling min based on another series.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # Given a `by` column `<t_0, t_1, ..., t_n>`, then `closed: "right"`
+    # (the default) means the windows will be:
+    #
+    #   - (t_0 - window_size, t_0]
+    #   - (t_1 - window_size, t_1]
+    #   - ...
+    #   - (t_n - window_size, t_n]
+    #
+    # @param by [Object]
+    #   Should be `DateTime`, `Date`, `UInt64`, `UInt32`, `Int64`,
+    #   or `Int32` data type (note that the integral ones require using `'i'`
+    #   in `window size`).
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #   - 1i    (1 index count)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    #
+    # @return [Series]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   s = Polars::Series.new("index", 25.times.to_a)
+    #   d = Polars::Series.new("date", Polars.datetime_range(start, stop, "1h", eager: true))
+    #   s.rolling_min_by(d, "3h")
+    #   # =>
+    #   # shape: (25,)
+    #   # Series: 'index' [i64]
+    #   # [
+    #   #         0
+    #   #         0
+    #   #         0
+    #   #         1
+    #   #         2
+    #   #         …
+    #   #         18
+    #   #         19
+    #   #         20
+    #   #         21
+    #   #         22
+    #   # ]
+    def rolling_min_by(
+      by,
+      window_size,
+      min_samples: 1,
+      closed: "right"
+    )
+      super
+    end
+
     # 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
@@ -3255,9 +4022,9 @@ module Polars
     # @param weights [Array]
     #   An optional slice with the same length as the window that will be multiplied
     #   elementwise with the values in the window.
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
-    #   a result. If None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -3279,12 +4046,96 @@ module Polars
     def rolling_min(
       window_size,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
       center: false
     )
       super
     end
 
+    # Compute a rolling max based on another series.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # Given a `by` column `<t_0, t_1, ..., t_n>`, then `closed="right"`
+    # (the default) means the windows will be:
+    #
+    #   - (t_0 - window_size, t_0]
+    #   - (t_1 - window_size, t_1]
+    #   - ...
+    #   - (t_n - window_size, t_n]
+    #
+    # @param by [Object]
+    #   Should be `DateTime`, `Date`, `UInt64`, `UInt32`, `Int64`,
+    #   or `Int32` data type (note that the integral ones require using `'i'`
+    #   in `window size`).
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #   - 1i    (1 index count)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    #
+    # @return [Series]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   s = Polars::Series.new("index", 25.times.to_a)
+    #   d = Polars::Series.new("date", Polars.datetime_range(start, stop, "1h", eager: true))
+    #   s.rolling_max_by(d, "3h")
+    #   # =>
+    #   # shape: (25,)
+    #   # Series: 'index' [i64]
+    #   # [
+    #   #         0
+    #   #         1
+    #   #         2
+    #   #         3
+    #   #         4
+    #   #         …
+    #   #         20
+    #   #         21
+    #   #         22
+    #   #         23
+    #   #         24
+    #   # ]
+    def rolling_max_by(
+      by,
+      window_size,
+      min_samples: 1,
+      closed: "right"
+    )
+      super
+    end
+
     # 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
@@ -3296,9 +4147,9 @@ module Polars
     # @param weights [Array]
     #   An optional slice with the same length as the window that will be multiplied
     #   elementwise with the values in the window.
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
-    #   a result. If None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -3320,12 +4171,96 @@ module Polars
     def rolling_max(
       window_size,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
       center: false
     )
       super
     end
 
+    # Compute a rolling mean based on another series.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # Given a `by` column `<t_0, t_1, ..., t_n>`, then `closed: "right"`
+    # (the default) means the windows will be:
+    #
+    #   - (t_0 - window_size, t_0]
+    #   - (t_1 - window_size, t_1]
+    #   - ...
+    #   - (t_n - window_size, t_n]
+    #
+    # @param by [Object]
+    #   Should be `DateTime`, `Date`, `UInt64`, `UInt32`, `Int64`,
+    #   or `Int32` data type (note that the integral ones require using `'i'`
+    #   in `window size`).
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #   - 1i    (1 index count)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    #
+    # @return [Series]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   s = Polars::Series.new("index", 25.times.to_a)
+    #   d = Polars::Series.new("date", Polars.datetime_range(start, stop, "1h", eager: true))
+    #   s.rolling_mean_by(d, "3h")
+    #   # =>
+    #   # shape: (25,)
+    #   # Series: 'index' [f64]
+    #   # [
+    #   #         0.0
+    #   #         0.5
+    #   #         1.0
+    #   #         2.0
+    #   #         3.0
+    #   #         …
+    #   #         19.0
+    #   #         20.0
+    #   #         21.0
+    #   #         22.0
+    #   #         23.0
+    #   # ]
+    def rolling_mean_by(
+      by,
+      window_size,
+      min_samples: 1,
+      closed: "right"
+    )
+      super
+    end
+
     # 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
@@ -3337,9 +4272,9 @@ module Polars
     # @param weights [Array]
     #   An optional slice with the same length as the window that will be multiplied
     #   elementwise with the values in the window.
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
-    #   a result. If None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -3361,12 +4296,96 @@ module Polars
     def rolling_mean(
       window_size,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
       center: false
     )
       super
     end
 
+    # Compute a rolling sum based on another series.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # Given a `by` column `<t_0, t_1, ..., t_n>`, then `closed: "right"`
+    # (the default) means the windows will be:
+    #
+    #   - (t_0 - window_size, t_0]
+    #   - (t_1 - window_size, t_1]
+    #   - ...
+    #   - (t_n - window_size, t_n]
+    #
+    # @param by [Object]
+    #   Should be `DateTime`, `Date`, `UInt64`, `UInt32`, `Int64`,
+    #   or `Int32` data type (note that the integral ones require using `'i'`
+    #   in `window size`).
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #   - 1i    (1 index count)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    #
+    # @return [Series]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   s = Polars::Series.new("index", 25.times.to_a)
+    #   d = Polars::Series.new("date", Polars.datetime_range(start, stop, "1h", eager: true))
+    #   s.rolling_sum_by(d, "3h")
+    #   # =>
+    #   # shape: (25,)
+    #   # Series: 'index' [i64]
+    #   # [
+    #   #         0
+    #   #         1
+    #   #         3
+    #   #         6
+    #   #         9
+    #   #         …
+    #   #         57
+    #   #         60
+    #   #         63
+    #   #         66
+    #   #         69
+    #   # ]
+    def rolling_sum_by(
+      by,
+      window_size,
+      min_samples: 0,
+      closed: "right"
+    )
+      super
+    end
+
     # 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
@@ -3378,9 +4397,9 @@ module Polars
     # @param weights [Array]
     #   An optional slice with the same length as the window that will be multiplied
     #   elementwise with the values in the window.
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
-    #   a result. If None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -3402,12 +4421,99 @@ module Polars
     def rolling_sum(
       window_size,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
       center: false
     )
       super
     end
 
+    # Compute a rolling standard deviation based on another series.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # Given a `by` column `<t_0, t_1, ..., t_n>`, then `closed="right"`
+    # (the default) means the windows will be:
+    #
+    #   - (t_0 - window_size, t_0]
+    #   - (t_1 - window_size, t_1]
+    #   - ...
+    #   - (t_n - window_size, t_n]
+    #
+    # @param by [Object]
+    #   Should be `DateTime`, `Date`, `UInt64`, `UInt32`, `Int64`,
+    #   or `Int32` data type (note that the integral ones require using `'i'`
+    #   in `window size`).
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #   - 1i    (1 index count)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param ddof [Integer]
+    #   "Delta Degrees of Freedom": The divisor for a length N window is N - ddof
+    #
+    # @return [Series]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   s = Polars::Series.new("index", 25.times.to_a)
+    #   d = Polars::Series.new("date", Polars.datetime_range(start, stop, "1h", eager: true))
+    #   s.rolling_std_by(d, "3h")
+    #   # =>
+    #   # shape: (25,)
+    #   # Series: 'index' [f64]
+    #   # [
+    #   #         null
+    #   #         0.707107
+    #   #         1.0
+    #   #         1.0
+    #   #         1.0
+    #   #         …
+    #   #         1.0
+    #   #         1.0
+    #   #         1.0
+    #   #         1.0
+    #   #         1.0
+    #   # ]
+    def rolling_std_by(
+      by,
+      window_size,
+      min_samples: 1,
+      closed: "right",
+      ddof: 1
+    )
+      super
+    end
+
     # Compute a rolling std dev.
     #
     # A window of length `window_size` will traverse the array. The values that fill
@@ -3419,11 +4525,13 @@ module Polars
     # @param weights [Array]
     #   An optional slice with the same length as the window that will be multiplied
     #   elementwise with the values in the window.
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
-    #   a result. If None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
+    # @param ddof [Integer]
+    #   "Delta Degrees of Freedom": The divisor for a length N window is N - ddof
     #
     # @return [Series]
     #
@@ -3444,13 +4552,100 @@ module Polars
     def rolling_std(
       window_size,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
       center: false,
       ddof: 1
     )
       super
     end
 
+    # Compute a rolling variance based on another series.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # Given a `by` column `<t_0, t_1, ..., t_n>`, then `closed: "right"`
+    # (the default) means the windows will be:
+    #
+    #   - (t_0 - window_size, t_0]
+    #   - (t_1 - window_size, t_1]
+    #   - ...
+    #   - (t_n - window_size, t_n]
+    #
+    # @param by
+    #   Should be `DateTime`, `Date`, `UInt64`, `UInt32`, `Int64`,
+    #   or `Int32` data type (note that the integral ones require using `'i'`
+    #   in `window size`).
+    # @param window_size
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #   - 1i    (1 index count)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    # @param ddof
+    #   "Delta Degrees of Freedom": The divisor for a length N window is N - ddof
+    #
+    # @return [Series]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   s = Polars::Series.new("index", 25.times.to_a)
+    #   d = Polars::Series.new("date", Polars.datetime_range(start, stop, "1h", eager: true))
+    #   s.rolling_var_by(d, "3h")
+    #   # =>
+    #   # shape: (25,)
+    #   # Series: 'index' [f64]
+    #   # [
+    #   #         null
+    #   #         0.5
+    #   #         1.0
+    #   #         1.0
+    #   #         1.0
+    #   #         …
+    #   #         1.0
+    #   #         1.0
+    #   #         1.0
+    #   #         1.0
+    #   #         1.0
+    #   # ]
+    def rolling_var_by(
+      by,
+      window_size,
+      min_samples: 1,
+      closed: "right",
+      ddof: 1
+    )
+      super
+    end
+
     # Compute a rolling variance.
     #
     # A window of length `window_size` will traverse the array. The values that fill
@@ -3462,11 +4657,13 @@ module Polars
     # @param weights [Array]
     #   An optional slice with the same length as the window that will be multiplied
     #   elementwise with the values in the window.
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
-    #   a result. If None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
+    # @param ddof [Integer]
+    #   "Delta Degrees of Freedom": The divisor for a length N window is N - ddof
     #
     # @return [Series]
     #
@@ -3487,26 +4684,149 @@ module Polars
     def rolling_var(
       window_size,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
       center: false,
       ddof: 1
     )
       super
     end
 
-    # def rolling_apply
-    # end
-
-    # Compute a rolling median.
+    # Compute a custom rolling window function.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
     #
     # @param window_size [Integer]
-    #   The length of the window.
+    #   The length of the window in number of elements.
+    # @param weights [Object]
+    #   An optional slice with the same length as the window that will be multiplied
+    #   elementwise with the values in the window.
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If set to `nil` (default), it will be set equal to `window_size`.
+    # @param center [Boolean]
+    #   Set the labels at the center of the window.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new([11.0, 2.0, 9.0, Float::NAN, 8.0])
+    #   s.rolling_map(3) { |v| v.drop_nans.sum }
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: '' [f64]
+    #   # [
+    #   #         null
+    #   #         null
+    #   #         22.0
+    #   #         11.0
+    #   #         17.0
+    #   # ]
+    def rolling_map(
+      window_size,
+      weights: nil,
+      min_samples: nil,
+      center: false,
+      &function
+    )
+      super
+    end
+
+    # Compute a rolling median based on another series.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # Given a `by` column `<t_0, t_1, ..., t_n>`, then `closed: "right"`
+    # (the default) means the windows will be:
+    #
+    #   - (t_0 - window_size, t_0]
+    #   - (t_1 - window_size, t_1]
+    #   - ...
+    #   - (t_n - window_size, t_n]
+    #
+    # @param by [Object]
+    #   Should be `DateTime`, `Date`, `UInt64`, `UInt32`, `Int64`,
+    #   or `Int32` data type (note that the integral ones require using `'i'`
+    #   in `window size`).
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic temporal
+    #   size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #   - 1i    (1 index count)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    #
+    # @return [Series]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   s = Polars::Series.new("index", 25.times.to_a)
+    #   d = Polars::Series.new("date", Polars.datetime_range(start, stop, "1h", eager: true))
+    #   s.rolling_median_by(d, "3h")
+    #   # =>
+    #   # shape: (25,)
+    #   # Series: 'index' [f64]
+    #   # [
+    #   #         0.0
+    #   #         0.5
+    #   #         1.0
+    #   #         2.0
+    #   #         3.0
+    #   #         …
+    #   #         19.0
+    #   #         20.0
+    #   #         21.0
+    #   #         22.0
+    #   #         23.0
+    #   # ]
+    def rolling_median_by(
+      by,
+      window_size,
+      min_samples: 1,
+      closed: "right"
+    )
+      super
+    end
+
+    # Compute a rolling median.
+    #
+    # @param window_size [Integer]
+    #   The length of the window.
     # @param weights [Array]
     #   An optional slice with the same length as the window that will be multiplied
     #   elementwise with the values in the window.
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
-    #   a result. If None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -3529,12 +4849,102 @@ module Polars
     def rolling_median(
       window_size,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
       center: false
     )
       super
     end
 
+    # Compute a rolling quantile based on another series.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # Given a `by` column `<t_0, t_1, ..., t_n>`, then `closed: "right"`
+    # (the default) means the windows will be:
+    #
+    #   - (t_0 - window_size, t_0]
+    #   - (t_1 - window_size, t_1]
+    #   - ...
+    #   - (t_n - window_size, t_n]
+    #
+    # @param by [Object]
+    #   Should be `DateTime`, `Date`, `UInt64`, `UInt32`, `Int64`,
+    #   or `Int32` data type (note that the integral ones require using `'i'`
+    #   in `window size`).
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic
+    #   temporal size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #   - 1i    (1 index count)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param quantile [Float]
+    #   Quantile between 0.0 and 1.0.
+    # @param interpolation ['nearest', 'higher', 'lower', 'midpoint', 'linear', 'equiprobable']
+    #   Interpolation method.
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    #
+    # @return [Series]
+    #
+    # @note
+    #   If you want to compute multiple aggregation statistics over the same dynamic
+    #   window, consider using `rolling` - this method can cache the window size
+    #   computation.
+    #
+    # @example
+    #   start = DateTime.new(2001, 1, 1)
+    #   stop = DateTime.new(2001, 1, 2)
+    #   s = Polars::Series.new("index", 25.times.to_a)
+    #   d = Polars::Series.new("date", Polars.datetime_range(start, stop, "1h", eager: true))
+    #   s.rolling_quantile_by(d, "3h", quantile: 0.5)
+    #   # =>
+    #   # shape: (25,)
+    #   # Series: 'index' [f64]
+    #   # [
+    #   #         0.0
+    #   #         1.0
+    #   #         1.0
+    #   #         2.0
+    #   #         3.0
+    #   #         …
+    #   #         19.0
+    #   #         20.0
+    #   #         21.0
+    #   #         22.0
+    #   #         23.0
+    #   # ]
+    def rolling_quantile_by(
+      by,
+      window_size,
+      quantile:,
+      interpolation: "nearest",
+      min_samples: 1,
+      closed: "right"
+    )
+      super
+    end
+
     # Compute a rolling quantile.
     #
     # @param quantile [Float]
@@ -3546,9 +4956,9 @@ module Polars
     # @param weights [Array]
     #   An optional slice with the same length as the window that will be multiplied
     #   elementwise with the values in the window.
-    # @param min_periods [Integer]
+    # @param min_samples [Integer]
     #   The number of values in the window that should be non-null before computing
-    #   a result. If None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -3563,10 +4973,10 @@ module Polars
     #   # [
     #   #         null
     #   #         null
-    #   #         1.0
     #   #         2.0
     #   #         3.0
     #   #         4.0
+    #   #         6.0
     #   # ]
     #
     # @example
@@ -3587,7 +4997,144 @@ module Polars
       interpolation: "nearest",
       window_size: 2,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
+      center: false
+    )
+      super
+    end
+
+    # Compute a rolling rank based on another column.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # Given a `by` column `<t_0, t_1, ..., t_n>`, then `closed="right"`
+    # (the default) means the windows will be:
+    #
+    #   - (t_0 - window_size, t_0]
+    #   - (t_1 - window_size, t_1]
+    #   - ...
+    #   - (t_n - window_size, t_n]
+    #
+    # @param by [Expr]
+    #   Should be `DateTime`, `Date`, `UInt64`, `UInt32`, `Int64`,
+    #   or `Int32` data type (note that the integral ones require using `'i'`
+    #   in `window size`).
+    # @param window_size [String]
+    #   The length of the window. Can be a dynamic
+    #   temporal size indicated by a timedelta or the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 calendar day)
+    #   - 1w    (1 calendar week)
+    #   - 1mo   (1 calendar month)
+    #   - 1q    (1 calendar quarter)
+    #   - 1y    (1 calendar year)
+    #   - 1i    (1 index count)
+    #
+    #   By "calendar day", we mean the corresponding time on the next day
+    #   (which may not be 24 hours, due to daylight savings). Similarly for
+    #   "calendar week", "calendar month", "calendar quarter", and
+    #   "calendar year".
+    # @param method ['average', 'min', 'max', 'dense', 'random']
+    #   The method used to assign ranks to tied elements.
+    #   The following methods are available (default is 'average'):
+    #
+    #   - 'average' : The average of the ranks that would have been assigned to
+    #     all the tied values is assigned to each value.
+    #   - 'min' : The minimum of the ranks that would have been assigned to all
+    #     the tied values is assigned to each value. (This is also referred to
+    #     as "competition" ranking.)
+    #   - 'max' : The maximum of the ranks that would have been assigned to all
+    #     the tied values is assigned to each value.
+    #   - 'dense' : Like 'min', but the rank of the next highest element is
+    #     assigned the rank immediately after those assigned to the tied
+    #     elements.
+    #   - 'random' : Choose a random rank for each value in a tie.
+    # @param seed [Integer]
+    #   Random seed used when `method: 'random'`. If set to nil (default), a
+    #   random seed is generated for each rolling rank operation.
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result.
+    # @param closed ['left', 'right', 'both', 'none']
+    #   Define which sides of the temporal interval are closed (inclusive),
+    #   defaults to `'right'`.
+    #
+    # @return [Series]
+    def rolling_rank_by(
+      by,
+      window_size,
+      method: "average",
+      seed: nil,
+      min_samples: 1,
+      closed: "right"
+    )
+      super
+    end
+
+    # Compute a rolling rank.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # A window of length `window_size` will traverse the array. The values
+    # that fill this window will be ranked according to the `method`
+    # parameter. The resulting values will be the rank of the value that is
+    # at the end of the sliding window.
+    #
+    # @param window_size [Integer]
+    #   Integer size of the rolling window.
+    # @param method ['average', 'min', 'max', 'dense', 'random']
+    #   The method used to assign ranks to tied elements.
+    #   The following methods are available (default is 'average'):
+    #
+    #   - 'average' : The average of the ranks that would have been assigned to
+    #     all the tied values is assigned to each value.
+    #   - 'min' : The minimum of the ranks that would have been assigned to all
+    #     the tied values is assigned to each value. (This is also referred to
+    #     as "competition" ranking.)
+    #   - 'max' : The maximum of the ranks that would have been assigned to all
+    #     the tied values is assigned to each value.
+    #   - 'dense' : Like 'min', but the rank of the next highest element is
+    #     assigned the rank immediately after those assigned to the tied
+    #     elements.
+    #   - 'random' : Choose a random rank for each value in a tie.
+    # @param seed [Integer]
+    #   Random seed used when `method: 'random'`. If set to nil (default), a
+    #   random seed is generated for each rolling rank operation.
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If set to `nil` (default), it will be set equal to `window_size`.
+    # @param center [Boolean]
+    #   Set the labels at the center of the window.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   Polars::Series.new([1, 4, 4, 1, 9]).rolling_rank(3, method: "average")
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: '' [f64]
+    #   # [
+    #   #         null
+    #   #         null
+    #   #         2.5
+    #   #         1.0
+    #   #         3.0
+    #   # ]
+    def rolling_rank(
+      window_size,
+      method: "average",
+      seed: nil,
+      min_samples: nil,
       center: false
     )
       super
@@ -3599,40 +5146,87 @@ module Polars
     #   Integer size of the rolling window.
     # @param bias [Boolean]
     #   If false, the calculations are corrected for statistical bias.
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If set to `nil` (default), it will be set equal to `window_size`.
+    # @param center [Boolean]
+    #   Set the labels at the center of the window.
     #
     # @return [Series]
     #
     # @example
-    #   s = Polars::Series.new("a", [1.0, 2.0, 3.0, 4.0, 6.0, 8.0])
-    #   s.rolling_skew(3)
+    #   Polars::Series.new([1, 4, 2, 9]).rolling_skew(3)
     #   # =>
-    #   # shape: (6,)
-    #   # Series: 'a' [f64]
+    #   # shape: (4,)
+    #   # Series: '' [f64]
     #   # [
     #   #         null
     #   #         null
-    #   #         0.0
-    #   #         0.0
     #   #         0.381802
-    #   #         0.0
+    #   #         0.47033
+    #   # ]
+    def rolling_skew(window_size, bias: true, min_samples: nil, center: false)
+      super
+    end
+
+    # Compute a rolling kurtosis.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # The window at a given row will include the row itself, and the `window_size - 1`
+    # elements before it.
+    #
+    # @param window_size [Integer]
+    #   Integer size of the rolling window.
+    # @param fisher [Boolean]
+    #   If true, Fisher's definition is used (normal ==> 0.0). If false,
+    #   Pearson's definition is used (normal ==> 3.0).
+    # @param bias [Boolean]
+    #   If false, the calculations are corrected for statistical bias.
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If set to `nil` (default), it will be set equal to `window_size`.
+    # @param center [Boolean]
+    #   Set the labels at the center of the window.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   Polars::Series.new([1, 4, 2, 9]).rolling_kurtosis(3)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [f64]
+    #   # [
+    #   #         null
+    #   #         null
+    #   #         -1.5
+    #   #         -1.5
     #   # ]
-    def rolling_skew(window_size, bias: true)
+    def rolling_kurtosis(
+      window_size,
+      fisher: true,
+      bias: true,
+      min_samples: nil,
+      center: false
+    )
       super
     end
 
     # Sample from this Series.
     #
     # @param n [Integer]
-    #   Number of items to return. Cannot be used with `frac`. Defaults to 1 if
-    #   `frac` is None.
-    # @param frac [Float]
+    #   Number of items to return. Cannot be used with `fraction`. Defaults to 1 if
+    #   `fraction` is nil.
+    # @param fraction [Float]
     #   Fraction of items to return. Cannot be used with `n`.
     # @param with_replacement [Boolean]
     #   Allow values to be sampled more than once.
     # @param shuffle [Boolean]
     #   Shuffle the order of sampled data points.
     # @param seed [Integer]
-    #   Seed for the random number generator. If set to None (default), a random
+    #   Seed for the random number generator. If set to nil (default), a random
     #   seed is used.
     #
     # @return [Series]
@@ -3644,28 +5238,17 @@ module Polars
     #   # shape: (2,)
     #   # Series: 'a' [i64]
     #   # [
+    #   #         2
     #   #         5
-    #   #         3
     #   # ]
     def sample(
       n: nil,
-      frac: nil,
+      fraction: nil,
       with_replacement: false,
       shuffle: false,
       seed: nil
     )
-      if !n.nil? && !frac.nil?
-        raise ArgumentError, "cannot specify both `n` and `frac`"
-      end
-
-      if n.nil? && !frac.nil?
-        return Utils.wrap_s(_s.sample_frac(frac, with_replacement, shuffle, seed))
-      end
-
-      if n.nil?
-        n = 1
-      end
-      Utils.wrap_s(_s.sample_n(n, with_replacement, shuffle, seed))
+      super
     end
 
     # Get a boolean mask of the local maximum peaks.
@@ -3741,7 +5324,7 @@ module Polars
 
     # Hash the Series.
     #
-    # The hash value is of type `:u64`.
+    # The hash value is of type `UInt64`.
     #
     # @param seed [Integer]
     #   Random seed parameter. Defaults to 0.
@@ -3756,7 +5339,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new("a", [1, 2, 3])
-    #   s._hash(42)
+    #   s.hash_(42)
     #   # =>
     #   # shape: (3,)
     #   # Series: 'a' [u64]
@@ -3765,17 +5348,22 @@ module Polars
     #   #         10386026231460783898
     #   #         17796317186427479491
     #   # ]
-    def _hash(seed = 0, seed_1 = nil, seed_2 = nil, seed_3 = nil)
+    def hash_(seed = 0, seed_1 = nil, seed_2 = nil, seed_3 = nil)
       super
     end
 
-    # Reinterpret the underlying bits as a signed/unsigned integer.
+    # Reinterpret the underlying bits as a signed/unsigned integer or float.
     #
-    # This operation is only allowed for 64bit integers. For lower bits integers,
-    # you can safely use that cast operation.
+    # This operation is only allowed for numeric types of the same size.
+    # For lower bits numbers, you can safely use the cast operation.
+    #
+    # Either `signed` or `dtype` can be specified.
     #
     # @param signed [Boolean]
-    #   If true, reinterpret as `:i64`. Otherwise, reinterpret as `:u64`.
+    #   If true, reinterpret as signed integer. Otherwise, reinterpret
+    #   as unsigned integer.
+    # @param dtype [Object]
+    #   DataType to reinterpret to.
     #
     # @return [Series]
     #
@@ -3790,7 +5378,18 @@ module Polars
     #   #         18446744073709551614
     #   #         3
     #   # ]
-    def reinterpret(signed: true)
+    #
+    # @example
+    #   s.reinterpret(dtype: Polars::Int64)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         -1152921504606846976
+    #   #         -2
+    #   #         3
+    #   # ]
+    def reinterpret(signed: nil, dtype: nil)
       super
     end
 
@@ -3815,6 +5414,30 @@ module Polars
       super
     end
 
+    # Fill null values using interpolation based on another column.
+    #
+    # @param by [Expr]
+    #   Column to interpolate values based on.
+    #
+    # @return [Series]
+    #
+    # @example Fill null values using linear interpolation.
+    #   s = Polars::Series.new("a", [1, nil, nil, 3])
+    #   by = Polars::Series.new("b", [1, 2, 7, 8])
+    #   s.interpolate_by(by)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         1.0
+    #   #         1.285714
+    #   #         2.714286
+    #   #         3.0
+    #   # ]
+    def interpolate_by(by)
+      super
+    end
+
     # Compute absolute values.
     #
     # @return [Series]
@@ -3854,7 +5477,7 @@ module Polars
     #     the order that the values occur in the Series.
     #   - 'random' : Like 'ordinal', but the rank for ties is not dependent
     #     on the order that the values occur in the Series.
-    # @param reverse [Boolean]
+    # @param descending [Boolean]
     #   Reverse the operation.
     # @param seed [Integer]
     #   If `method: "random"`, use this as seed.
@@ -3888,7 +5511,7 @@ module Polars
     #   #         2
     #   #         5
     #   # ]
-    def rank(method: "average", reverse: false, seed: nil)
+    def rank(method: "average", descending: false, seed: nil)
       super
     end
 
@@ -4041,22 +5664,21 @@ module Polars
     #
     # @example
     #   s.kurtosis(fisher: false, bias: false)
-    #   # => 2.1040361802642726
+    #   # => 2.1040361802642717
     def kurtosis(fisher: true, bias: true)
       _s.kurtosis(fisher, bias)
     end
 
-    # Clip (limit) the values in an array to a `min` and `max` boundary.
+    # Set values outside the given boundaries to the boundary value.
     #
-    # Only works for numerical types.
-    #
-    # If you want to clip other dtypes, consider writing a "when, then, otherwise"
-    # expression. See {#when} for more information.
-    #
-    # @param min_val [Numeric]
-    #   Minimum value.
-    # @param max_val [Numeric]
-    #   Maximum value.
+    # @param lower_bound [Numeric]
+    #   Lower bound. Accepts expression input.
+    #   Non-expression inputs are parsed as literals.
+    #   If set to `nil` (default), no lower bound is applied.
+    # @param upper_bound [Numeric]
+    #   Upper bound. Accepts expression input.
+    #   Non-expression inputs are parsed as literals.
+    #   If set to `nil` (default), no upper bound is applied.
     #
     # @return [Series]
     #
@@ -4072,47 +5694,71 @@ module Polars
     #   #         null
     #   #         10
     #   # ]
-    def clip(min_val = nil, max_val = nil)
+    def clip(lower_bound = nil, upper_bound = nil)
       super
     end
 
-    # Clip (limit) the values in an array to a `min` boundary.
+    # Return the lower bound of this Series' dtype as a unit Series.
     #
-    # Only works for numerical types.
-    #
-    # If you want to clip other dtypes, consider writing a "when, then, otherwise"
-    # expression. See {#when} for more information.
+    # @return [Series]
     #
-    # @param min_val [Numeric]
-    #   Minimum value.
+    # @example
+    #   s = Polars::Series.new("s", [-1, 0, 1], dtype: Polars::Int32)
+    #   s.lower_bound
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: 's' [i32]
+    #   # [
+    #   #         -2147483648
+    #   # ]
     #
-    # @return [Series]
-    def clip_min(min_val)
+    # @example
+    #   s = Polars::Series.new("s", [1.0, 2.5, 3.0], dtype: Polars::Float32)
+    #   s.lower_bound
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: 's' [f32]
+    #   # [
+    #   #         -inf
+    #   # ]
+    def lower_bound
       super
     end
 
-    # Clip (limit) the values in an array to a `max` boundary.
+    # Return the upper bound of this Series' dtype as a unit Series.
     #
-    # Only works for numerical types.
-    #
-    # If you want to clip other dtypes, consider writing a "when, then, otherwise"
-    # expression. See {#when} for more information.
+    # @return [Series]
     #
-    # @param max_val [Numeric]
-    #   Maximum value.
+    # @example
+    #   s = Polars::Series.new("s", [-1, 0, 1], dtype: Polars::Int8)
+    #   s.upper_bound
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: 's' [i8]
+    #   # [
+    #   #         127
+    #   # ]
     #
-    # @return [Series]
-    def clip_max(max_val)
+    # @example
+    #   s = Polars::Series.new("s", [1.0, 2.5, 3.0], dtype: Polars::Float64)
+    #   s.upper_bound
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: 's' [f64]
+    #   # [
+    #   #         inf
+    #   # ]
+    def upper_bound
       super
     end
 
     # Replace values by different values.
     #
     # @param old [Object]
-    #   Value or sequence of values to replace.
+    #   Value or array of values to replace.
     #   Also accepts a mapping of values to their replacement.
     # @param new [Object]
-    #   Value or sequence of values to replace by.
+    #   Value or array of values to replace by.
     #   Length must match the length of `old` or have length 1.
     # @param default [Object]
     #   Set values that were not replaced to this value.
@@ -4137,7 +5783,7 @@ module Polars
     #   #         3
     #   # ]
     #
-    # @example Replace multiple values by passing sequences to the `old` and `new` parameters.
+    # @example Replace multiple values by passing arrays to the `old` and `new` parameters.
     #   s.replace([2, 3], [100, 200])
     #   # =>
     #   # shape: (4,)
@@ -4174,20 +5820,134 @@ module Polars
     #   #         "2"
     #   #         "3"
     #   # ]
-    def replace(old, new = Expr::NO_DEFAULT, default: Expr::NO_DEFAULT, return_dtype: nil)
+    def replace(old, new = NO_DEFAULT, default: NO_DEFAULT, return_dtype: nil)
       super
     end
 
-    # Reshape this Series to a flat Series or a Series of Lists.
+    # Replace all values by different values.
     #
-    # @param dims [Array]
-    #   Tuple of the dimension sizes. If a -1 is used in any of the dimensions, that
-    #   dimension is inferred.
+    # @param old [Object]
+    #   Value or array of values to replace.
+    #   Also accepts a mapping of values to their replacement as syntactic sugar for
+    #   `replace_strict(old: Polars::Series.new(mapping.keys), new: Polars::Series.new(mapping.values))`.
+    # @param new [Object]
+    #   Value or array of values to replace by.
+    #   Length must match the length of `old` or have length 1.
+    # @param default [Object]
+    #   Set values that were not replaced to this value. If no default is specified,
+    #   (default), an error is raised if any values were not replaced.
+    #   Accepts expression input. Non-expression inputs are parsed as literals.
+    # @param return_dtype [Object]
+    #   The data type of the resulting Series. If set to `nil` (default),
+    #   the data type is determined automatically based on the other inputs.
     #
     # @return [Series]
     #
-    # @example
-    #   s = Polars::Series.new("foo", [1, 2, 3, 4, 5, 6, 7, 8, 9])
+    # @example Replace values by passing arrays to the `old` and `new` parameters.
+    #   s = Polars::Series.new([1, 2, 2, 3])
+    #   s.replace_strict([1, 2, 3], [100, 200, 300])
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [i64]
+    #   # [
+    #   #         100
+    #   #         200
+    #   #         200
+    #   #         300
+    #   # ]
+    #
+    # @example Passing a mapping with replacements is also supported as syntactic sugar.
+    #   mapping = {1 => 100, 2 => 200, 3 => 300}
+    #   s.replace_strict(mapping)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [i64]
+    #   # [
+    #   #         100
+    #   #         200
+    #   #         200
+    #   #         300
+    #   # ]
+    #
+    # @example By default, an error is raised if any non-null values were not replaced. Specify a default to set all values that were not matched.
+    #   mapping = {2 => 200, 3 => 300}
+    #   s.replace_strict(mapping, default: -1)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [i64]
+    #   # [
+    #   #         -1
+    #   #         200
+    #   #         200
+    #   #         300
+    #   # ]
+    #
+    # @example The default can be another Series.
+    #   default = Polars::Series.new([2.5, 5.0, 7.5, 10.0])
+    #   s.replace_strict(2, 200, default: default)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [f64]
+    #   # [
+    #   #         2.5
+    #   #         200.0
+    #   #         200.0
+    #   #         10.0
+    #   # ]
+    #
+    # @example Replacing by values of a different data type sets the return type based on a combination of the `new` data type and the `default` data type.
+    #   s = Polars::Series.new(["x", "y", "z"])
+    #   mapping = {"x" => 1, "y" => 2, "z" => 3}
+    #   s.replace_strict(mapping)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: '' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   # ]
+    #
+    # @example
+    #   s.replace_strict(mapping, default: "x")
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         "1"
+    #   #         "2"
+    #   #         "3"
+    #   # ]
+    #
+    # @example Set the `return_dtype` parameter to control the resulting data type directly.
+    #   s.replace_strict(mapping, return_dtype: Polars::UInt8)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: '' [u8]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   # ]
+    def replace_strict(
+      old,
+      new = NO_DEFAULT,
+      default: NO_DEFAULT,
+      return_dtype: nil
+    )
+      super
+    end
+
+    # Reshape this Series to a flat Series or a Series of Lists.
+    #
+    # @param dimensions [Array]
+    #   Tuple of the dimension sizes. If a -1 is used in any of the dimensions, that
+    #   dimension is inferred.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("foo", [1, 2, 3, 4, 5, 6, 7, 8, 9])
     #   square = s.reshape([3, 3])
     #   # =>
     #   # shape: (3,)
@@ -4214,8 +5974,8 @@ module Polars
     #   #         8
     #   #         9
     #   # ]
-    def reshape(dims)
-      super
+    def reshape(dimensions)
+      self.class._from_rbseries(_s.reshape(dimensions))
     end
 
     # Shuffle the contents of this Series.
@@ -4233,8 +5993,8 @@ module Polars
     #   # Series: 'a' [i64]
     #   # [
     #   #         2
-    #   #         1
     #   #         3
+    #   #         1
     #   # ]
     def shuffle(seed: nil)
       super
@@ -4261,8 +6021,70 @@ module Polars
       half_life: nil,
       alpha: nil,
       adjust: true,
-      min_periods: 1,
-      ignore_nulls: true
+      min_samples: 1,
+      ignore_nulls: false
+    )
+      super
+    end
+
+    # Compute time-based exponentially weighted moving average.
+    #
+    # @param by [Object]
+    #   Times to calculate average by. Should be `DateTime`, `Date`, `UInt64`,
+    #   `UInt32`, `Int64`, or `Int32` data type.
+    # @param half_life [String]
+    #   Unit over which observation decays to half its value.
+    #
+    #   Can be created either from a timedelta, or
+    #   by using the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 day)
+    #   - 1w    (1 week)
+    #   - 1i    (1 index count)
+    #
+    #   Or combine them:
+    #   "3d12h4m25s" # 3 days, 12 hours, 4 minutes, and 25 seconds
+    #
+    #   Note that `half_life` is treated as a constant duration - calendar
+    #   durations such as months (or even days in the time-zone-aware case)
+    #   are not supported, please express your duration in an approximately
+    #   equivalent number of hours (e.g. '370h' instead of '1mo').
+    #
+    # @return [Series]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "values" => [0, 1, 2, nil, 4],
+    #       "times" => [
+    #         Date.new(2020, 1, 1),
+    #         Date.new(2020, 1, 3),
+    #         Date.new(2020, 1, 10),
+    #         Date.new(2020, 1, 15),
+    #         Date.new(2020, 1, 17)
+    #       ]
+    #     }
+    #   ).sort("times")
+    #   df["values"].ewm_mean_by(df["times"], half_life: "4d")
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'values' [f64]
+    #   # [
+    #   #         0.0
+    #   #         0.292893
+    #   #         1.492474
+    #   #         null
+    #   #         3.254508
+    #   # ]
+    def ewm_mean_by(
+      by,
+      half_life:
     )
       super
     end
@@ -4289,8 +6111,8 @@ module Polars
       alpha: nil,
       adjust: true,
       bias: false,
-      min_periods: 1,
-      ignore_nulls: true
+      min_samples: 1,
+      ignore_nulls: false
     )
       super
     end
@@ -4317,8 +6139,8 @@ module Polars
       alpha: nil,
       adjust: true,
       bias: false,
-      min_periods: 1,
-      ignore_nulls: true
+      min_samples: 1,
+      ignore_nulls: false
     )
       super
     end
@@ -4347,14 +6169,14 @@ module Polars
     #   #         99
     #   # ]
     def extend_constant(value, n)
-      Utils.wrap_s(_s.extend_constant(value, n))
+      super
     end
 
     # Flags the Series as sorted.
     #
     # Enables downstream code to user fast paths for sorted arrays.
     #
-    # @param reverse [Boolean]
+    # @param descending [Boolean]
     #   If the Series order is reversed, e.g. descending.
     #
     # @return [Series]
@@ -4367,8 +6189,8 @@ module Polars
     #   s = Polars::Series.new("a", [1, 2, 3])
     #   s.set_sorted.max
     #   # => 3
-    def set_sorted(reverse: false)
-      Utils.wrap_s(_s.set_sorted(reverse))
+    def set_sorted(descending: false)
+      Utils.wrap_s(_s.set_sorted(descending))
     end
 
     # Create a new Series filled with values from the given index.
@@ -4412,9 +6234,153 @@ module Polars
     #   #         6
     #   # ]
     def shrink_dtype
+      Utils.wrap_s(_s.shrink_dtype)
+    end
+
+    # Get the chunks of this Series as a list of Series.
+    #
+    # @return [Array]
+    #
+    # @example
+    #   s1 = Polars::Series.new("a", [1, 2, 3])
+    #   s2 = Polars::Series.new("a", [4, 5, 6])
+    #   s = Polars.concat([s1, s2], rechunk: false)
+    #   s.get_chunks
+    #   # =>
+    #   # [shape: (3,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   # ], shape: (3,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         4
+    #   #         5
+    #   #         6
+    #   # ]]
+    def get_chunks
+      _s.get_chunks
+    end
+
+    # Aggregate values into a list.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3])
+    #   s.implode
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: 'a' [list[i64]]
+    #   # [
+    #   #         [1, 2, 3]
+    #   # ]
+    def implode
+      super
+    end
+
+    # Evaluate the number of set bits.
+    #
+    # @return [Series]
+    def bitwise_count_ones
+      super
+    end
+
+    # Evaluate the number of unset bits.
+    #
+    # @return [Series]
+    def bitwise_count_zeros
+      super
+    end
+
+    # Evaluate the number most-significant set bits before seeing an unset bit.
+    #
+    # @return [Series]
+    def bitwise_leading_ones
       super
     end
 
+    # Evaluate the number most-significant unset bits before seeing a set bit.
+    #
+    # @return [Series]
+    def bitwise_leading_zeros
+      super
+    end
+
+    # Evaluate the number least-significant set bits before seeing an unset bit.
+    #
+    # @return [Series]
+    def bitwise_trailing_ones
+      super
+    end
+
+    # Evaluate the number least-significant unset bits before seeing a set bit.
+    #
+    # @return [Series]
+    def bitwise_trailing_zeros
+      super
+    end
+
+    # Perform an aggregation of bitwise ANDs.
+    #
+    # @return [Object]
+    def bitwise_and
+      _s.bitwise_and
+    end
+
+    # Perform an aggregation of bitwise ORs.
+    #
+    # @return [Object]
+    def bitwise_or
+      _s.bitwise_or
+    end
+
+    # Perform an aggregation of bitwise XORs.
+    #
+    # @return [Object]
+    def bitwise_xor
+      _s.bitwise_xor
+    end
+
+    # Get the first element of the Series.
+    #
+    # Returns `nil` if the Series is empty.
+    #
+    # @param ignore_nulls [Boolean]
+    #   Ignore null values (default `false`).
+    #   If set to `true`, the first non-null value is returned, otherwise `nil` is
+    #   returned if no non-null value exists.
+    #
+    # @return [Object]
+    def first(ignore_nulls: false)
+      _s.first(ignore_nulls)
+    end
+
+    # Get the last element of the Series.
+    #
+    # Returns `nil` if the Series is empty.
+    #
+    # @param ignore_nulls [Boolean]
+    #   Ignore null values (default `false`).
+    #   If set to `true`, the last non-null value is returned, otherwise `nil` is
+    #   returned if no non-null value exists.
+    #
+    # @return [Object]
+    def last(ignore_nulls: false)
+      _s.last(ignore_nulls)
+    end
+
+    # Approximate count of unique values.
+    #
+    # This is done using the HyperLogLog++ algorithm for cardinality estimation.
+    #
+    # @return [Object]
+    def approx_n_unique
+      _s.approx_n_unique
+    end
+
     # Create an object namespace of all list related methods.
     #
     # @return [ListNameSpace]
@@ -4464,6 +6430,42 @@ module Polars
       StructNameSpace.new(self)
     end
 
+    # Create an object namespace of all extension type related methods.
+    #
+    # @return [ExtensionNameSpace]
+    def ext
+      ExtensionNameSpace.new(self)
+    end
+
+    # Create a plot namespace.
+    #
+    # @note
+    #   This functionality is currently considered **unstable**. It may be
+    #   changed at any point without it being considered a breaking change.
+    #
+    # @return [SeriesPlot]
+    #
+    # @example Histogram:
+    #   s = Polars::Series.new([1, 4, 4, 6, 2, 4, 3, 5, 5, 7, 1])
+    #   s.plot.hist
+    def plot
+      SeriesPlot.new(self)
+    end
+
+    # Repeat the elements in this Series as specified in the given expression.
+    #
+    # The repeated elements are expanded into a List.
+    #
+    # @param by [Object]
+    #   Numeric column that determines how often the values will be repeated.
+    #   The column will be coerced to UInt32. Give this dtype to make the coercion
+    #   a no-op.
+    #
+    # @return [Object]
+    def repeat_by(by)
+      super
+    end
+
     private
 
     def initialize_copy(other)
@@ -4547,12 +6549,12 @@ module Polars
         ts = Utils.datetime_to_int(other, time_unit)
         f = ffi_func("#{op}_<>", Int64, _s)
         fail if f.nil?
-        return Utils.wrap_s(f.call(ts))
+        return Utils.wrap_s(f.(ts))
       elsif other.is_a?(::Date) && dtype == Date
         d = Utils.date_to_int(other)
         f = ffi_func("#{op}_<>", Int32, _s)
         fail if f.nil?
-        return Utils.wrap_s(f.call(d))
+        return Utils.wrap_s(f.(d))
       end
 
       if other.is_a?(Series)
@@ -4563,7 +6565,7 @@ module Polars
       if f.nil?
         raise NotImplementedError
       end
-      Utils.wrap_s(f.call(other))
+      Utils.wrap_s(f.(other))
     end
 
     def ffi_func(name, dtype, _s)
@@ -4578,8 +6580,8 @@ module Polars
         return Utils.wrap_s(_s.send(op, other._s))
       end
 
-      if (other.is_a?(Float) || other.is_a?(::Date) || other.is_a?(::DateTime) || other.is_a?(::Time) || other.is_a?(::String)) && !is_float
-        _s2 = sequence_to_rbseries(name, [other])
+      if (other.is_a?(Float) || other.is_a?(::Date) || other.is_a?(::DateTime) || other.is_a?(::Time) || other.is_a?(::String)) && !dtype.float?
+        _s2 = Utils.sequence_to_rbseries(name, [other])
         return Utils.wrap_s(_s.send(op, _s2))
       end
 
@@ -4587,7 +6589,7 @@ module Polars
       if f.nil?
         raise ArgumentError, "cannot do arithmetic with series of dtype: #{dtype} and argument of type: #{other.class.name}"
       end
-      Utils.wrap_s(f.call(other))
+      Utils.wrap_s(f.(other))
     end
 
     DTYPE_TO_FFINAME = {
@@ -4595,10 +6597,13 @@ module Polars
       Int16 => "i16",
       Int32 => "i32",
       Int64 => "i64",
+      Int128 => "i128",
       UInt8 => "u8",
       UInt16 => "u16",
       UInt32 => "u32",
       UInt64 => "u64",
+      UInt128 => "u128",
+      Float16 => "f16",
       Float32 => "f32",
       Float64 => "f64",
       Boolean => "bool",
@@ -4613,262 +6618,5 @@ module Polars
       Struct => "struct",
       Binary => "binary"
     }
-
-    def series_to_rbseries(name, values)
-      # should not be in-place?
-      values.rename(name, in_place: true)
-      values._s
-    end
-
-    def numo_to_rbseries(name, values, strict: true, nan_to_null: false)
-      # not needed yet
-      # if !values.contiguous?
-      # end
-
-      if values.shape.length == 1
-        values, dtype = numo_values_and_dtype(values)
-        strict = nan_to_null if [Numo::SFloat, Numo::DFloat].include?(dtype)
-        if dtype == Numo::RObject
-          sequence_to_rbseries(name, values.to_a, strict: strict)
-        else
-          constructor = numo_type_to_constructor(dtype)
-          # TODO improve performance
-          constructor.call(name, values.to_a, strict)
-        end
-      elsif values.shape.sum == 0
-        raise Todo
-      else
-        original_shape = values.shape
-        values = values.reshape(original_shape.inject(&:*))
-        rb_s = numo_to_rbseries(
-          name,
-          values,
-          strict: strict,
-          nan_to_null: nan_to_null
-        )
-        Utils.wrap_s(rb_s).reshape(original_shape)._s
-      end
-    end
-
-    def numo_values_and_dtype(values)
-      [values, values.class]
-    end
-
-    def numo_type_to_constructor(dtype)
-      {
-        Numo::Float32 => RbSeries.method(:new_opt_f32),
-        Numo::Float64 => RbSeries.method(:new_opt_f64),
-        Numo::Int8 => RbSeries.method(:new_opt_i8),
-        Numo::Int16 => RbSeries.method(:new_opt_i16),
-        Numo::Int32 => RbSeries.method(:new_opt_i32),
-        Numo::Int64 => RbSeries.method(:new_opt_i64),
-        Numo::UInt8 => RbSeries.method(:new_opt_u8),
-        Numo::UInt16 => RbSeries.method(:new_opt_u16),
-        Numo::UInt32 => RbSeries.method(:new_opt_u32),
-        Numo::UInt64 => RbSeries.method(:new_opt_u64)
-      }.fetch(dtype)
-    rescue KeyError
-      RbSeries.method(:new_object)
-    end
-
-    def sequence_to_rbseries(name, values, dtype: nil, strict: true, dtype_if_empty: nil)
-      ruby_dtype = nil
-
-      if (values.nil? || values.empty?) && dtype.nil?
-        dtype = dtype_if_empty || Float32
-      elsif dtype == List
-        ruby_dtype = ::Array
-      end
-
-      rb_temporal_types = [::Date, ::DateTime, ::Time]
-      rb_temporal_types << ActiveSupport::TimeWithZone if defined?(ActiveSupport::TimeWithZone)
-
-      value = _get_first_non_none(values)
-      if !value.nil?
-        if value.is_a?(Hash)
-          return DataFrame.new(values).to_struct(name)._s
-        end
-      end
-
-      if !dtype.nil? && ![List, Struct, Unknown].include?(dtype) && Utils.is_polars_dtype(dtype) && ruby_dtype.nil?
-        if dtype == Array && !dtype.is_a?(Array) && value.is_a?(::Array)
-          dtype = Array.new(nil, value.size)
-        end
-
-        constructor = polars_type_to_constructor(dtype)
-        rbseries = constructor.call(name, values, strict)
-
-        base_type = dtype.is_a?(DataType) ? dtype.class : dtype
-        if [Date, Datetime, Duration, Time, Categorical, Boolean, Enum, Decimal].include?(base_type)
-          if rbseries.dtype != dtype
-            rbseries = rbseries.cast(dtype, true)
-          end
-        end
-        rbseries
-      elsif dtype == Struct
-        struct_schema = dtype.is_a?(Struct) ? dtype.to_schema : nil
-        empty = {}
-        DataFrame.sequence_to_rbdf(
-          values.map { |v| v.nil? ? empty : v },
-          schema: struct_schema,
-          orient: "row",
-        ).to_struct(name)
-      else
-        if ruby_dtype.nil?
-          if value.nil?
-            # generic default dtype
-            ruby_dtype = Float
-          else
-            ruby_dtype = value.class
-          end
-        end
-
-        # temporal branch
-        if rb_temporal_types.include?(ruby_dtype)
-          if dtype.nil?
-            dtype = Utils.rb_type_to_dtype(ruby_dtype)
-          elsif rb_temporal_types.include?(dtype)
-            dtype = Utils.rb_type_to_dtype(dtype)
-          end
-          # TODO
-          time_unit = nil
-
-          rb_series = RbSeries.new_from_any_values(name, values, strict)
-          if time_unit.nil?
-            s = Utils.wrap_s(rb_series)
-          else
-            s = Utils.wrap_s(rb_series).dt.cast_time_unit(time_unit)
-          end
-          s._s
-        elsif defined?(Numo::NArray) && value.is_a?(Numo::NArray) && value.shape.length == 1
-          raise Todo
-        elsif ruby_dtype == ::Array
-          if dtype.is_a?(Object)
-            return RbSeries.new_object(name, values, strict)
-          end
-          if dtype
-            srs = sequence_from_anyvalue_or_object(name, values)
-            if dtype != srs.dtype
-              srs = srs.cast(dtype, strict: false)
-            end
-            return srs
-          end
-          sequence_from_anyvalue_or_object(name, values)
-        elsif ruby_dtype == Series
-          RbSeries.new_series_list(name, values.map(&:_s), strict)
-        elsif ruby_dtype == RbSeries
-          RbSeries.new_series_list(name, values, strict)
-        else
-          constructor =
-            if value.is_a?(::String)
-              if value.encoding == Encoding::UTF_8
-                RbSeries.method(:new_str)
-              else
-                RbSeries.method(:new_binary)
-              end
-            elsif value.is_a?(Integer) && values.any? { |v| v.is_a?(Float) }
-              # TODO improve performance
-              RbSeries.method(:new_opt_f64)
-            else
-              rb_type_to_constructor(value.class)
-            end
-
-          construct_series_with_fallbacks(constructor, name, values, dtype, strict: strict)
-        end
-      end
-    end
-
-    def construct_series_with_fallbacks(constructor, name, values, dtype, strict:)
-      begin
-        constructor.call(name, values, strict)
-      rescue
-        if dtype.nil?
-          RbSeries.new_from_any_values(name, values, strict)
-        else
-          RbSeries.new_from_any_values_and_dtype(name, values, dtype, strict)
-        end
-      end
-    end
-
-    def sequence_from_anyvalue_or_object(name, values)
-      RbSeries.new_from_any_values(name, values, true)
-    rescue
-      RbSeries.new_object(name, values, false)
-    end
-
-    POLARS_TYPE_TO_CONSTRUCTOR = {
-      Float32 => RbSeries.method(:new_opt_f32),
-      Float64 => RbSeries.method(:new_opt_f64),
-      Int8 => RbSeries.method(:new_opt_i8),
-      Int16 => RbSeries.method(:new_opt_i16),
-      Int32 => RbSeries.method(:new_opt_i32),
-      Int64 => RbSeries.method(:new_opt_i64),
-      UInt8 => RbSeries.method(:new_opt_u8),
-      UInt16 => RbSeries.method(:new_opt_u16),
-      UInt32 => RbSeries.method(:new_opt_u32),
-      UInt64 => RbSeries.method(:new_opt_u64),
-      Decimal => RbSeries.method(:new_decimal),
-      Date => RbSeries.method(:new_from_any_values),
-      Datetime => RbSeries.method(:new_from_any_values),
-      Duration => RbSeries.method(:new_from_any_values),
-      Time => RbSeries.method(:new_from_any_values),
-      Boolean => RbSeries.method(:new_opt_bool),
-      Utf8 => RbSeries.method(:new_str),
-      Object => RbSeries.method(:new_object),
-      Categorical => RbSeries.method(:new_str),
-      Enum => RbSeries.method(:new_str),
-      Binary => RbSeries.method(:new_binary),
-      Null => RbSeries.method(:new_null)
-    }
-
-    SYM_TYPE_TO_CONSTRUCTOR = {
-      f32: RbSeries.method(:new_opt_f32),
-      f64: RbSeries.method(:new_opt_f64),
-      i8: RbSeries.method(:new_opt_i8),
-      i16: RbSeries.method(:new_opt_i16),
-      i32: RbSeries.method(:new_opt_i32),
-      i64: RbSeries.method(:new_opt_i64),
-      u8: RbSeries.method(:new_opt_u8),
-      u16: RbSeries.method(:new_opt_u16),
-      u32: RbSeries.method(:new_opt_u32),
-      u64: RbSeries.method(:new_opt_u64),
-      bool: RbSeries.method(:new_opt_bool),
-      str: RbSeries.method(:new_str)
-    }
-
-    def polars_type_to_constructor(dtype)
-      if dtype.is_a?(Array)
-        lambda do |name, values, strict|
-          RbSeries.new_array(dtype.width, dtype.inner, name, values, strict)
-        end
-      elsif dtype.is_a?(Class) && dtype < DataType
-        POLARS_TYPE_TO_CONSTRUCTOR.fetch(dtype)
-      elsif dtype.is_a?(DataType)
-        POLARS_TYPE_TO_CONSTRUCTOR.fetch(dtype.class)
-      else
-        SYM_TYPE_TO_CONSTRUCTOR.fetch(dtype.to_sym)
-      end
-    rescue KeyError
-      raise ArgumentError, "Cannot construct RbSeries for type #{dtype}."
-    end
-
-    RB_TYPE_TO_CONSTRUCTOR = {
-      Float => RbSeries.method(:new_opt_f64),
-      Integer => RbSeries.method(:new_opt_i64),
-      TrueClass => RbSeries.method(:new_opt_bool),
-      FalseClass => RbSeries.method(:new_opt_bool),
-      BigDecimal => RbSeries.method(:new_decimal),
-      NilClass => RbSeries.method(:new_null)
-    }
-
-    def rb_type_to_constructor(dtype)
-      RB_TYPE_TO_CONSTRUCTOR.fetch(dtype)
-    rescue KeyError
-      RbSeries.method(:new_object)
-    end
-
-    def _get_first_non_none(values)
-      values.find { |v| !v.nil? }
-    end
   end
 end