polars-df 0.4.0-x86_64-darwin → 0.6.0-x86_64-darwin

data/lib/polars/expr.rb

@@ -362,7 +362,7 @@ module Polars
       if columns.is_a?(String)
         columns = [columns]
         return wrap_expr(_rbexpr.exclude(columns))
-      elsif !columns.is_a?(Array)
+      elsif !columns.is_a?(::Array)
         columns = [columns]
         return wrap_expr(_rbexpr.exclude_dtype(columns))
       end
@@ -820,18 +820,18 @@ module Polars
     #   df.select(Polars.repeat(nil, 3).append(Polars.col("a")).rechunk)
     #   # =>
     #   # shape: (6, 1)
-    #   # ┌─────────┐
-    #   # │ literal │
-    #   # │ ---     │
-    #   # │ i64     │
-    #   # ╞═════════╡
-    #   # │ null    │
-    #   # │ null    │
-    #   # │ null    │
-    #   # │ 1       │
-    #   # │ 1       │
-    #   # │ 2       │
-    #   # └─────────┘
+    #   # ┌────────┐
+    #   # │ repeat │
+    #   # │ ---    │
+    #   # │ i64    │
+    #   # ╞════════╡
+    #   # │ null   │
+    #   # │ null   │
+    #   # │ null   │
+    #   # │ 1      │
+    #   # │ 1      │
+    #   # │ 2      │
+    #   # └────────┘
     def rechunk
       wrap_expr(_rbexpr.rechunk)
     end
@@ -1308,8 +1308,6 @@ module Polars
     #
     # @param k [Integer]
     #   Number of elements to return.
-    # @param reverse [Boolean]
-    #   Return the smallest elements.
     #
     # @return [Expr]
     #
@@ -1322,7 +1320,45 @@ module Polars
     #   df.select(
     #     [
     #       Polars.col("value").top_k.alias("top_k"),
-    #       Polars.col("value").top_k(reverse: true).alias("bottom_k")
+    #       Polars.col("value").bottom_k.alias("bottom_k")
+    #     ]
+    #   )
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌───────┬──────────┐
+    #   # │ top_k ┆ bottom_k │
+    #   # │ ---   ┆ ---      │
+    #   # │ i64   ┆ i64      │
+    #   # ╞═══════╪══════════╡
+    #   # │ 99    ┆ 1        │
+    #   # │ 98    ┆ 2        │
+    #   # │ 4     ┆ 3        │
+    #   # │ 3     ┆ 4        │
+    #   # │ 2     ┆ 98       │
+    #   # └───────┴──────────┘
+    def top_k(k: 5)
+      wrap_expr(_rbexpr.top_k(k))
+    end
+
+    # Return the `k` smallest elements.
+    #
+    # If 'reverse: true` the smallest elements will be given.
+    #
+    # @param k [Integer]
+    #   Number of elements to return.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "value" => [1, 98, 2, 3, 99, 4]
+    #     }
+    #   )
+    #   df.select(
+    #     [
+    #       Polars.col("value").top_k.alias("top_k"),
+    #       Polars.col("value").bottom_k.alias("bottom_k")
     #     ]
     #   )
     #   # =>
@@ -1338,8 +1374,8 @@ module Polars
     #   # │ 3     ┆ 4        │
     #   # │ 2     ┆ 98       │
     #   # └───────┴──────────┘
-    def top_k(k: 5, reverse: false)
-      wrap_expr(_rbexpr.top_k(k, reverse))
+    def bottom_k(k: 5)
+      wrap_expr(_rbexpr.bottom_k(k))
     end
 
     # Get the index values that would sort this column.
@@ -1498,10 +1534,10 @@ module Polars
     #   # │ two   │
     #   # └───────┘
     def sort_by(by, reverse: false)
-      if !by.is_a?(Array)
+      if !by.is_a?(::Array)
         by = [by]
       end
-      if !reverse.is_a?(Array)
+      if !reverse.is_a?(::Array)
         reverse = [reverse]
       end
       by = Utils.selection_to_rbexpr_list(by)
@@ -1542,7 +1578,7 @@ module Polars
     #   # │ two   ┆ 99    │
     #   # └───────┴───────┘
     def take(indices)
-      if indices.is_a?(Array)
+      if indices.is_a?(::Array)
         indices_lit = Polars.lit(Series.new("", indices, dtype: :u32))
       else
         indices_lit = Utils.expr_to_lit_or_expr(indices, str_to_lit: false)
@@ -2008,6 +2044,28 @@ module Polars
       wrap_expr(_rbexpr.n_unique)
     end
 
+    # Approx count unique values.
+    #
+    # This is done using the HyperLogLog++ algorithm for cardinality estimation.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1, 1, 2]})
+    #   df.select(Polars.col("a").approx_unique)
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌─────┐
+    #   # │ a   │
+    #   # │ --- │
+    #   # │ u32 │
+    #   # ╞═════╡
+    #   # │ 2   │
+    #   # └─────┘
+    def approx_unique
+      wrap_expr(_rbexpr.approx_unique)
+    end
+
     # Count null values.
     #
     # @return [Expr]
@@ -2194,7 +2252,7 @@ module Polars
     #   # │ 4      │
     #   # │ 6      │
     #   # │ 6      │
-    #   # │ …      │
+    #   # │ 4      │
     #   # │ 6      │
     #   # │ 6      │
     #   # │ 6      │
@@ -2378,14 +2436,14 @@ module Polars
     #   ).sort("group_col")
     #   # =>
     #   # shape: (2, 3)
-    #   # ┌───────────┬──────┬─────┐
-    #   # │ group_col ┆ lt   ┆ gte │
-    #   # │ ---       ┆ ---  ┆ --- │
-    #   # │ str       ┆ i64  ┆ i64 │
-    #   # ╞═══════════╪══════╪═════╡
-    #   # │ g1        ┆ 1    ┆ 2   │
-    #   # │ g2        ┆ null ┆ 3   │
-    #   # └───────────┴──────┴─────┘
+    #   # ┌───────────┬─────┬─────┐
+    #   # │ group_col ┆ lt  ┆ gte │
+    #   # │ ---       ┆ --- ┆ --- │
+    #   # │ str       ┆ i64 ┆ i64 │
+    #   # ╞═══════════╪═════╪═════╡
+    #   # │ g1        ┆ 1   ┆ 2   │
+    #   # │ g2        ┆ 0   ┆ 3   │
+    #   # └───────────┴─────┴─────┘
     def filter(predicate)
       wrap_expr(_rbexpr.filter(predicate._rbexpr))
     end
@@ -2416,14 +2474,14 @@ module Polars
     #   ).sort("group_col")
     #   # =>
     #   # shape: (2, 3)
-    #   # ┌───────────┬──────┬─────┐
-    #   # │ group_col ┆ lt   ┆ gte │
-    #   # │ ---       ┆ ---  ┆ --- │
-    #   # │ str       ┆ i64  ┆ i64 │
-    #   # ╞═══════════╪══════╪═════╡
-    #   # │ g1        ┆ 1    ┆ 2   │
-    #   # │ g2        ┆ null ┆ 3   │
-    #   # └───────────┴──────┴─────┘
+    #   # ┌───────────┬─────┬─────┐
+    #   # │ group_col ┆ lt  ┆ gte │
+    #   # │ ---       ┆ --- ┆ --- │
+    #   # │ str       ┆ i64 ┆ i64 │
+    #   # ╞═══════════╪═════╪═════╡
+    #   # │ g1        ┆ 1   ┆ 2   │
+    #   # │ g2        ┆ 0   ┆ 3   │
+    #   # └───────────┴─────┴─────┘
     def where(predicate)
       filter(predicate)
     end
@@ -2558,25 +2616,23 @@ module Polars
     # @return [Expr]
     #
     # @example
-    #   df = Polars::DataFrame.new({"foo" => ["hello", "world"]})
-    #   df.select(Polars.col("foo").flatten)
-    #   # =>
-    #   # shape: (10, 1)
-    #   # ┌─────┐
-    #   # │ foo │
-    #   # │ --- │
-    #   # │ str │
-    #   # ╞═════╡
-    #   # │ h   │
-    #   # │ e   │
-    #   # │ l   │
-    #   # │ l   │
-    #   # │ …   │
-    #   # │ o   │
-    #   # │ r   │
-    #   # │ l   │
-    #   # │ d   │
-    #   # └─────┘
+    #  df = Polars::DataFrame.new(
+    #    {
+    #      "group" => ["a", "b", "b"],
+    #      "values" => [[1, 2], [2, 3], [4]]
+    #    }
+    #  )
+    #  df.groupby("group").agg(Polars.col("values").flatten)
+    #  # =>
+    #  # shape: (2, 2)
+    #  # ┌───────┬───────────┐
+    #  # │ group ┆ values    │
+    #  # │ ---   ┆ ---       │
+    #  # │ str   ┆ list[i64] │
+    #  # ╞═══════╪═══════════╡
+    #  # │ a     ┆ [1, 2]    │
+    #  # │ b     ┆ [2, 3, 4] │
+    #  # └───────┴───────────┘
     def flatten
       wrap_expr(_rbexpr.explode)
     end
@@ -2740,7 +2796,7 @@ module Polars
     #   # │ false    │
     #   # └──────────┘
     def is_in(other)
-      if other.is_a?(Array)
+      if other.is_a?(::Array)
         if other.length == 0
           other = Polars.lit(nil)
         else
@@ -2751,6 +2807,7 @@ module Polars
       end
       wrap_expr(_rbexpr.is_in(other._rbexpr))
     end
+    alias_method :in?, :is_in
 
     # Repeat the elements in this Series as specified in the given expression.
     #
@@ -3443,14 +3500,15 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left"
+      closed: "left",
+      ddof: 1
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
       wrap_expr(
         _rbexpr.rolling_std(
-          window_size, weights, min_periods, center, by, closed
+          window_size, weights, min_periods, center, by, closed, ddof
         )
       )
     end
@@ -3532,14 +3590,15 @@ module Polars
       min_periods: nil,
       center: false,
       by: nil,
-      closed: "left"
+      closed: "left",
+      ddof: 1
     )
       window_size, min_periods = _prepare_rolling_window_args(
         window_size, min_periods
       )
       wrap_expr(
         _rbexpr.rolling_var(
-          window_size, weights, min_periods, center, by, closed
+          window_size, weights, min_periods, center, by, closed, ddof
         )
       )
     end
@@ -3914,8 +3973,8 @@ module Polars
     #   # │ 2   │
     #   # │ 5   │
     #   # └─────┘
-    def rank(method: "average", reverse: false)
-      wrap_expr(_rbexpr.rank(method, reverse))
+    def rank(method: "average", reverse: false, seed: nil)
+      wrap_expr(_rbexpr.rank(method, reverse, seed))
     end
 
     # Calculate the n-th discrete difference.
@@ -4499,11 +4558,11 @@ module Polars
     #   # │ 1   │
     #   # │ 3   │
     #   # └─────┘
-    def shuffle(seed: nil)
+    def shuffle(seed: nil, fixed_seed: false)
       if seed.nil?
         seed = rand(10000)
       end
-      wrap_expr(_rbexpr.shuffle(seed))
+      wrap_expr(_rbexpr.shuffle(seed, fixed_seed))
     end
 
     # Sample from this expression.
@@ -4541,21 +4600,22 @@ module Polars
       with_replacement: true,
       shuffle: false,
       seed: nil,
-      n: nil
+      n: nil,
+      fixed_seed: false
     )
       if !n.nil? && !frac.nil?
         raise ArgumentError, "cannot specify both `n` and `frac`"
       end
 
       if !n.nil? && frac.nil?
-        return wrap_expr(_rbexpr.sample_n(n, with_replacement, shuffle, seed))
+        return wrap_expr(_rbexpr.sample_n(n, with_replacement, shuffle, seed, fixed_seed))
       end
 
       if frac.nil?
         frac = 1.0
       end
       wrap_expr(
-        _rbexpr.sample_frac(frac, with_replacement, shuffle, seed)
+        _rbexpr.sample_frac(frac, with_replacement, shuffle, seed, fixed_seed)
       )
     end
 
@@ -4870,8 +4930,8 @@ module Polars
     #
     # Enables downstream code to user fast paths for sorted arrays.
     #
-    # @param reverse [Boolean]
-    #   If the `Series` order is reversed, e.g. descending.
+    # @param descending [Boolean]
+    #   Whether the `Series` order is descending.
     #
     # @return [Expr]
     #
@@ -4891,9 +4951,9 @@ module Polars
     #   # ╞════════╡
     #   # │ 3      │
     #   # └────────┘
-    # def set_sorted(reverse: false)
-    #   map { |s| s.set_sorted(reverse) }
-    # end
+    def set_sorted(descending: false)
+      wrap_expr(_rbexpr.set_sorted_flag(descending))
+    end
 
     # Aggregate to list.
     #
@@ -4906,7 +4966,7 @@ module Polars
     #       "b" => [4, 5, 6]
     #     }
     #   )
-    #   df.select(Polars.all.list)
+    #   df.select(Polars.all.implode)
     #   # =>
     #   # shape: (1, 2)
     #   # ┌───────────┬───────────┐
@@ -4916,8 +4976,8 @@ module Polars
     #   # ╞═══════════╪═══════════╡
     #   # │ [1, 2, 3] ┆ [4, 5, 6] │
     #   # └───────────┴───────────┘
-    def list
-      wrap_expr(_rbexpr.list)
+    def implode
+      wrap_expr(_rbexpr.implode)
     end
 
     # Shrink numeric columns to the minimal required datatype.
@@ -4958,10 +5018,17 @@ module Polars
     # Create an object namespace of all list related methods.
     #
     # @return [ListExpr]
-    def arr
+    def list
       ListExpr.new(self)
     end
 
+    # Create an object namespace of all array related methods.
+    #
+    # @return [ArrayExpr]
+    def arr
+      ArrayExpr.new(self)
+    end
+
     # Create an object namespace of all binary related methods.
     #
     # @return [BinaryExpr]

data/lib/polars/functions.rb

@@ -43,7 +43,6 @@ module Polars
     #   # │ i64 ┆ i64 │
     #   # ╞═════╪═════╡
     #   # │ 1   ┆ 3   │
-    #   # ├╌╌╌╌╌┼╌╌╌╌╌┤
     #   # │ 2   ┆ 4   │
     #   # └─────┴─────┘
     def concat(items, rechunk: true, how: "vertical", parallel: true)

data/lib/polars/group_by.rb

@@ -551,32 +551,11 @@ module Polars
       agg(Polars.all.median)
     end
 
-    # Aggregate the groups into Series.
-    #
-    # @return [DataFrame]
-    #
-    # @example
-    #   df = Polars::DataFrame.new({"a" => ["one", "two", "one", "two"], "b" => [1, 2, 3, 4]})
-    #   df.groupby("a", maintain_order: true).agg_list
-    #   # =>
-    #   # shape: (2, 2)
-    #   # ┌─────┬─────────────────┐
-    #   # │ a   ┆ b               │
-    #   # │ --- ┆ ---             │
-    #   # │ str ┆ list[list[i64]] │
-    #   # ╞═════╪═════════════════╡
-    #   # │ one ┆ [[1, 3]]        │
-    #   # │ two ┆ [[2, 4]]        │
-    #   # └─────┴─────────────────┘
-    def agg_list
-      agg(Polars.all.list)
-    end
-
     # Plot data.
     #
     # @return [Vega::LiteChart]
     def plot(*args, **options)
-      raise ArgumentError, "Multiple groups not supported" if by.is_a?(Array) && by.size > 1
+      raise ArgumentError, "Multiple groups not supported" if by.is_a?(::Array) && by.size > 1
       # same message as Ruby
       raise ArgumentError, "unknown keyword: :group" if options.key?(:group)