polars-df 0.23.0 → 0.24.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
 
@@ -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
@@ -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?
@@ -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)
@@ -548,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")
@@ -613,7 +613,7 @@ module Polars
     #   # => false
     def any?(ignore_nulls: true, &block)
       if block_given?
-        apply(return_dtype: Boolean, skip_nulls: ignore_nulls, &block).any?
+        map_elements(return_dtype: Boolean, skip_nulls: ignore_nulls, &block).any?
       else
         _s.any(ignore_nulls)
       end
@@ -637,7 +637,7 @@ module Polars
     #   # => true
     def all?(ignore_nulls: true, &block)
       if block_given?
-        apply(return_dtype: Boolean, skip_nulls: ignore_nulls, &block).all?
+        map_elements(return_dtype: Boolean, skip_nulls: ignore_nulls, &block).all?
       else
         _s.all(ignore_nulls)
       end
@@ -661,7 +661,7 @@ module Polars
     #   # => true
     def none?(&block)
       if block_given?
-        apply(return_dtype: Boolean, &block).none?
+        map_elements(return_dtype: Boolean, &block).none?
       else
         to_frame.select(Polars.col(name).is_not.all).to_series[0]
       end
@@ -827,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.
@@ -909,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])
@@ -1053,7 +1032,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]
@@ -1073,7 +1052,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]
@@ -1490,7 +1469,13 @@ 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: nil)
+      # TODO update
+      if normalize.nil?
+        warn "The default `normalize` for `entropy` method will change from `false` to `true` in a future version"
+        normalize = false
+      end
+
       Polars.select(Polars.lit(self).entropy(base: base, normalize: normalize)).to_series[0]
     end
 
@@ -1498,7 +1483,7 @@ 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`
     #
@@ -1525,7 +1510,7 @@ module Polars
     #   #         -15
     #   #         -24
     #   # ]
-    def cumulative_eval(expr, min_periods: 1)
+    def cumulative_eval(expr, min_samples: 1)
       super
     end
 
@@ -1537,8 +1522,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)
@@ -1549,21 +1542,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.
@@ -1575,7 +1569,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
@@ -1594,7 +1588,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
@@ -1612,8 +1606,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])
@@ -1629,7 +1623,6 @@ 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.
     #
@@ -1675,7 +1668,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.
     #
@@ -1698,7 +1690,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.
     #
@@ -1708,8 +1699,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])
@@ -1725,7 +1716,6 @@ module Polars
     def cum_prod(reverse: false)
       super
     end
-    alias_method :cumprod, :cum_prod
 
     # Get a slice of this Series.
     #
@@ -1755,29 +1745,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]
     #
@@ -1796,20 +1763,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
 
@@ -1856,7 +1863,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.
@@ -1877,7 +1887,10 @@ 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
 
     # Get the first `n` rows.
@@ -1900,7 +1913,7 @@ module Polars
     #   #         2
     #   # ]
     def limit(n = 10)
-      to_frame.select(F.col(name).limit(n)).to_series
+      head(n)
     end
 
     # Take every nth value in the Series and return as new Series.
@@ -1935,11 +1948,10 @@ module Polars
     def gather_every(n, offset = 0)
       super
     end
-    alias_method :take_every, :gather_every
 
     # Sort this Series.
     #
-    # @param reverse [Boolean]
+    # @param descending [Boolean]
     #   Reverse sort.
     # @param nulls_last [Boolean]
     #   Place null values last instead of first.
@@ -1962,7 +1974,7 @@ module Polars
     #   #         3
     #   #         4
     #   # ]
-    #   s.sort(reverse: true)
+    #   s.sort(descending: true)
     #   # =>
     #   # shape: (4,)
     #   # Series: 'a' [i64]
@@ -1972,12 +1984,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
 
@@ -2017,7 +2029,7 @@ module Polars
     #   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 a sequence of
+    #   largest). This can be specified per column by passing an array of
     #   booleans.
     #
     # @return [Series]
@@ -2077,7 +2089,7 @@ module Polars
     #   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 a sequence of
+    #   smallest). This can be specified per column by passing an array of
     #   booleans.
     #
     # @return [Series]
@@ -2103,7 +2115,7 @@ module Polars
 
     # 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.
@@ -2123,10 +2135,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.
     #
@@ -2281,7 +2292,6 @@ module Polars
     def gather(indices)
       super
     end
-    alias_method :take, :gather
 
     # Count the null values in this Series.
     #
@@ -2313,7 +2323,6 @@ module Polars
     def has_nulls
       _s.has_nulls
     end
-    alias_method :has_validity, :has_nulls
 
     # Check if the Series is empty.
     #
@@ -2613,8 +2622,6 @@ 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.
     #
@@ -2685,7 +2692,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.
@@ -2701,10 +2708,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.
     #
@@ -2734,16 +2740,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]
@@ -2752,24 +2761,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]
@@ -2840,7 +2843,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,)
@@ -2869,7 +2872,7 @@ module Polars
     #
     # @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.
+    #   then the result will be false, as no value can satisfy the condition.
     #
     # @example
     #   s = Polars::Series.new("num", [1, 2, 3, 4, 5])
@@ -2962,7 +2965,7 @@ module Polars
     def is_close(
       other,
       abs_tol: 0.0,
-      rel_tol: 1e-09,
+      rel_tol: 1.0e-09,
       nans_equal: false
     )
       F.select(
@@ -2972,75 +2975,6 @@ module Polars
       ).to_series
     end
 
-    # Check if this Series datatype is numeric.
-    #
-    # @return [Boolean]
-    #
-    # @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 [Boolean]
-    #
-    # @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.
-    #
-    # @return [Boolean]
-    #
-    # @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
-
-    # 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
-    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.
-    #
-    # @return [Boolean]
-    #
-    # @example
-    #   s = Polars::Series.new("x", ["a", "b", "c"])
-    #   s.is_utf8
-    #   # => true
-    def is_utf8
-      dtype == String
-    end
-    alias_method :utf8?, :is_utf8
-
     # def view
     # end
 
@@ -3055,7 +2989,7 @@ module Polars
     #   # Numo::Int64#shape=[3]
     #   # [1, 2, 3]
     def to_numo
-      if is_datelike
+      if dtype.temporal?
         Numo::RObject.cast(to_a)
       else
         _s.to_numo
@@ -3093,16 +3027,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]
@@ -3111,29 +3045,28 @@ 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.
     #
@@ -3197,13 +3130,12 @@ module Polars
       s = len > 0 ? self.class.new(name, [], dtype: dtype) : clone
       n > 0 ? s.extend_constant(nil, n) : s
     end
-    alias_method :cleared, :clear
 
     # clone handled by initialize_copy
 
     # Fill floating point NaN value with a fill value.
     #
-    # @param fill_value [Object]
+    # @param value [Object]
     #   Value used to fill nan values.
     #
     # @return [Series]
@@ -3220,7 +3152,7 @@ module Polars
     #   #         3.0
     #   #         0.0
     #   # ]
-    def fill_nan(fill_value)
+    def fill_nan(value)
       super
     end
 
@@ -3344,8 +3276,12 @@ module Polars
 
     # 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]
     #
@@ -3360,7 +3296,7 @@ module Polars
     #   #         2.57
     #   #         3.9
     #   # ]
-    def round(decimals = 0)
+    def round(decimals = 0, mode: "half_to_even")
       super
     end
 
@@ -3543,7 +3479,6 @@ module Polars
     def arcsin
       super
     end
-    alias_method :asin, :arcsin
 
     # Compute the element-wise value for the inverse cosine.
     #
@@ -3563,7 +3498,6 @@ module Polars
     def arccos
       super
     end
-    alias_method :acos, :arccos
 
     # Compute the element-wise value for the inverse tangent.
     #
@@ -3583,7 +3517,6 @@ module Polars
     def arctan
       super
     end
-    alias_method :atan, :arctan
 
     # Compute the element-wise value for the inverse hyperbolic sine.
     #
@@ -3603,7 +3536,6 @@ module Polars
     def arcsinh
       super
     end
-    alias_method :asinh, :arcsinh
 
     # Compute the element-wise value for the inverse hyperbolic cosine.
     #
@@ -3624,7 +3556,6 @@ module Polars
     def arccosh
       super
     end
-    alias_method :acosh, :arccosh
 
     # Compute the element-wise value for the inverse hyperbolic tangent.
     #
@@ -3648,7 +3579,6 @@ module Polars
     def arctanh
       super
     end
-    alias_method :atanh, :arctanh
 
     # Compute the element-wise value for the hyperbolic sine.
     #
@@ -3734,21 +3664,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.map_elements(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]
     #
@@ -3774,19 +3706,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 nil 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
 
@@ -3834,6 +3754,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
@@ -3845,7 +3849,7 @@ 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 nil, it will be set equal to window size.
     # @param center [Boolean]
@@ -3869,12 +3873,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
@@ -3886,7 +3974,7 @@ 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 nil, it will be set equal to window size.
     # @param center [Boolean]
@@ -3910,35 +3998,119 @@ module Polars
     def rolling_max(
       window_size,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
       center: false
     )
       super
     end
 
-    # Apply a rolling mean (moving mean) over the values in this array.
+    # Compute a rolling mean based on another series.
     #
-    # A window of length `window_size` will traverse the array. The values that fill
-    # this window will (optionally) be multiplied with the weights given by the
-    # `weight` vector. The resulting values will be aggregated to their sum.
+    # @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.
-    # @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]
-    #   The number of values in the window that should be non-null before computing
-    #   a result. If nil, it will be set equal to window size.
-    # @param center [Boolean]
-    #   Set the labels at the center of the window
+    # Given a `by` column `<t_0, t_1, ..., t_n>`, then `closed: "right"`
+    # (the default) means the windows will be:
     #
-    # @return [Series]
+    #   - (t_0 - window_size, t_0]
+    #   - (t_1 - window_size, t_1]
+    #   - ...
+    #   - (t_n - window_size, t_n]
     #
-    # @example
-    #   s = Polars::Series.new("a", [100, 200, 300, 400, 500])
-    #   s.rolling_mean(2)
-    #   # =>
+    # @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
+    # this window will (optionally) be multiplied with the weights given by the
+    # `weight` vector. The resulting values will be aggregated to their sum.
+    #
+    # @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_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If nil, 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", [100, 200, 300, 400, 500])
+    #   s.rolling_mean(2)
+    #   # =>
     #   # shape: (5,)
     #   # Series: 'a' [f64]
     #   # [
@@ -3951,12 +4123,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: 1,
+      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
@@ -3968,7 +4224,7 @@ 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 nil, it will be set equal to window size.
     # @param center [Boolean]
@@ -3992,12 +4248,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
@@ -4009,7 +4352,7 @@ 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 nil, it will be set equal to window size.
     # @param center [Boolean]
@@ -4036,13 +4379,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
@@ -4054,7 +4484,7 @@ 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 nil, it will be set equal to window size.
     # @param center [Boolean]
@@ -4081,7 +4511,7 @@ module Polars
     def rolling_var(
       window_size,
       weights: nil,
-      min_periods: nil,
+      min_samples: nil,
       center: false,
       ddof: 1
     )
@@ -4091,6 +4521,90 @@ module Polars
     # def rolling_apply
     # 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]
@@ -4098,7 +4612,7 @@ 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 nil, it will be set equal to window size.
     # @param center [Boolean]
@@ -4123,12 +4637,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]
@@ -4140,7 +4744,7 @@ 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 nil, it will be set equal to window size.
     # @param center [Boolean]
@@ -4181,7 +4785,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
@@ -4264,9 +5005,9 @@ module Polars
     # Sample from this Series.
     #
     # @param n [Integer]
-    #   Number of items to return. Cannot be used with `frac`. Defaults to 1 if
-    #   `frac` is nil.
-    # @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.
@@ -4290,23 +5031,12 @@ module Polars
     #   # ]
     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.
@@ -4382,7 +5112,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.
@@ -4397,7 +5127,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new("a", [1, 2, 3])
-    #   s._hash(42)
+    #   s.hash_(42)
     #   # =>
     #   # shape: (3,)
     #   # Series: 'a' [u64]
@@ -4406,7 +5136,7 @@ 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
 
@@ -4416,7 +5146,7 @@ module Polars
     # you can safely use that cast operation.
     #
     # @param signed [Boolean]
-    #   If true, reinterpret as `:i64`. Otherwise, reinterpret as `:u64`.
+    #   If true, reinterpret as `Polars::Int64`. Otherwise, reinterpret as `Polars::UInt64`.
     #
     # @return [Series]
     #
@@ -4519,7 +5249,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.
@@ -4553,7 +5283,7 @@ module Polars
     #   #         2
     #   #         5
     #   # ]
-    def rank(method: "average", reverse: false, seed: nil)
+    def rank(method: "average", descending: false, seed: nil)
       super
     end
 
@@ -4711,17 +5441,16 @@ module Polars
       _s.kurtosis(fisher, bias)
     end
 
-    # Clip (limit) the values in an array to a `min` and `max` boundary.
-    #
-    # Only works for numerical types.
+    # Set values outside the given boundaries to the boundary value.
     #
-    # If you want to clip other dtypes, consider writing a "when, then, otherwise"
-    # expression. See {#when} for more information.
-    #
-    # @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]
     #
@@ -4737,37 +5466,7 @@ module Polars
     #   #         null
     #   #         10
     #   # ]
-    def clip(min_val = nil, max_val = nil)
-      super
-    end
-
-    # Clip (limit) the values in an array to a `min` boundary.
-    #
-    # Only works for numerical types.
-    #
-    # If you want to clip other dtypes, consider writing a "when, then, otherwise"
-    # expression. See {#when} for more information.
-    #
-    # @param min_val [Numeric]
-    #   Minimum value.
-    #
-    # @return [Series]
-    def clip_min(min_val)
-      super
-    end
-
-    # Clip (limit) the values in an array to a `max` boundary.
-    #
-    # Only works for numerical types.
-    #
-    # If you want to clip other dtypes, consider writing a "when, then, otherwise"
-    # expression. See {#when} for more information.
-    #
-    # @param max_val [Numeric]
-    #   Maximum value.
-    #
-    # @return [Series]
-    def clip_max(max_val)
+    def clip(lower_bound = nil, upper_bound = nil)
       super
     end
 
@@ -4828,10 +5527,10 @@ module Polars
     # 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.
@@ -4856,7 +5555,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,)
@@ -4893,18 +5592,18 @@ 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
 
     # Replace all 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 as syntactic sugar for
     #   `replace_strict(old: Polars::Series.new(mapping.keys), new: Polars::Series.new(mapping.values))`.
     # @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. If no default is specified,
@@ -4916,7 +5615,7 @@ module Polars
     #
     # @return [Series]
     #
-    # @example Replace values by passing sequences to the `old` and `new` parameters.
+    # @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])
     #   # =>
@@ -5004,8 +5703,8 @@ module Polars
     #   # ]
     def replace_strict(
       old,
-      new = Expr::NO_DEFAULT,
-      default: Expr::NO_DEFAULT,
+      new = NO_DEFAULT,
+      default: NO_DEFAULT,
       return_dtype: nil
     )
       super
@@ -5013,7 +5712,7 @@ module Polars
 
     # Reshape this Series to a flat Series or a Series of Lists.
     #
-    # @param dims [Array]
+    # @param dimensions [Array]
     #   Tuple of the dimension sizes. If a -1 is used in any of the dimensions, that
     #   dimension is inferred.
     #
@@ -5047,8 +5746,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.
@@ -5094,8 +5793,8 @@ module Polars
       half_life: nil,
       alpha: nil,
       adjust: true,
-      min_periods: 1,
-      ignore_nulls: true
+      min_samples: 1,
+      ignore_nulls: false
     )
       super
     end
@@ -5184,8 +5883,8 @@ module Polars
       alpha: nil,
       adjust: true,
       bias: false,
-      min_periods: 1,
-      ignore_nulls: true
+      min_samples: 1,
+      ignore_nulls: false
     )
       super
     end
@@ -5212,8 +5911,8 @@ module Polars
       alpha: nil,
       adjust: true,
       bias: false,
-      min_periods: 1,
-      ignore_nulls: true
+      min_samples: 1,
+      ignore_nulls: false
     )
       super
     end
@@ -5249,7 +5948,7 @@ module Polars
     #
     # 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]
@@ -5262,8 +5961,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.
@@ -5493,6 +6192,21 @@ module Polars
       StructNameSpace.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.
@@ -5590,12 +6304,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)
@@ -5606,7 +6320,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)
@@ -5621,8 +6335,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
 
@@ -5630,7 +6344,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 = {
@@ -5656,291 +6370,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 =
-          if dtype == Array
-            constructor.call(name, values, strict)
-          else
-            construct_series_with_fallbacks(constructor, name, values, dtype, strict: strict)
-          end
-
-        base_type = dtype.is_a?(DataType) ? dtype.class : dtype
-        if [Date, Datetime, Duration, Time, Categorical, Boolean, Enum].include?(base_type) || dtype.is_a?(Decimal)
-          if rbseries.dtype != dtype
-            rbseries = rbseries.cast(dtype, true)
-          end
-        end
-
-        # Uninstanced Decimal is a bit special and has various inference paths
-        if dtype == Decimal
-          if rbseries.dtype == String
-            rbseries = rbseries.str_to_decimal_infer(0)
-          elsif rbseries.dtype.float?
-            # Go through string so we infer an appropriate scale.
-            rbseries = rbseries.cast(
-              String, strict: strict, wrap_numerical: false
-            ).str_to_decimal_infer(0)
-          elsif rbseries.dtype.integer? || rbseries.dtype == Null
-            rbseries = rbseries.cast(
-              Decimal.new(nil, 0), strict: strict, wrap_numerical: false
-            )
-          elsif !rbseries.dtype.is_a?(Decimal)
-            msg = "can't convert #{rbseries.dtype} to Decimal"
-            raise TypeError, msg
-          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),
-      Int128 => RbSeries.method(:new_opt_i128),
-      UInt8 => RbSeries.method(:new_opt_u8),
-      UInt16 => RbSeries.method(:new_opt_u16),
-      UInt32 => RbSeries.method(:new_opt_u32),
-      UInt64 => RbSeries.method(:new_opt_u64),
-      UInt128 => RbSeries.method(:new_opt_u128),
-      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),
-      i128: RbSeries.method(:new_opt_i128),
-      u8: RbSeries.method(:new_opt_u8),
-      u16: RbSeries.method(:new_opt_u16),
-      u32: RbSeries.method(:new_opt_u32),
-      u64: RbSeries.method(:new_opt_u64),
-      u128: RbSeries.method(:new_opt_u128),
-      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