polars-df 0.4.0-x86_64-darwin → 0.5.0-x86_64-darwin

data/lib/polars/expr.rb

@@ -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,7 @@ 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")
     #     ]
     #   )
     #   # =>
@@ -1338,8 +1336,46 @@ module Polars
     #   # │ 3     ┆ 4        │
     #   # │ 2     ┆ 98       │
     #   # └───────┴──────────┘
-    def top_k(k: 5, reverse: false)
-      wrap_expr(_rbexpr.top_k(k, reverse))
+    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")
+    #     ]
+    #   )
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌───────┬──────────┐
+    #   # │ top_k ┆ bottom_k │
+    #   # │ ---   ┆ ---      │
+    #   # │ i64   ┆ i64      │
+    #   # ╞═══════╪══════════╡
+    #   # │ 99    ┆ 1        │
+    #   # │ 98    ┆ 2        │
+    #   # │ 4     ┆ 3        │
+    #   # │ 3     ┆ 4        │
+    #   # │ 2     ┆ 98       │
+    #   # └───────┴──────────┘
+    def bottom_k(k: 5)
+      wrap_expr(_rbexpr.bottom_k(k))
     end
 
     # Get the index values that would sort this column.
@@ -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      │
@@ -2751,6 +2809,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.
     #
@@ -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.
@@ -4916,9 +4975,10 @@ module Polars
     #   # ╞═══════════╪═══════════╡
     #   # │ [1, 2, 3] ┆ [4, 5, 6] │
     #   # └───────────┴───────────┘
-    def list
-      wrap_expr(_rbexpr.list)
+    def implode
+      wrap_expr(_rbexpr.implode)
     end
+    alias_method :list, :implode
 
     # Shrink numeric columns to the minimal required datatype.
     #

data/lib/polars/lazy_frame.rb

@@ -1,5 +1,5 @@
 module Polars
-  # Representation of a Lazy computation graph/query againat a DataFrame.
+  # Representation of a Lazy computation graph/query against a DataFrame.
   class LazyFrame
     # @private
     attr_accessor :_ldf
@@ -934,7 +934,7 @@ module Polars
     #     "2020-01-08 23:16:43"
     #   ]
     #   df = Polars::DataFrame.new({"dt" => dates, "a" => [3, 7, 5, 9, 2, 1]}).with_column(
-    #     Polars.col("dt").str.strptime(:datetime)
+    #     Polars.col("dt").str.strptime(Polars::Datetime)
     #   )
     #   df.groupby_rolling(index_column: "dt", period: "2d").agg(
     #     [
@@ -964,6 +964,7 @@ module Polars
       closed: "right",
       by: nil
     )
+      index_column = Utils.expr_to_lit_or_expr(index_column, str_to_lit: false)
       if offset.nil?
         offset = "-#{period}"
       end
@@ -973,7 +974,7 @@ module Polars
       offset = Utils._timedelta_to_pl_duration(offset)
 
       lgb = _ldf.groupby_rolling(
-        index_column, period, offset, closed, rbexprs_by
+        index_column._rbexpr, period, offset, closed, rbexprs_by
       )
       LazyGroupBy.new(lgb, self.class)
     end

data/lib/polars/lazy_functions.rb

@@ -1077,8 +1077,11 @@ module Polars
     #   # │ null ┆ null ┆ 3.0  ┆ 3.0  │
     #   # │ null ┆ null ┆ null ┆ 99.9 │
     #   # └──────┴──────┴──────┴──────┘
-    def coalesce(exprs)
+    def coalesce(exprs, *more_exprs)
       exprs = Utils.selection_to_rbexpr_list(exprs)
+      if more_exprs.any?
+        exprs.concat(Utils.selection_to_rbexpr_list(more_exprs))
+      end
       Utils.wrap_expr(_coalesce_exprs(exprs))
     end
 

data/lib/polars/list_expr.rb

@@ -27,7 +27,7 @@ module Polars
     #   # │ 1   │
     #   # └─────┘
     def lengths
-      Utils.wrap_expr(_rbexpr.arr_lengths)
+      Utils.wrap_expr(_rbexpr.list_lengths)
     end
 
     # Sum all the lists in the array.
@@ -48,7 +48,7 @@ module Polars
     #   # │ 5      │
     #   # └────────┘
     def sum
-      Utils.wrap_expr(_rbexpr.lst_sum)
+      Utils.wrap_expr(_rbexpr.list_sum)
     end
 
     # Compute the max value of the lists in the array.
@@ -69,7 +69,7 @@ module Polars
     #   # │ 3      │
     #   # └────────┘
     def max
-      Utils.wrap_expr(_rbexpr.lst_max)
+      Utils.wrap_expr(_rbexpr.list_max)
     end
 
     # Compute the min value of the lists in the array.
@@ -90,7 +90,7 @@ module Polars
     #   # │ 2      │
     #   # └────────┘
     def min
-      Utils.wrap_expr(_rbexpr.lst_min)
+      Utils.wrap_expr(_rbexpr.list_min)
     end
 
     # Compute the mean value of the lists in the array.
@@ -111,7 +111,7 @@ module Polars
     #   # │ 2.5    │
     #   # └────────┘
     def mean
-      Utils.wrap_expr(_rbexpr.lst_mean)
+      Utils.wrap_expr(_rbexpr.list_mean)
     end
 
     # Sort the arrays in the list.
@@ -136,7 +136,7 @@ module Polars
     #   # │ [1, 2, 9] │
     #   # └───────────┘
     def sort(reverse: false)
-      Utils.wrap_expr(_rbexpr.lst_sort(reverse))
+      Utils.wrap_expr(_rbexpr.list_sort(reverse))
     end
 
     # Reverse the arrays in the list.
@@ -161,7 +161,7 @@ module Polars
     #   # │ [2, 1, 9] │
     #   # └───────────┘
     def reverse
-      Utils.wrap_expr(_rbexpr.lst_reverse)
+      Utils.wrap_expr(_rbexpr.list_reverse)
     end
 
     # Get the unique/distinct values in the list.
@@ -184,8 +184,8 @@ module Polars
     #   # ╞═══════════╡
     #   # │ [1, 2]    │
     #   # └───────────┘
-    def unique
-      Utils.wrap_expr(_rbexpr.lst_unique)
+    def unique(maintain_order: false)
+      Utils.wrap_expr(_rbexpr.list_unique(maintain_order))
     end
 
     # Concat the arrays in a Series dtype List in linear time.
@@ -255,7 +255,7 @@ module Polars
     #   # └──────┘
     def get(index)
       index = Utils.expr_to_lit_or_expr(index, str_to_lit: false)._rbexpr
-      Utils.wrap_expr(_rbexpr.lst_get(index))
+      Utils.wrap_expr(_rbexpr.list_get(index))
     end
 
     # Get the value by index in the sublists.
@@ -265,6 +265,28 @@ module Polars
       get(item)
     end
 
+    # Take sublists by multiple indices.
+    #
+    # The indices may be defined in a single column, or by sublists in another
+    # column of dtype `List`.
+    #
+    # @param index [Object]
+    #   Indices to return per sublist
+    # @param null_on_oob [Boolean]
+    #   Behavior if an index is out of bounds:
+    #   True -> set as null
+    #   False -> raise an error
+    #   Note that defaulting to raising an error is much cheaper
+    #
+    # @return [Expr]
+    def take(index, null_on_oob: false)
+      if index.is_a?(Array)
+        index = Series.new(index)
+      end
+      index = Utils.expr_to_lit_or_expr(index, str_to_lit: false)._rbexpr
+      Utils.wrap_expr(_rbexpr.list_take(index, null_on_oob))
+    end
+
     # Get the first value of the sublists.
     #
     # @return [Expr]
@@ -331,7 +353,7 @@ module Polars
     #   # │ true  │
     #   # └───────┘
     def contains(item)
-      Utils.wrap_expr(_rbexpr.arr_contains(Utils.expr_to_lit_or_expr(item)._rbexpr))
+      Utils.wrap_expr(_rbexpr.list_contains(Utils.expr_to_lit_or_expr(item)._rbexpr))
     end
 
     # Join all string items in a sublist and place a separator between them.
@@ -357,7 +379,7 @@ module Polars
     #   # │ x y   │
     #   # └───────┘
     def join(separator)
-      Utils.wrap_expr(_rbexpr.lst_join(separator))
+      Utils.wrap_expr(_rbexpr.list_join(separator))
     end
 
     # Retrieve the index of the minimal value in every sublist.
@@ -382,7 +404,7 @@ module Polars
     #   # │ 1   │
     #   # └─────┘
     def arg_min
-      Utils.wrap_expr(_rbexpr.lst_arg_min)
+      Utils.wrap_expr(_rbexpr.list_arg_min)
     end
 
     # Retrieve the index of the maximum value in every sublist.
@@ -407,7 +429,7 @@ module Polars
     #   # │ 0   │
     #   # └─────┘
     def arg_max
-      Utils.wrap_expr(_rbexpr.lst_arg_max)
+      Utils.wrap_expr(_rbexpr.list_arg_max)
     end
 
     # Calculate the n-th discrete difference of every sublist.
@@ -430,7 +452,7 @@ module Polars
     #   #         [null, -8, -1]
     #   # ]
     def diff(n: 1, null_behavior: "ignore")
-      Utils.wrap_expr(_rbexpr.lst_diff(n, null_behavior))
+      Utils.wrap_expr(_rbexpr.list_diff(n, null_behavior))
     end
 
     # Shift values by the given period.
@@ -451,7 +473,7 @@ module Polars
     #   #         [null, 10, 2]
     #   # ]
     def shift(periods = 1)
-      Utils.wrap_expr(_rbexpr.lst_shift(periods))
+      Utils.wrap_expr(_rbexpr.list_shift(periods))
     end
 
     # Slice every sublist.
@@ -477,7 +499,7 @@ module Polars
     def slice(offset, length = nil)
       offset = Utils.expr_to_lit_or_expr(offset, str_to_lit: false)._rbexpr
       length = Utils.expr_to_lit_or_expr(length, str_to_lit: false)._rbexpr
-      Utils.wrap_expr(_rbexpr.lst_slice(offset, length))
+      Utils.wrap_expr(_rbexpr.list_slice(offset, length))
     end
 
     # Slice the first `n` values of every sublist.
@@ -523,6 +545,33 @@ module Polars
       slice(offset, n)
     end
 
+    # Count how often the value produced by ``element`` occurs.
+    #
+    # @param element [Expr]
+    #   An expression that produces a single value
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"listcol" => [[0], [1], [1, 2, 3, 2], [1, 2, 1], [4, 4]]})
+    #   df.select(Polars.col("listcol").arr.count_match(2).alias("number_of_twos"))
+    #   # =>
+    #   # shape: (5, 1)
+    #   # ┌────────────────┐
+    #   # │ number_of_twos │
+    #   # │ ---            │
+    #   # │ u32            │
+    #   # ╞════════════════╡
+    #   # │ 0              │
+    #   # │ 0              │
+    #   # │ 2              │
+    #   # │ 1              │
+    #   # │ 0              │
+    #   # └────────────────┘
+    def count_match(element)
+      Utils.wrap_expr(_rbexpr.list_count_match(Utils.expr_to_lit_or_expr(element)._rbexpr))
+    end
+
     # Convert the series of type `List` to a series of type `Struct`.
     #
     # @param n_field_strategy ["first_non_null", "max_width"]
@@ -548,7 +597,7 @@ module Polars
     #   # └────────────┘
     def to_struct(n_field_strategy: "first_non_null", name_generator: nil)
       raise Todo if name_generator
-      Utils.wrap_expr(_rbexpr.lst_to_struct(n_field_strategy, name_generator, 0))
+      Utils.wrap_expr(_rbexpr.list_to_struct(n_field_strategy, name_generator, 0))
     end
 
     # Run any polars expression against the lists' elements.
@@ -582,7 +631,7 @@ module Polars
     #   # │ 3   ┆ 2   ┆ [2.0, 1.0] │
     #   # └─────┴─────┴────────────┘
     def eval(expr, parallel: false)
-       Utils.wrap_expr(_rbexpr.lst_eval(expr._rbexpr, parallel))
+      Utils.wrap_expr(_rbexpr.list_eval(expr._rbexpr, parallel))
     end
   end
 end