polars-df 0.20.0-x86_64-darwin → 0.21.1-x86_64-darwin

data/lib/polars/series.rb

@@ -287,7 +287,7 @@ module Polars
       self != other
     end
 
-    # Method equivalent of equality operator `series != other` where `None == None`.
+    # Method equivalent of equality operator `series != other` where `nil == nil`.
     #
     # This differs from the standard `ne` where null values are propagated.
     #
@@ -407,7 +407,7 @@ module Polars
     # @return [Series]
     def !
       if dtype == Boolean
-        return Utils.wrap_s(_s.not)
+        return Utils.wrap_s(_s.not_)
       end
       raise NotImplementedError
     end
@@ -447,7 +447,7 @@ module Polars
           item = len + item
         end
 
-        return _s.get_idx(item)
+        return _s.get_index(item)
       end
 
       if item.is_a?(Range)
@@ -496,6 +496,37 @@ module Polars
       end
     end
 
+    # Return the Series as a scalar, or return the element at the given index.
+    #
+    # If no index is provided, this is equivalent to `s[0]`, with a check
+    # that the shape is (1,). With an index, this is equivalent to `s[index]`.
+    #
+    # @return [Object]
+    #
+    # @example
+    #   s1 = Polars::Series.new("a", [1])
+    #   s1.item
+    #   # => 1
+    #
+    # @example
+    #   s2 = Polars::Series.new("a", [9, 8, 7])
+    #   s2.cum_sum.item(-1)
+    #   # => 24
+    def item(index = nil)
+      if index.nil?
+        if len != 1
+          msg = (
+            "can only call '.item' if the Series is of length 1," +
+            " or an explicit index is provided (Series is of length #{len})"
+          )
+          raise ArgumentError, msg
+        end
+        return _s.get_index(0)
+      end
+
+      _s.get_index_signed(index)
+    end
+
     # Return an estimation of the total (heap) allocated size of the Series.
     #
     # Estimated size is given in the specified unit (bytes by default).
@@ -543,7 +574,26 @@ module Polars
     #   #         1.732051
     #   # ]
     def sqrt
-      self**0.5
+      super
+    end
+
+    # Compute the cube root of the elements.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new([1, 2, 3])
+    #   s.cbrt
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: '' [f64]
+    #   # [
+    #   #         1.0
+    #   #         1.259921
+    #   #         1.44225
+    #   # ]
+    def cbrt
+      super
     end
 
     # Check if any boolean value in the column is `true`.
@@ -563,7 +613,7 @@ module Polars
     #   # => false
     def any?(ignore_nulls: true, &block)
       if block_given?
-        apply(skip_nulls: ignore_nulls, &block).any?
+        apply(return_dtype: Boolean, skip_nulls: ignore_nulls, &block).any?
       else
         _s.any(ignore_nulls)
       end
@@ -587,7 +637,7 @@ module Polars
     #   # => true
     def all?(ignore_nulls: true, &block)
       if block_given?
-        apply(skip_nulls: ignore_nulls, &block).all?
+        apply(return_dtype: Boolean, skip_nulls: ignore_nulls, &block).all?
       else
         _s.all(ignore_nulls)
       end
@@ -611,7 +661,7 @@ module Polars
     #   # => true
     def none?(&block)
       if block_given?
-        apply(&block).none?
+        apply(return_dtype: Boolean, &block).none?
       else
         to_frame.select(Polars.col(name).is_not.all).to_series[0]
       end
@@ -640,6 +690,25 @@ module Polars
       super
     end
 
+    # Compute the natural logarithm of the input array plus one, element-wise.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new([1, 2, 3])
+    #   s.log1p
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: '' [f64]
+    #   # [
+    #   #         0.693147
+    #   #         1.098612
+    #   #         1.386294
+    #   # ]
+    def log1p
+      super
+    end
+
     # Compute the base 10 logarithm of the input array, element-wise.
     #
     # @return [Series]
@@ -875,6 +944,44 @@ module Polars
       to_frame.select(Polars.col(name).product).to_series[0]
     end
 
+    # Raise to the power of the given exponent.
+    #
+    # If the exponent is float, the result follows the dtype of exponent.
+    # Otherwise, it follows dtype of base.
+    #
+    # @param exponent [Numeric]
+    #   The exponent. Accepts Series input.
+    #
+    # @return [Series]
+    #
+    # @example Raising integers to positive integers results in integers:
+    #   s = Polars::Series.new("foo", [1, 2, 3, 4])
+    #   s.pow(3)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'foo' [i64]
+    #   # [
+    #   #         1
+    #   #         8
+    #   #         27
+    #   #         64
+    #   # ]
+    #
+    # @example In order to raise integers to negative integers, you can cast either the base or the exponent to float:
+    #   s.pow(-3.0)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'foo' [f64]
+    #   # [
+    #   #         1.0
+    #   #         0.125
+    #   #         0.037037
+    #   #         0.015625
+    #   # ]
+    def pow(exponent)
+      to_frame.select_seq(F.col(name).pow(exponent)).to_series
+    end
+
     # Get the minimal value in this Series.
     #
     # @return [Object]
@@ -1004,6 +1111,13 @@ module Polars
 
     # Get dummy variables.
     #
+    # @param separator [String]
+    #   Separator/delimiter used when generating column names.
+    # @param drop_first [Boolean]
+    #   Remove the first category from the variable being encoded.
+    # @param drop_nulls [Boolean]
+    #   If there are `nil` values in the series, a `null` column is not generated.
+    #
     # @return [DataFrame]
     #
     # @example
@@ -1020,8 +1134,8 @@ module Polars
     #   # │ 0   ┆ 1   ┆ 0   │
     #   # │ 0   ┆ 0   ┆ 1   │
     #   # └─────┴─────┴─────┘
-    def to_dummies(separator: "_", drop_first: false)
-      Utils.wrap_df(_s.to_dummies(separator, drop_first))
+    def to_dummies(separator: "_", drop_first: false, drop_nulls: false)
+      Utils.wrap_df(_s.to_dummies(separator, drop_first, drop_nulls))
     end
 
     # Bin continuous values into discrete categories.
@@ -1093,8 +1207,8 @@ module Polars
 
     # Bin continuous values into discrete categories based on their quantiles.
     #
-    # @param quantiles [Array]
-    #   Either a list of quantile probabilities between 0 and 1 or a positive
+    # @param quantiles [Object]
+    #   Either an array of quantile probabilities between 0 and 1 or a positive
     #   integer determining the number of bins with uniform probability.
     # @param labels [Array]
     #   Names of the categories. The number of labels must be equal to the number
@@ -1230,10 +1344,76 @@ module Polars
       super
     end
 
+    # Bin values into buckets and count their occurrences.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # @param bins [Object]
+    #   Bin edges. If nil given, we determine the edges based on the data.
+    # @param bin_count [Integer]
+    #   If `bins` is not provided, `bin_count` uniform bins are created that fully
+    #   encompass the data.
+    # @param include_category [Boolean]
+    #   Include a column that shows the intervals as categories.
+    # @param include_breakpoint [Boolean]
+    #   Include a column that indicates the upper breakpoint.
+    #
+    # @return [DataFrame]
+    #
+    # @example
+    #   a = Polars::Series.new("a", [1, 3, 8, 8, 2, 1, 3])
+    #   a.hist(bin_count: 4)
+    #   # =>
+    #   # shape: (4, 3)
+    #   # ┌────────────┬─────────────┬───────┐
+    #   # │ breakpoint ┆ category    ┆ count │
+    #   # │ ---        ┆ ---         ┆ ---   │
+    #   # │ f64        ┆ cat         ┆ u32   │
+    #   # ╞════════════╪═════════════╪═══════╡
+    #   # │ 2.75       ┆ [1.0, 2.75] ┆ 3     │
+    #   # │ 4.5        ┆ (2.75, 4.5] ┆ 2     │
+    #   # │ 6.25       ┆ (4.5, 6.25] ┆ 0     │
+    #   # │ 8.0        ┆ (6.25, 8.0] ┆ 2     │
+    #   # └────────────┴─────────────┴───────┘
+    def hist(
+      bins: nil,
+      bin_count: nil,
+      include_category: true,
+      include_breakpoint: true
+    )
+      out = (
+        to_frame
+        .select_seq(
+          F.col(name).hist(
+            bins: bins,
+            bin_count: bin_count,
+            include_category: include_category,
+            include_breakpoint: include_breakpoint
+          )
+        )
+        .to_series
+      )
+      if !include_breakpoint && !include_category
+        out.to_frame
+      else
+        out.struct.unnest
+      end
+    end
+
     # Count the unique values in a Series.
     #
     # @param sort [Boolean]
     #   Ensure the output is sorted from most values to least.
+    # @param parallel [Boolean]
+    #   Execute the computation in parallel.
+    # @param name [String]
+    #   Give the resulting count column a specific name; if `normalize` is
+    #   true this defaults to "proportion", otherwise defaults to "count".
+    # @param normalize [Boolean]
+    #   If true, the count is returned as the relative frequency of unique
+    #   values normalized to 1.0.
     #
     # @return [DataFrame]
     #
@@ -1451,6 +1631,29 @@ module Polars
     end
     alias_method :cumsum, :cum_sum
 
+    # Return the cumulative count of the non-null values in the column.
+    #
+    # @param reverse [Boolean]
+    #   Reverse the operation.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(["x", "k", nil, "d"])
+    #   s.cum_count
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [u32]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         2
+    #   #         3
+    #   # ]
+    def cum_count(reverse: false)
+      super
+    end
+
     # Get an array with the cumulative min computed at every element.
     #
     # @param reverse [Boolean]
@@ -1524,29 +1727,6 @@ module Polars
     end
     alias_method :cumprod, :cum_prod
 
-    # Get the first `n` rows.
-    #
-    # Alias for {#head}.
-    #
-    # @param n [Integer]
-    #   Number of rows to return.
-    #
-    # @return [Series]
-    #
-    # @example
-    #   s = Polars::Series.new("a", [1, 2, 3])
-    #   s.limit(2)
-    #   # =>
-    #   # shape: (2,)
-    #   # Series: 'a' [i64]
-    #   # [
-    #   #         1
-    #   #         2
-    #   # ]
-    def limit(n = 10)
-      to_frame.select(F.col(name).limit(n)).to_series
-    end
-
     # Get a slice of this Series.
     #
     # @param offset [Integer]
@@ -1700,13 +1880,41 @@ module Polars
       to_frame.select(F.col(name).tail(n)).to_series
     end
 
+    # Get the first `n` rows.
+    #
+    # Alias for {#head}.
+    #
+    # @param n [Integer]
+    #   Number of rows to return.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3])
+    #   s.limit(2)
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   # ]
+    def limit(n = 10)
+      to_frame.select(F.col(name).limit(n)).to_series
+    end
+
     # Take every nth value in the Series and return as new Series.
     #
+    # @param n [Integer]
+    #   Gather every *n*-th row.
+    # @param offset [Integer]
+    #   Start the row index at this offset.
+    #
     # @return [Series]
     #
     # @example
     #   s = Polars::Series.new("a", [1, 2, 3, 4])
-    #   s.take_every(2)
+    #   s.gather_every(2)
     #   # =>
     #   # shape: (2,)
     #   # Series: 'a' [i64]
@@ -1714,14 +1922,29 @@ module Polars
     #   #         1
     #   #         3
     #   # ]
-    def take_every(n)
+    #
+    # @example
+    #   s.gather_every(2, 1)
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         2
+    #   #         4
+    #   # ]
+    def gather_every(n, offset = 0)
       super
     end
+    alias_method :take_every, :gather_every
 
     # Sort this Series.
     #
     # @param reverse [Boolean]
     #   Reverse sort.
+    # @param nulls_last [Boolean]
+    #   Place null values last instead of first.
+    # @param multithreaded [Boolean]
+    #   Sort using multiple threads.
     # @param in_place [Boolean]
     #   Sort in place.
     #
@@ -1780,6 +2003,44 @@ module Polars
       super
     end
 
+    # Return the `k` largest elements of the `by` column.
+    #
+    # Non-null elements are always preferred over null elements, regardless of
+    # the value of `reverse`. The output is not guaranteed to be in any
+    # particular order, call `sort` after this function if you wish the
+    # output to be sorted.
+    #
+    # @param by [Object]
+    #   Column used to determine the largest elements.
+    #   Accepts expression input. Strings are parsed as column names.
+    # @param k [Integer]
+    #   Number of elements to return.
+    # @param reverse [Object]
+    #   Consider the `k` smallest elements of the `by` column (instead of the `k`
+    #   largest). This can be specified per column by passing a sequence of
+    #   booleans.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [2, 5, 1, 4, 3])
+    #   s.top_k_by("a", k: 3)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         5
+    #   #         4
+    #   #         3
+    #   # ]
+    def top_k_by(
+      by,
+      k: 5,
+      reverse: false
+    )
+      super
+    end
+
     # Return the `k` smallest elements.
     #
     # @param k [Integer]
@@ -1802,6 +2063,44 @@ module Polars
       super
     end
 
+    # Return the `k` smallest elements of the `by` column.
+    #
+    # Non-null elements are always preferred over null elements, regardless of
+    # the value of `reverse`. The output is not guaranteed to be in any
+    # particular order, call `sort` after this function if you wish the
+    # output to be sorted.
+    #
+    # @param by [Object]
+    #   Column used to determine the smallest elements.
+    #   Accepts expression input. Strings are parsed as column names.
+    # @param k [Integer]
+    #   Number of elements to return.
+    # @param reverse [Object]
+    #   Consider the `k` largest elements of the `by` column( (instead of the `k`
+    #   smallest). This can be specified per column by passing a sequence of
+    #   booleans.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [2, 5, 1, 4, 3])
+    #   s.bottom_k_by("a", k: 3)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   # ]
+    def bottom_k_by(
+      by,
+      k: 5,
+      reverse: false
+    )
+      super
+    end
+
     # Get the index values that would sort this Series.
     #
     # @param reverse [Boolean]
@@ -1971,7 +2270,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new("a", [1, 2, 3, 4])
-    #   s.take([1, 3])
+    #   s.gather([1, 3])
     #   # =>
     #   # shape: (2,)
     #   # Series: 'a' [i64]
@@ -1979,9 +2278,10 @@ module Polars
     #   #         2
     #   #         4
     #   # ]
-    def take(indices)
-      to_frame.select(Polars.col(name).take(indices)).to_series
+    def gather(indices)
+      super
     end
+    alias_method :take, :gather
 
     # Count the null values in this Series.
     #
@@ -2028,6 +2328,48 @@ module Polars
     end
     alias_method :empty?, :is_empty
 
+    # Check if the Series is sorted.
+    #
+    # @param descending [Boolean]
+    #   Check if the Series is sorted in descending order
+    # @param nulls_last [Boolean]
+    #   Set nulls at the end of the Series in sorted check.
+    #
+    # @return [Boolean]
+    #
+    # @example
+    #   s = Polars::Series.new([1, 3, 2])
+    #   s.is_sorted
+    #   # => false
+    #
+    # @example
+    #   s = Polars::Series.new([3, 2, 1])
+    #   s.is_sorted(descending: true)
+    #   # => true
+    def is_sorted(descending: false, nulls_last: false)
+      _s.is_sorted(descending, nulls_last)
+    end
+    alias_method :sorted?, :is_sorted
+
+    # Negate a boolean Series.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [true, false, false])
+    #   s.not_
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [bool]
+    #   # [
+    #   #         false
+    #   #         true
+    #   #         true
+    #   # ]
+    def not_
+      self.class._from_rbseries(_s.not_)
+    end
+
     # Returns a boolean Series indicating which values are null.
     #
     # @return [Series]
@@ -2154,7 +2496,7 @@ module Polars
     # @return [Series]
     #
     # @example
-    #   s = Polars::Series.new("a", [1, 2, 3])
+    #   s = Polars::Series.new("a", [[1, 2, 3]])
     #   s2 = Polars::Series.new("b", [2, 4, nil])
     #   s2.is_in(s)
     #   # =>
@@ -2273,6 +2615,28 @@ module Polars
     end
     alias_method :is_first, :is_first_distinct
 
+
+    # Return a boolean mask indicating the last occurrence of each distinct value.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new([1, 1, 2, 3, 2])
+    #   s.is_last_distinct
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: '' [bool]
+    #   # [
+    #   #         false
+    #   #         true
+    #   #         false
+    #   #         true
+    #   #         true
+    #   # ]
+    def is_last_distinct
+      super
+    end
+
     # Get mask of all duplicated values.
     #
     # @return [Series]
@@ -2490,12 +2854,130 @@ module Polars
       super
     end
 
-    # Check if this Series datatype is numeric.
+    # Get a boolean mask of the values that are between the given lower/upper bounds.
     #
-    # @return [Boolean]
+    # @param lower_bound [Object]
+    #   Lower bound value. Accepts expression input. Non-expression inputs
+    #   (including strings) are parsed as literals.
+    # @param upper_bound [Object]
+    #   Upper bound value. Accepts expression input. Non-expression inputs
+    #   (including strings) are parsed as literals.
+    # @param closed ['both', 'left', 'right', 'none']
+    #   Define which sides of the interval are closed (inclusive).
     #
-    # @example
-    #   s = Polars::Series.new("a", [1, 2, 3])
+    # @return [Series]
+    #
+    # @note
+    #   If the value of the `lower_bound` is greater than that of the `upper_bound`
+    #   then the result will be False, as no value can satisfy the condition.
+    #
+    # @example
+    #   s = Polars::Series.new("num", [1, 2, 3, 4, 5])
+    #   s.is_between(2, 4)
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'num' [bool]
+    #   # [
+    #   #         false
+    #   #         true
+    #   #         true
+    #   #         true
+    #   #         false
+    #   # ]
+    #
+    # @example Use the `closed` argument to include or exclude the values at the bounds:
+    #   s.is_between(2, 4, closed: "left")
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'num' [bool]
+    #   # [
+    #   #         false
+    #   #         true
+    #   #         true
+    #   #         false
+    #   #         false
+    #   # ]
+    #
+    # @example You can also use strings as well as numeric/temporal values:
+    #   s = Polars::Series.new("s", ["a", "b", "c", "d", "e"])
+    #   s.is_between("b", "d", closed: "both")
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 's' [bool]
+    #   # [
+    #   #         false
+    #   #         true
+    #   #         true
+    #   #         true
+    #   #         false
+    #   # ]
+    def is_between(
+      lower_bound,
+      upper_bound,
+      closed: "both"
+    )
+      if closed == "none"
+        out = (self > lower_bound) & (self < upper_bound)
+      elsif closed == "both"
+        out = (self >= lower_bound) & (self <= upper_bound)
+      elsif closed == "right"
+        out = (self > lower_bound) & (self <= upper_bound)
+      elsif closed == "left"
+        out = (self >= lower_bound) & (self < upper_bound)
+      end
+
+      if out.is_a?(Expr)
+        out = F.select(out).to_series
+      end
+
+      out
+    end
+
+    # Get a boolean mask of the values being close to the other values.
+    #
+    # @param abs_tol [Float]
+    #   Absolute tolerance. This is the maximum allowed absolute difference between
+    #   two values. Must be non-negative.
+    # @param rel_tol [Float]
+    #   Relative tolerance. This is the maximum allowed difference between two
+    #   values, relative to the larger absolute value. Must be in the range [0, 1).
+    # @param nans_equal [Boolean]
+    #   Whether NaN values should be considered equal.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("s", [1.0, 1.2, 1.4, 1.45, 1.6])
+    #   s.is_close(1.4, abs_tol: 0.1)
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 's' [bool]
+    #   # [
+    #   #         false
+    #   #         false
+    #   #         true
+    #   #         true
+    #   #         false
+    #   # ]
+    def is_close(
+      other,
+      abs_tol: 0.0,
+      rel_tol: 1e-09,
+      nans_equal: false
+    )
+      F.select(
+        F.lit(self).is_close(
+          other, abs_tol: abs_tol, rel_tol: rel_tol, nans_equal: nans_equal
+        )
+      ).to_series
+    end
+
+    # 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
@@ -2653,23 +3135,69 @@ module Polars
     end
     alias_method :set_at_idx, :scatter
 
+    # Get the index of the first occurrence of a value, or `nil` if it's not found.
+    #
+    # @param element [Object]
+    #   Value to find.
+    #
+    # @return [Object]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, nil, 17])
+    #   s.index_of(17)
+    #   # => 2
+    #
+    # @example
+    #   s.index_of(nil) # search for a null
+    #   # => 1
+    #
+    # @example
+    #   s.index_of(55).nil?
+    #   # => true
+    def index_of(element)
+      F.select(F.lit(self).index_of(element)).item
+    end
+
     # Create an empty copy of the current Series.
     #
     # The copy has identical name/dtype but no data.
     #
+    # @param n [Integer]
+    #   Number of (empty) elements to return in the cleared frame.
+    #
     # @return [Series]
     #
     # @example
     #   s = Polars::Series.new("a", [nil, true, false])
-    #   s.cleared
+    #   s.clear
     #   # =>
     #   # shape: (0,)
     #   # Series: 'a' [bool]
     #   # [
     #   # ]
-    def cleared
-      len > 0 ? limit(0) : clone
+    #
+    # @example
+    #   s.clear(n: 2)
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [bool]
+    #   # [
+    #   #         null
+    #   #         null
+    #   # ]
+    def clear(n: 0)
+      if n < 0
+        msg = "`n` should be greater than or equal to 0, got #{n}"
+        raise ArgumentError, msg
+      end
+      # faster path
+      if n == 0
+        return self.class._from_rbseries(_s.clear)
+      end
+      s = len > 0 ? self.class.new(name, [], dtype: dtype) : clone
+      n > 0 ? s.extend_constant(nil, n) : s
     end
+    alias_method :cleared, :clear
 
     # clone handled by initialize_copy
 
@@ -2748,6 +3276,30 @@ module Polars
       super
     end
 
+    # Fill missing values with the next non-null value.
+    #
+    # This is an alias of `.fill_null(strategy: "backward")`.
+    #
+    # @param limit [Integer]
+    #   The number of consecutive null values to backward fill.
+    #
+    # @return [Series]
+    def backward_fill(limit: nil)
+      fill_null(strategy: "backward", limit: limit)
+    end
+
+    # Fill missing values with the next non-null value.
+    #
+    # This is an alias of `.fill_null(strategy: "forward")`.
+    #
+    # @param limit [Integer]
+    #   The number of consecutive null values to forward fill.
+    #
+    # @return [Series]
+    def forward_fill(limit: nil)
+      fill_null(strategy: "forward", limit: limit)
+    end
+
     # Rounds down to the nearest integer value.
     #
     # Only works on floating point Series.
@@ -2812,6 +3364,28 @@ module Polars
       super
     end
 
+    # Round to a number of significant figures.
+    #
+    # @param digits [Integer]
+    #   Number of significant figures to round to.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new([0.01234, 3.333, 3450.0])
+    #   s.round_sig_figs(2)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: '' [f64]
+    #   # [
+    #   #         0.012
+    #   #         3.3
+    #   #         3500.0
+    #   # ]
+    def round_sig_figs(digits)
+      super
+    end
+
     # Compute the dot/inner product between two Series.
     #
     # @param other [Object]
@@ -2932,6 +3506,25 @@ module Polars
       super
     end
 
+    # Compute the element-wise value for the cotangent.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [0.0, Math::PI / 2.0, Math::PI])
+    #   s.cot
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         inf
+    #   #         6.1232e-17
+    #   #         -8.1656e15
+    #   # ]
+    def cot
+      super
+    end
+
     # Compute the element-wise value for the inverse sine.
     #
     # @return [Series]
@@ -3132,7 +3725,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new("a", [1, 2, 3])
-    #   s.map_elements { |x| x + 10 }
+    #   s.map_elements(return_dtype: Polars::Int64) { |x| x + 10 }
     #   # =>
     #   # shape: (3,)
     #   # Series: 'a' [i64]
@@ -3147,7 +3740,7 @@ module Polars
       else
         pl_return_dtype = Utils.rb_type_to_dtype(return_dtype)
       end
-      Utils.wrap_s(_s.apply_lambda(func, pl_return_dtype, skip_nulls))
+      Utils.wrap_s(_s.map_elements(func, pl_return_dtype, skip_nulls))
     end
     alias_method :map, :map_elements
     alias_method :apply, :map_elements
@@ -3190,7 +3783,7 @@ module Polars
     # @param periods [Integer]
     #   Number of places to shift (may be negative).
     # @param fill_value [Object]
-    #   Fill None values with the result of this expression.
+    #   Fill nil values with the result of this expression.
     #
     # @return [Series]
     def shift_and_fill(periods, fill_value)
@@ -3254,7 +3847,7 @@ module Polars
     #   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 None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -3295,7 +3888,7 @@ module Polars
     #   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 None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -3336,7 +3929,7 @@ module Polars
     #   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 None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -3377,7 +3970,7 @@ module Polars
     #   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 None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -3418,9 +4011,11 @@ module Polars
     #   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 None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
+    # @param ddof [Integer]
+    #   "Delta Degrees of Freedom": The divisor for a length N window is N - ddof
     #
     # @return [Series]
     #
@@ -3461,9 +4056,11 @@ module Polars
     #   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 None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
+    # @param ddof [Integer]
+    #   "Delta Degrees of Freedom": The divisor for a length N window is N - ddof
     #
     # @return [Series]
     #
@@ -3503,7 +4100,7 @@ module Polars
     #   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 None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -3545,7 +4142,7 @@ module Polars
     #   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 None, it will be set equal to window size.
+    #   a result. If nil, it will be set equal to window size.
     # @param center [Boolean]
     #   Set the labels at the center of the window
     #
@@ -3560,10 +4157,10 @@ module Polars
     #   # [
     #   #         null
     #   #         null
-    #   #         1.0
     #   #         2.0
     #   #         3.0
     #   #         4.0
+    #   #         6.0
     #   # ]
     #
     # @example
@@ -3619,11 +4216,56 @@ module Polars
       super
     end
 
+    # Compute a rolling kurtosis.
+    #
+    # @note
+    #   This functionality is considered **unstable**. It may be changed
+    #   at any point without it being considered a breaking change.
+    #
+    # The window at a given row will include the row itself, and the `window_size - 1`
+    # elements before it.
+    #
+    # @param window_size [Integer]
+    #   Integer size of the rolling window.
+    # @param fisher [Boolean]
+    #   If true, Fisher's definition is used (normal ==> 0.0). If false,
+    #   Pearson's definition is used (normal ==> 3.0).
+    # @param bias [Boolean]
+    #   If false, the calculations are corrected for statistical bias.
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If set to `nil` (default), it will be set equal to `window_size`.
+    # @param center [Boolean]
+    #   Set the labels at the center of the window.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   Polars::Series.new([1, 4, 2, 9]).rolling_kurtosis(3)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [f64]
+    #   # [
+    #   #         null
+    #   #         null
+    #   #         -1.5
+    #   #         -1.5
+    #   # ]
+    def rolling_kurtosis(
+      window_size,
+      fisher: true,
+      bias: true,
+      min_samples: nil,
+      center: false
+    )
+      super
+    end
+
     # Sample from this Series.
     #
     # @param n [Integer]
     #   Number of items to return. Cannot be used with `frac`. Defaults to 1 if
-    #   `frac` is None.
+    #   `frac` is nil.
     # @param frac [Float]
     #   Fraction of items to return. Cannot be used with `n`.
     # @param with_replacement [Boolean]
@@ -3631,7 +4273,7 @@ module Polars
     # @param shuffle [Boolean]
     #   Shuffle the order of sampled data points.
     # @param seed [Integer]
-    #   Seed for the random number generator. If set to None (default), a random
+    #   Seed for the random number generator. If set to nil (default), a random
     #   seed is used.
     #
     # @return [Series]
@@ -3644,7 +4286,7 @@ module Polars
     #   # Series: 'a' [i64]
     #   # [
     #   #         5
-    #   #         3
+    #   #         2
     #   # ]
     def sample(
       n: nil,
@@ -4129,6 +4771,60 @@ module Polars
       super
     end
 
+    # Return the lower bound of this Series' dtype as a unit Series.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("s", [-1, 0, 1], dtype: Polars::Int32)
+    #   s.lower_bound
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: 's' [i32]
+    #   # [
+    #   #         -2147483648
+    #   # ]
+    #
+    # @example
+    #   s = Polars::Series.new("s", [1.0, 2.5, 3.0], dtype: Polars::Float32)
+    #   s.lower_bound
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: 's' [f32]
+    #   # [
+    #   #         -inf
+    #   # ]
+    def lower_bound
+      super
+    end
+
+    # Return the upper bound of this Series' dtype as a unit Series.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("s", [-1, 0, 1], dtype: Polars::Int8)
+    #   s.upper_bound
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: 's' [i8]
+    #   # [
+    #   #         127
+    #   # ]
+    #
+    # @example
+    #   s = Polars::Series.new("s", [1.0, 2.5, 3.0], dtype: Polars::Float64)
+    #   s.upper_bound
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: 's' [f64]
+    #   # [
+    #   #         inf
+    #   # ]
+    def upper_bound
+      super
+    end
+
     # Replace values by different values.
     #
     # @param old [Object]
@@ -4201,6 +4897,120 @@ module Polars
       super
     end
 
+    # Replace all values by different values.
+    #
+    # @param old [Object]
+    #   Value or sequence 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.
+    #   Length must match the length of `old` or have length 1.
+    # @param default [Object]
+    #   Set values that were not replaced to this value. If no default is specified,
+    #   (default), an error is raised if any values were not replaced.
+    #   Accepts expression input. Non-expression inputs are parsed as literals.
+    # @param return_dtype [Object]
+    #   The data type of the resulting Series. If set to `nil` (default),
+    #   the data type is determined automatically based on the other inputs.
+    #
+    # @return [Series]
+    #
+    # @example Replace values by passing sequences to the `old` and `new` parameters.
+    #   s = Polars::Series.new([1, 2, 2, 3])
+    #   s.replace_strict([1, 2, 3], [100, 200, 300])
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [i64]
+    #   # [
+    #   #         100
+    #   #         200
+    #   #         200
+    #   #         300
+    #   # ]
+    #
+    # @example Passing a mapping with replacements is also supported as syntactic sugar.
+    #   mapping = {1 => 100, 2 => 200, 3 => 300}
+    #   s.replace_strict(mapping)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [i64]
+    #   # [
+    #   #         100
+    #   #         200
+    #   #         200
+    #   #         300
+    #   # ]
+    #
+    # @example By default, an error is raised if any non-null values were not replaced. Specify a default to set all values that were not matched.
+    #   mapping = {2 => 200, 3 => 300}
+    #   s.replace_strict(mapping, default: -1)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [i64]
+    #   # [
+    #   #         -1
+    #   #         200
+    #   #         200
+    #   #         300
+    #   # ]
+    #
+    # @example The default can be another Series.
+    #   default = Polars::Series.new([2.5, 5.0, 7.5, 10.0])
+    #   s.replace_strict(2, 200, default: default)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: '' [f64]
+    #   # [
+    #   #         2.5
+    #   #         200.0
+    #   #         200.0
+    #   #         10.0
+    #   # ]
+    #
+    # @example Replacing by values of a different data type sets the return type based on a combination of the `new` data type and the `default` data type.
+    #   s = Polars::Series.new(["x", "y", "z"])
+    #   mapping = {"x" => 1, "y" => 2, "z" => 3}
+    #   s.replace_strict(mapping)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: '' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   # ]
+    #
+    # @example
+    #   s.replace_strict(mapping, default: "x")
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         "1"
+    #   #         "2"
+    #   #         "3"
+    #   # ]
+    #
+    # @example Set the `return_dtype` parameter to control the resulting data type directly.
+    #   s.replace_strict(mapping, return_dtype: Polars::UInt8)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: '' [u8]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   # ]
+    def replace_strict(
+      old,
+      new = Expr::NO_DEFAULT,
+      default: Expr::NO_DEFAULT,
+      return_dtype: nil
+    )
+      super
+    end
+
     # Reshape this Series to a flat Series or a Series of Lists.
     #
     # @param dims [Array]
@@ -4256,8 +5066,8 @@ module Polars
     #   # Series: 'a' [i64]
     #   # [
     #   #         2
-    #   #         1
     #   #         3
+    #   #         1
     #   # ]
     def shuffle(seed: nil)
       super
@@ -4290,6 +5100,68 @@ module Polars
       super
     end
 
+    # Compute time-based exponentially weighted moving average.
+    #
+    # @param by [Object]
+    #   Times to calculate average by. Should be `DateTime`, `Date`, `UInt64`,
+    #   `UInt32`, `Int64`, or `Int32` data type.
+    # @param half_life [String]
+    #   Unit over which observation decays to half its value.
+    #
+    #   Can be created either from a timedelta, or
+    #   by using the following string language:
+    #
+    #   - 1ns   (1 nanosecond)
+    #   - 1us   (1 microsecond)
+    #   - 1ms   (1 millisecond)
+    #   - 1s    (1 second)
+    #   - 1m    (1 minute)
+    #   - 1h    (1 hour)
+    #   - 1d    (1 day)
+    #   - 1w    (1 week)
+    #   - 1i    (1 index count)
+    #
+    #   Or combine them:
+    #   "3d12h4m25s" # 3 days, 12 hours, 4 minutes, and 25 seconds
+    #
+    #   Note that `half_life` is treated as a constant duration - calendar
+    #   durations such as months (or even days in the time-zone-aware case)
+    #   are not supported, please express your duration in an approximately
+    #   equivalent number of hours (e.g. '370h' instead of '1mo').
+    #
+    # @return [Series]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "values" => [0, 1, 2, nil, 4],
+    #       "times" => [
+    #         Date.new(2020, 1, 1),
+    #         Date.new(2020, 1, 3),
+    #         Date.new(2020, 1, 10),
+    #         Date.new(2020, 1, 15),
+    #         Date.new(2020, 1, 17)
+    #       ]
+    #     }
+    #   ).sort("times")
+    #   df["values"].ewm_mean_by(df["times"], half_life: "4d")
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'values' [f64]
+    #   # [
+    #   #         0.0
+    #   #         0.292893
+    #   #         1.492474
+    #   #         null
+    #   #         3.254508
+    #   # ]
+    def ewm_mean_by(
+      by,
+      half_life:
+    )
+      super
+    end
+
     # Exponentially-weighted moving standard deviation.
     #
     # @return [Series]
@@ -4438,6 +5310,140 @@ module Polars
       super
     end
 
+    # Get the chunks of this Series as a list of Series.
+    #
+    # @return [Array]
+    #
+    # @example
+    #   s1 = Polars::Series.new("a", [1, 2, 3])
+    #   s2 = Polars::Series.new("a", [4, 5, 6])
+    #   s = Polars.concat([s1, s2], rechunk: false)
+    #   s.get_chunks
+    #   # =>
+    #   # [shape: (3,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   # ], shape: (3,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         4
+    #   #         5
+    #   #         6
+    #   # ]]
+    def get_chunks
+      _s.get_chunks
+    end
+
+    # Aggregate values into a list.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3])
+    #   s.implode
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: 'a' [list[i64]]
+    #   # [
+    #   #         [1, 2, 3]
+    #   # ]
+    def implode
+      super
+    end
+
+    # Evaluate the number of set bits.
+    #
+    # @return [Series]
+    def bitwise_count_ones
+      super
+    end
+
+    # Evaluate the number of unset bits.
+    #
+    # @return [Series]
+    def bitwise_count_zeros
+      super
+    end
+
+    # Evaluate the number most-significant set bits before seeing an unset bit.
+    #
+    # @return [Series]
+    def bitwise_leading_ones
+      super
+    end
+
+    # Evaluate the number most-significant unset bits before seeing a set bit.
+    #
+    # @return [Series]
+    def bitwise_leading_zeros
+      super
+    end
+
+    # Evaluate the number least-significant set bits before seeing an unset bit.
+    #
+    # @return [Series]
+    def bitwise_trailing_ones
+      super
+    end
+
+    # Evaluate the number least-significant unset bits before seeing a set bit.
+    #
+    # @return [Series]
+    def bitwise_trailing_zeros
+      super
+    end
+
+    # Perform an aggregation of bitwise ANDs.
+    #
+    # @return [Object]
+    def bitwise_and
+      _s.bitwise_and
+    end
+
+    # Perform an aggregation of bitwise ORs.
+    #
+    # @return [Object]
+    def bitwise_or
+      _s.bitwise_or
+    end
+
+    # Perform an aggregation of bitwise XORs.
+    #
+    # @return [Object]
+    def bitwise_xor
+      _s.bitwise_xor
+    end
+
+    # Get the first element of the Series.
+    #
+    # Returns `nil` if the Series is empty.
+    #
+    # @return [Object]
+    def first
+      _s.first
+    end
+
+    # Get the last element of the Series.
+    #
+    # Returns `nil` if the Series is empty.
+    #
+    # @return [Object]
+    def last
+      _s.last
+    end
+
+    # Approximate count of unique values.
+    #
+    # This is done using the HyperLogLog++ algorithm for cardinality estimation.
+    #
+    # @return [Object]
+    def approx_n_unique
+      _s.approx_n_unique
+    end
+
     # Create an object namespace of all list related methods.
     #
     # @return [ListNameSpace]
@@ -4487,6 +5493,20 @@ module Polars
       StructNameSpace.new(self)
     end
 
+    # Repeat the elements in this Series as specified in the given expression.
+    #
+    # The repeated elements are expanded into a List.
+    #
+    # @param by [Object]
+    #   Numeric column that determines how often the values will be repeated.
+    #   The column will be coerced to UInt32. Give this dtype to make the coercion
+    #   a no-op.
+    #
+    # @return [Object]
+    def repeat_by(by)
+      super
+    end
+
     private
 
     def initialize_copy(other)