polars-df 0.1.1 → 0.1.3

data/lib/polars/expr.rb

@@ -1,78 +1,139 @@
 module Polars
+  # Expressions that can be used in various contexts.
   class Expr
+    # @private
     attr_accessor :_rbexpr
 
+    # @private
     def self._from_rbexpr(rbexpr)
       expr = Expr.allocate
       expr._rbexpr = rbexpr
       expr
     end
 
+    # Returns a string representing the Expr.
+    #
+    # @return [String]
     def to_s
       _rbexpr.to_str
     end
     alias_method :inspect, :to_s
 
+    # Bitwise XOR.
+    #
+    # @return [Expr]
     def ^(other)
       wrap_expr(_rbexpr._xor(_to_rbexpr(other)))
     end
 
+    # Bitwise AND.
+    #
+    # @return [Expr]
     def &(other)
       wrap_expr(_rbexpr._and(_to_rbexpr(other)))
     end
 
+    # Bitwise OR.
+    #
+    # @return [Expr]
     def |(other)
       wrap_expr(_rbexpr._or(_to_rbexpr(other)))
     end
 
+    # Performs addition.
+    #
+    # @return [Expr]
     def +(other)
       wrap_expr(_rbexpr + _to_rbexpr(other))
     end
 
+    # Performs subtraction.
+    #
+    # @return [Expr]
     def -(other)
       wrap_expr(_rbexpr - _to_rbexpr(other))
     end
 
+    # Performs multiplication.
+    #
+    # @return [Expr]
     def *(other)
       wrap_expr(_rbexpr * _to_rbexpr(other))
     end
 
+    # Performs division.
+    #
+    # @return [Expr]
     def /(other)
       wrap_expr(_rbexpr / _to_rbexpr(other))
     end
 
+    # Performs floor division.
+    #
+    # @return [Expr]
+    def floordiv(other)
+      wrap_expr(_rbexpr.floordiv(_to_rbexpr(other)))
+    end
+
+    # Returns the modulo.
+    #
+    # @return [Expr]
     def %(other)
       wrap_expr(_rbexpr % _to_rbexpr(other))
     end
 
+    # Raises to the power of exponent.
+    #
+    # @return [Expr]
     def **(power)
       pow(power)
     end
 
+    # Greater than or equal.
+    #
+    # @return [Expr]
     def >=(other)
       wrap_expr(_rbexpr.gt_eq(_to_expr(other)._rbexpr))
     end
 
+    # Less than or equal.
+    #
+    # @return [Expr]
     def <=(other)
       wrap_expr(_rbexpr.lt_eq(_to_expr(other)._rbexpr))
     end
 
+    # Equal.
+    #
+    # @return [Expr]
     def ==(other)
       wrap_expr(_rbexpr.eq(_to_expr(other)._rbexpr))
     end
 
+    # Not equal.
+    #
+    # @return [Expr]
     def !=(other)
       wrap_expr(_rbexpr.neq(_to_expr(other)._rbexpr))
     end
 
+    # Less than.
+    #
+    # @return [Expr]
     def <(other)
       wrap_expr(_rbexpr.lt(_to_expr(other)._rbexpr))
     end
 
+    # Greater than.
+    #
+    # @return [Expr]
     def >(other)
       wrap_expr(_rbexpr.gt(_to_expr(other)._rbexpr))
     end
 
+    # Performs negation.
+    #
+    # @return [Expr]
     def -@
       Utils.lit(0) - self
     end
@@ -80,22 +141,119 @@ module Polars
     # def to_physical
     # end
 
+    # Check if any boolean value in a Boolean column is `true`.
+    #
+    # @return [Boolean]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"TF" => [true, false], "FF" => [false, false]})
+    #   df.select(Polars.all.any)
+    #   # =>
+    #   # shape: (1, 2)
+    #   # ┌──────┬───────┐
+    #   # │ TF   ┆ FF    │
+    #   # │ ---  ┆ ---   │
+    #   # │ bool ┆ bool  │
+    #   # ╞══════╪═══════╡
+    #   # │ true ┆ false │
+    #   # └──────┴───────┘
     def any
       wrap_expr(_rbexpr.any)
     end
 
+    # Check if all boolean values in a Boolean column are `true`.
+    #
+    # This method is an expression - not to be confused with
+    # `Polars.all` which is a function to select all columns.
+    #
+    # @return [Boolean]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"TT" => [true, true], "TF" => [true, false], "FF" => [false, false]}
+    #   )
+    #   df.select(Polars.col("*").all)
+    #   # =>
+    #   # shape: (1, 3)
+    #   # ┌──────┬───────┬───────┐
+    #   # │ TT   ┆ TF    ┆ FF    │
+    #   # │ ---  ┆ ---   ┆ ---   │
+    #   # │ bool ┆ bool  ┆ bool  │
+    #   # ╞══════╪═══════╪═══════╡
+    #   # │ true ┆ false ┆ false │
+    #   # └──────┴───────┴───────┘
     def all
       wrap_expr(_rbexpr.all)
     end
 
+    # Compute the square root of the elements.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"values" => [1.0, 2.0, 4.0]})
+    #   df.select(Polars.col("values").sqrt)
+    #   # =>
+    #   # shape: (3, 1)
+    #   # ┌──────────┐
+    #   # │ values   │
+    #   # │ ---      │
+    #   # │ f64      │
+    #   # ╞══════════╡
+    #   # │ 1.0      │
+    #   # ├╌╌╌╌╌╌╌╌╌╌┤
+    #   # │ 1.414214 │
+    #   # ├╌╌╌╌╌╌╌╌╌╌┤
+    #   # │ 2.0      │
+    #   # └──────────┘
     def sqrt
-      self ** 0.5
-    end
-
+      self**0.5
+    end
+
+    # Compute the base 10 logarithm of the input array, element-wise.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"values" => [1.0, 2.0, 4.0]})
+    #   df.select(Polars.col("values").log10)
+    #   # =>
+    #   # shape: (3, 1)
+    #   # ┌─────────┐
+    #   # │ values  │
+    #   # │ ---     │
+    #   # │ f64     │
+    #   # ╞═════════╡
+    #   # │ 0.0     │
+    #   # ├╌╌╌╌╌╌╌╌╌┤
+    #   # │ 0.30103 │
+    #   # ├╌╌╌╌╌╌╌╌╌┤
+    #   # │ 0.60206 │
+    #   # └─────────┘
     def log10
       log(10)
     end
 
+    # Compute the exponential, element-wise.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"values" => [1.0, 2.0, 4.0]})
+    #   df.select(Polars.col("values").exp)
+    #   # =>
+    #   # shape: (3, 1)
+    #   # ┌──────────┐
+    #   # │ values   │
+    #   # │ ---      │
+    #   # │ f64      │
+    #   # ╞══════════╡
+    #   # │ 2.718282 │
+    #   # ├╌╌╌╌╌╌╌╌╌╌┤
+    #   # │ 7.389056 │
+    #   # ├╌╌╌╌╌╌╌╌╌╌┤
+    #   # │ 54.59815 │
+    #   # └──────────┘
     def exp
       wrap_expr(_rbexpr.exp)
     end
@@ -104,7 +262,9 @@ module Polars
       wrap_expr(_rbexpr._alias(name))
     end
 
-    # TODO support symbols
+    # TODO support symbols for exclude
+
+    #
     def exclude(columns)
       if columns.is_a?(String)
         columns = [columns]
@@ -140,22 +300,166 @@ module Polars
     # def map_alias
     # end
 
+    # Negate a boolean expression.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [true, false, false],
+    #       "b" => ["a", "b", nil]
+    #     }
+    #   )
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌───────┬──────┐
+    #   # │ a     ┆ b    │
+    #   # │ ---   ┆ ---  │
+    #   # │ bool  ┆ str  │
+    #   # ╞═══════╪══════╡
+    #   # │ true  ┆ a    │
+    #   # ├╌╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ false ┆ b    │
+    #   # ├╌╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ false ┆ null │
+    #   # └───────┴──────┘
+    #
+    # @example
+    #   df.select(Polars.col("a").is_not)
+    #   # =>
+    #   # shape: (3, 1)
+    #   # ┌───────┐
+    #   # │ a     │
+    #   # │ ---   │
+    #   # │ bool  │
+    #   # ╞═══════╡
+    #   # │ false │
+    #   # ├╌╌╌╌╌╌╌┤
+    #   # │ true  │
+    #   # ├╌╌╌╌╌╌╌┤
+    #   # │ true  │
+    #   # └───────┘
     def is_not
       wrap_expr(_rbexpr.is_not)
     end
 
+    # Returns a boolean Series indicating which values are null.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 2, nil, 1, 5],
+    #       "b" => [1.0, 2.0, Float::NAN, 1.0, 5.0]
+    #     }
+    #   )
+    #   df.with_column(Polars.all.is_null.suffix("_isnull"))
+    #   # =>
+    #   # shape: (5, 4)
+    #   # ┌──────┬─────┬──────────┬──────────┐
+    #   # │ a    ┆ b   ┆ a_isnull ┆ b_isnull │
+    #   # │ ---  ┆ --- ┆ ---      ┆ ---      │
+    #   # │ i64  ┆ f64 ┆ bool     ┆ bool     │
+    #   # ╞══════╪═════╪══════════╪══════════╡
+    #   # │ 1    ┆ 1.0 ┆ false    ┆ false    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┤
+    #   # │ 2    ┆ 2.0 ┆ false    ┆ false    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┤
+    #   # │ null ┆ NaN ┆ true     ┆ false    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┤
+    #   # │ 1    ┆ 1.0 ┆ false    ┆ false    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┤
+    #   # │ 5    ┆ 5.0 ┆ false    ┆ false    │
+    #   # └──────┴─────┴──────────┴──────────┘
     def is_null
       wrap_expr(_rbexpr.is_null)
     end
 
+    # Returns a boolean Series indicating which values are not null.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 2, nil, 1, 5],
+    #       "b" => [1.0, 2.0, Float::NAN, 1.0, 5.0]
+    #     }
+    #   )
+    #   df.with_column(Polars.all.is_not_null.suffix("_not_null"))
+    #   # =>
+    #   # shape: (5, 4)
+    #   # ┌──────┬─────┬────────────┬────────────┐
+    #   # │ a    ┆ b   ┆ a_not_null ┆ b_not_null │
+    #   # │ ---  ┆ --- ┆ ---        ┆ ---        │
+    #   # │ i64  ┆ f64 ┆ bool       ┆ bool       │
+    #   # ╞══════╪═════╪════════════╪════════════╡
+    #   # │ 1    ┆ 1.0 ┆ true       ┆ true       │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
+    #   # │ 2    ┆ 2.0 ┆ true       ┆ true       │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
+    #   # │ null ┆ NaN ┆ false      ┆ true       │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
+    #   # │ 1    ┆ 1.0 ┆ true       ┆ true       │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
+    #   # │ 5    ┆ 5.0 ┆ true       ┆ true       │
+    #   # └──────┴─────┴────────────┴────────────┘
     def is_not_null
       wrap_expr(_rbexpr.is_not_null)
     end
 
+    # Returns a boolean Series indicating which values are finite.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "A" => [1.0, 2],
+    #       "B" => [3.0, Float::INFINITY]
+    #     }
+    #   )
+    #   df.select(Polars.all.is_finite)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌──────┬───────┐
+    #   # │ A    ┆ B     │
+    #   # │ ---  ┆ ---   │
+    #   # │ bool ┆ bool  │
+    #   # ╞══════╪═══════╡
+    #   # │ true ┆ true  │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
+    #   # │ true ┆ false │
+    #   # └──────┴───────┘
     def is_finite
       wrap_expr(_rbexpr.is_finite)
     end
 
+    # Returns a boolean Series indicating which values are infinite.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "A" => [1.0, 2],
+    #       "B" => [3.0, Float::INFINITY]
+    #     }
+    #   )
+    #   df.select(Polars.all.is_infinite)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌───────┬───────┐
+    #   # │ A     ┆ B     │
+    #   # │ ---   ┆ ---   │
+    #   # │ bool  ┆ bool  │
+    #   # ╞═══════╪═══════╡
+    #   # │ false ┆ false │
+    #   # ├╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
+    #   # │ false ┆ true  │
+    #   # └───────┴───────┘
     def is_infinite
       wrap_expr(_rbexpr.is_infinite)
     end
@@ -172,14 +476,77 @@ module Polars
       wrap_expr(_rbexpr.agg_groups)
     end
 
+    # Count the number of values in this expression.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [8, 9, 10], "b" => [nil, 4, 4]})
+    #   df.select(Polars.all.count)
+    #   # =>
+    #   # shape: (1, 2)
+    #   # ┌─────┬─────┐
+    #   # │ a   ┆ b   │
+    #   # │ --- ┆ --- │
+    #   # │ u32 ┆ u32 │
+    #   # ╞═════╪═════╡
+    #   # │ 3   ┆ 3   │
+    #   # └─────┴─────┘
     def count
       wrap_expr(_rbexpr.count)
     end
 
+    # Count the number of values in this expression.
+    #
+    # Alias for {#count}.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [8, 9, 10], "b" => [nil, 4, 4]})
+    #   df.select(Polars.all.len)
+    #   # =>
+    #   # shape: (1, 2)
+    #   # ┌─────┬─────┐
+    #   # │ a   ┆ b   │
+    #   # │ --- ┆ --- │
+    #   # │ u32 ┆ u32 │
+    #   # ╞═════╪═════╡
+    #   # │ 3   ┆ 3   │
+    #   # └─────┴─────┘
     def len
       count
     end
 
+    # Get a slice of this expression.
+    #
+    # @param offset [Integer]
+    #   Start index. Negative indexing is supported.
+    # @param length [Integer]
+    #   Length of the slice. If set to `nil`, all rows starting at the offset
+    #   will be selected.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [8, 9, 10, 11],
+    #       "b" => [nil, 4, 4, 4]
+    #     }
+    #   )
+    #   df.select(Polars.all.slice(1, 2))
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────┬─────┐
+    #   # │ a   ┆ b   │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ i64 │
+    #   # ╞═════╪═════╡
+    #   # │ 9   ┆ 4   │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌┤
+    #   # │ 10  ┆ 4   │
+    #   # └─────┴─────┘
     def slice(offset, length = nil)
       if !offset.is_a?(Expr)
         offset = Polars.lit(offset)
@@ -195,14 +562,90 @@ module Polars
       wrap_expr(_rbexpr.append(other._rbexpr, upcast))
     end
 
+    # Create a single chunk of memory for this Series.
+    #
+    # @return [Expr]
+    #
+    # @example Create a Series with 3 nulls, append column a then rechunk
+    #   df = Polars::DataFrame.new({"a": [1, 1, 2]})
+    #   df.select(Polars.repeat(nil, 3).append(Polars.col("a")).rechunk)
+    #   # =>
+    #   # shape: (6, 1)
+    #   # ┌─────────┐
+    #   # │ literal │
+    #   # │ ---     │
+    #   # │ i64     │
+    #   # ╞═════════╡
+    #   # │ null    │
+    #   # ├╌╌╌╌╌╌╌╌╌┤
+    #   # │ null    │
+    #   # ├╌╌╌╌╌╌╌╌╌┤
+    #   # │ null    │
+    #   # ├╌╌╌╌╌╌╌╌╌┤
+    #   # │ 1       │
+    #   # ├╌╌╌╌╌╌╌╌╌┤
+    #   # │ 1       │
+    #   # ├╌╌╌╌╌╌╌╌╌┤
+    #   # │ 2       │
+    #   # └─────────┘
     def rechunk
       wrap_expr(_rbexpr.rechunk)
     end
 
+    # Drop null values.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [8, 9, 10, 11],
+    #       "b" => [nil, 4.0, 4.0, Float::NAN]
+    #     }
+    #   )
+    #   df.select(Polars.col("b").drop_nulls)
+    #   # =>
+    #   # shape: (3, 1)
+    #   # ┌─────┐
+    #   # │ b   │
+    #   # │ --- │
+    #   # │ f64 │
+    #   # ╞═════╡
+    #   # │ 4.0 │
+    #   # ├╌╌╌╌╌┤
+    #   # │ 4.0 │
+    #   # ├╌╌╌╌╌┤
+    #   # │ NaN │
+    #   # └─────┘
     def drop_nulls
       wrap_expr(_rbexpr.drop_nulls)
     end
 
+    # Drop floating point NaN values.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [8, 9, 10, 11],
+    #       "b" => [nil, 4.0, 4.0, Float::NAN]
+    #     }
+    #   )
+    #   df.select(Polars.col("b").drop_nans)
+    #   # =>
+    #   # shape: (3, 1)
+    #   # ┌──────┐
+    #   # │ b    │
+    #   # │ ---  │
+    #   # │ f64  │
+    #   # ╞══════╡
+    #   # │ null │
+    #   # ├╌╌╌╌╌╌┤
+    #   # │ 4.0  │
+    #   # ├╌╌╌╌╌╌┤
+    #   # │ 4.0  │
+    #   # └──────┘
     def drop_nans
       wrap_expr(_rbexpr.drop_nans)
     end
@@ -227,14 +670,87 @@ module Polars
       wrap_expr(_rbexpr.cumcount(reverse))
     end
 
+    # Rounds down to the nearest integer value.
+    #
+    # Only works on floating point Series.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [0.3, 0.5, 1.0, 1.1]})
+    #   df.select(Polars.col("a").floor)
+    #   # =>
+    #   # shape: (4, 1)
+    #   # ┌─────┐
+    #   # │ a   │
+    #   # │ --- │
+    #   # │ f64 │
+    #   # ╞═════╡
+    #   # │ 0.0 │
+    #   # ├╌╌╌╌╌┤
+    #   # │ 0.0 │
+    #   # ├╌╌╌╌╌┤
+    #   # │ 1.0 │
+    #   # ├╌╌╌╌╌┤
+    #   # │ 1.0 │
+    #   # └─────┘
     def floor
       wrap_expr(_rbexpr.floor)
     end
 
+    # Rounds up to the nearest integer value.
+    #
+    # Only works on floating point Series.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [0.3, 0.5, 1.0, 1.1]})
+    #   df.select(Polars.col("a").ceil)
+    #   # =>
+    #   # shape: (4, 1)
+    #   # ┌─────┐
+    #   # │ a   │
+    #   # │ --- │
+    #   # │ f64 │
+    #   # ╞═════╡
+    #   # │ 1.0 │
+    #   # ├╌╌╌╌╌┤
+    #   # │ 1.0 │
+    #   # ├╌╌╌╌╌┤
+    #   # │ 1.0 │
+    #   # ├╌╌╌╌╌┤
+    #   # │ 2.0 │
+    #   # └─────┘
     def ceil
       wrap_expr(_rbexpr.ceil)
     end
 
+    # Round underlying floating point data by `decimals` digits.
+    #
+    # @param decimals [Integer]
+    #   Number of decimals to round by.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [0.33, 0.52, 1.02, 1.17]})
+    #   df.select(Polars.col("a").round(1))
+    #   # =>
+    #   # shape: (4, 1)
+    #   # ┌─────┐
+    #   # │ a   │
+    #   # │ --- │
+    #   # │ f64 │
+    #   # ╞═════╡
+    #   # │ 0.3 │
+    #   # ├╌╌╌╌╌┤
+    #   # │ 0.5 │
+    #   # ├╌╌╌╌╌┤
+    #   # │ 1.0 │
+    #   # ├╌╌╌╌╌┤
+    #   # │ 1.2 │
+    #   # └─────┘
     def round(decimals = 0)
       wrap_expr(_rbexpr.round(decimals))
     end
@@ -244,6 +760,31 @@ module Polars
       wrap_expr(_rbexpr.dot(other._rbexpr))
     end
 
+    # Compute the most occurring value(s).
+    #
+    # Can return multiple Values.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 1, 2, 3],
+    #       "b" => [1, 1, 2, 2]
+    #     }
+    #   )
+    #   df.select(Polars.all.mode)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────┬─────┐
+    #   # │ a   ┆ b   │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ i64 │
+    #   # ╞═════╪═════╡
+    #   # │ 1   ┆ 1   │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌┤
+    #   # │ 1   ┆ 2   │
+    #   # └─────┴─────┘
     def mode
       wrap_expr(_rbexpr.mode)
     end
@@ -265,10 +806,50 @@ module Polars
       wrap_expr(_rbexpr.arg_sort(reverse, nulls_last))
     end
 
+    # Get the index of the maximal value.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [20, 10, 30]
+    #     }
+    #   )
+    #   df.select(Polars.col("a").arg_max)
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌─────┐
+    #   # │ a   │
+    #   # │ --- │
+    #   # │ u32 │
+    #   # ╞═════╡
+    #   # │ 2   │
+    #   # └─────┘
     def arg_max
       wrap_expr(_rbexpr.arg_max)
     end
 
+    # Get the index of the minimal value.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [20, 10, 30]
+    #     }
+    #   )
+    #   df.select(Polars.col("a").arg_min)
+    #   # =>
+    #   # shape: (1, 1)
+    #   # ┌─────┐
+    #   # │ a   │
+    #   # │ --- │
+    #   # │ u32 │
+    #   # ╞═════╡
+    #   # │ 1   │
+    #   # └─────┘
     def arg_min
       wrap_expr(_rbexpr.arg_min)
     end
@@ -290,10 +871,41 @@ module Polars
       wrap_expr(_rbexpr.sort_by(by, reverse))
     end
 
-    # def take
-    # end
-
-    def shift(periods)
+    def take(indices)
+      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)
+      end
+      wrap_expr(_rbexpr.take(indices_lit._rbexpr))
+    end
+
+    # Shift the values by a given period.
+    #
+    # @param periods [Integer]
+    #   Number of places to shift (may be negative).
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"foo" => [1, 2, 3, 4]})
+    #   df.select(Polars.col("foo").shift(1))
+    #   # =>
+    #   # shape: (4, 1)
+    #   # ┌──────┐
+    #   # │ foo  │
+    #   # │ ---  │
+    #   # │ i64  │
+    #   # ╞══════╡
+    #   # │ null │
+    #   # ├╌╌╌╌╌╌┤
+    #   # │ 1    │
+    #   # ├╌╌╌╌╌╌┤
+    #   # │ 2    │
+    #   # ├╌╌╌╌╌╌┤
+    #   # │ 3    │
+    #   # └──────┘
+    def shift(periods = 1)
       wrap_expr(_rbexpr.shift(periods))
     end
 
@@ -439,6 +1051,7 @@ module Polars
     # def apply
     # end
 
+    #
     def flatten
       wrap_expr(_rbexpr.explode)
     end
@@ -471,6 +1084,7 @@ module Polars
     # def is_in
     # end
 
+    #
     def repeat_by(by)
       by = Utils.expr_to_lit_or_expr(by, false)
       wrap_expr(_rbexpr.repeat_by(by._rbexpr))
@@ -482,6 +1096,7 @@ module Polars
     # def _hash
     # end
 
+    #
     def reinterpret(signed: false)
       wrap_expr(_rbexpr.reinterpret(signed))
     end
@@ -489,6 +1104,7 @@ module Polars
     # def _inspect
     # end
 
+    #
     def interpolate
       wrap_expr(_rbexpr.interpolate)
     end
@@ -520,6 +1136,7 @@ module Polars
     # def rolling_apply
     # end
 
+    #
     def rolling_skew(window_size, bias: true)
       wrap_expr(_rbexpr.rolling_skew(window_size, bias))
     end
@@ -647,8 +1264,10 @@ module Polars
     # def ewm_var
     # end
 
-    # def extend_constant
-    # end
+    #
+    def extend_constant(value, n)
+      wrap_expr(_rbexpr.extend_constant(value, n))
+    end
 
     def value_counts(multithreaded: false, sort: false)
       wrap_expr(_rbexpr.value_counts(multithreaded, sort))
@@ -659,7 +1278,7 @@ module Polars
     end
 
     def log(base = Math::E)
-      wrap_expr(self._rbexpr.log(base))
+      wrap_expr(_rbexpr.log(base))
     end
 
     def entropy(base: 2, normalize: false)
@@ -672,6 +1291,7 @@ module Polars
     # def set_sorted
     # end
 
+    #
     def list
       wrap_expr(_rbexpr.list)
     end