polars-df 0.13.0-aarch64-linux-musl

data/lib/polars/functions/repeat.rb

@@ -0,0 +1,144 @@
+module Polars
+  module Functions
+    # Repeat a single value n times.
+    #
+    # @param value [Object]
+    #   Value to repeat.
+    # @param n [Integer]
+    #   Repeat `n` times.
+    # @param eager [Boolean]
+    #   Run eagerly and collect into a `Series`.
+    # @param name [String]
+    #   Only used in `eager` mode. As expression, use `alias`.
+    #
+    # @return [Object]
+    #
+    # @example Construct a column with a repeated value in a lazy context.
+    #   Polars.select(Polars.repeat("z", 3)).to_series
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'repeat' [str]
+    #   # [
+    #   #         "z"
+    #   #         "z"
+    #   #         "z"
+    #   # ]
+    #
+    # @example Generate a Series directly by setting `eager: true`.
+    #   Polars.repeat(3, 3, dtype: Polars::Int8, eager: true)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'repeat' [i8]
+    #   # [
+    #   #         3
+    #   #         3
+    #   #         3
+    #   # ]
+    def repeat(value, n, dtype: nil, eager: false, name: nil)
+      if !name.nil?
+        warn "the `name` argument is deprecated. Use the `alias` method instead."
+      end
+
+      if n.is_a?(Integer)
+        n = lit(n)
+      end
+
+      value = Utils.parse_into_expression(value, str_as_lit: true)
+      expr = Utils.wrap_expr(Plr.repeat(value, n._rbexpr, dtype))
+      if !name.nil?
+        expr = expr.alias(name)
+      end
+      if eager
+        return select(expr).to_series
+      end
+      expr
+    end
+
+    # Construct a column of length `n` filled with ones.
+    #
+    # This is syntactic sugar for the `repeat` function.
+    #
+    # @param n [Integer]
+    #   Length of the resulting column.
+    # @param dtype [Object]
+    #   Data type of the resulting column. Defaults to Float64.
+    # @param eager [Boolean]
+    #   Evaluate immediately and return a `Series`. If set to `false`,
+    #   return an expression instead.
+    #
+    # @return [Object]
+    #
+    # @example
+    #   Polars.ones(3, dtype: Polars::Int8, eager: true)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'ones' [i8]
+    #   # [
+    #   #         1
+    #   #         1
+    #   #         1
+    #   # ]
+    def ones(n, dtype: nil, eager: true)
+      if (zero = _one_or_zero_by_dtype(1, dtype)).nil?
+        msg = "invalid dtype for `ones`; found #{dtype}"
+        raise TypeError, msg
+      end
+
+      repeat(zero, n, dtype: dtype, eager: eager).alias("ones")
+    end
+
+    # Construct a column of length `n` filled with zeros.
+    #
+    # This is syntactic sugar for the `repeat` function.
+    #
+    # @param n [Integer]
+    #   Length of the resulting column.
+    # @param dtype [Object]
+    #   Data type of the resulting column. Defaults to Float64.
+    # @param eager [Boolean]
+    #   Evaluate immediately and return a `Series`. If set to `false`,
+    #   return an expression instead.
+    #
+    # @return [Object]
+    #
+    # @example
+    #   Polars.zeros(3, dtype: Polars::Int8, eager: true)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'zeros' [i8]
+    #   # [
+    #   #         0
+    #   #         0
+    #   #         0
+    #   # ]
+    def zeros(n, dtype: nil, eager: true)
+      if (zero = _one_or_zero_by_dtype(0, dtype)).nil?
+        msg = "invalid dtype for `zeros`; found #{dtype}"
+        raise TypeError, msg
+      end
+
+      repeat(zero, n, dtype: dtype, eager: eager).alias("zeros")
+    end
+
+    private
+
+    def _one_or_zero_by_dtype(value, dtype)
+      if dtype.integer?
+        value
+      elsif dtype.float?
+        value.to_f
+      elsif dtype == Boolean
+        value != 0
+      elsif dtype == Utf8
+        value.to_s
+      elsif dtype == Decimal
+        Decimal(value.to_s)
+      elsif [List, Array].include?(dtype)
+        arr_width = dtype.respond_to?(:width) ? dtype.width : 1
+        [_one_or_zero_by_dtype(value, dtype.inner)] * arr_width
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/polars/functions/whenthen.rb

@@ -0,0 +1,96 @@
+module Polars
+  module Functions
+    # Start a "when, then, otherwise" expression.
+    #
+    # @return [When]
+    #
+    # @example Below we add a column with the value 1, where column "foo" > 2 and the value -1 where it isn't.
+    #   df = Polars::DataFrame.new({"foo" => [1, 3, 4], "bar" => [3, 4, 0]})
+    #   df.with_column(Polars.when(Polars.col("foo") > 2).then(Polars.lit(1)).otherwise(Polars.lit(-1)))
+    #   # =>
+    #   # shape: (3, 3)
+    #   # ┌─────┬─────┬─────────┐
+    #   # │ foo ┆ bar ┆ literal │
+    #   # │ --- ┆ --- ┆ ---     │
+    #   # │ i64 ┆ i64 ┆ i32     │
+    #   # ╞═════╪═════╪═════════╡
+    #   # │ 1   ┆ 3   ┆ -1      │
+    #   # │ 3   ┆ 4   ┆ 1       │
+    #   # │ 4   ┆ 0   ┆ 1       │
+    #   # └─────┴─────┴─────────┘
+    #
+    # @example Or with multiple when-then operations chained:
+    #   df.with_columns(
+    #     Polars.when(Polars.col("foo") > 2)
+    #     .then(1)
+    #     .when(Polars.col("bar") > 2)
+    #     .then(4)
+    #     .otherwise(-1)
+    #     .alias("val")
+    #   )
+    #   # =>
+    #   # shape: (3, 3)
+    #   # ┌─────┬─────┬─────┐
+    #   # │ foo ┆ bar ┆ val │
+    #   # │ --- ┆ --- ┆ --- │
+    #   # │ i64 ┆ i64 ┆ i32 │
+    #   # ╞═════╪═════╪═════╡
+    #   # │ 1   ┆ 3   ┆ 4   │
+    #   # │ 3   ┆ 4   ┆ 1   │
+    #   # │ 4   ┆ 0   ┆ 1   │
+    #   # └─────┴─────┴─────┘
+    #
+    # @example The `otherwise` at the end is optional. If left out, any rows where none of the `when` expressions evaluate to True, are set to `null`:
+    #   df.with_columns(Polars.when(Polars.col("foo") > 2).then(1).alias("val"))
+    #   # =>
+    #   # shape: (3, 3)
+    #   # ┌─────┬─────┬──────┐
+    #   # │ foo ┆ bar ┆ val  │
+    #   # │ --- ┆ --- ┆ ---  │
+    #   # │ i64 ┆ i64 ┆ i32  │
+    #   # ╞═════╪═════╪══════╡
+    #   # │ 1   ┆ 3   ┆ null │
+    #   # │ 3   ┆ 4   ┆ 1    │
+    #   # │ 4   ┆ 0   ┆ 1    │
+    #   # └─────┴─────┴──────┘
+    #
+    # @example Pass multiple predicates, each of which must be met:
+    #   df.with_columns(
+    #     val: Polars.when(
+    #       Polars.col("bar") > 0,
+    #       Polars.col("foo") % 2 != 0
+    #     )
+    #     .then(99)
+    #     .otherwise(-1)
+    #   )
+    #   # =>
+    #   # shape: (3, 3)
+    #   # ┌─────┬─────┬─────┐
+    #   # │ foo ┆ bar ┆ val │
+    #   # │ --- ┆ --- ┆ --- │
+    #   # │ i64 ┆ i64 ┆ i32 │
+    #   # ╞═════╪═════╪═════╡
+    #   # │ 1   ┆ 3   ┆ 99  │
+    #   # │ 3   ┆ 4   ┆ 99  │
+    #   # │ 4   ┆ 0   ┆ -1  │
+    #   # └─────┴─────┴─────┘
+    #
+    # @example Pass conditions as keyword arguments:
+    #   df.with_columns(val: Polars.when(foo: 4, bar: 0).then(99).otherwise(-1))
+    #   # =>
+    #   # shape: (3, 3)
+    #   # ┌─────┬─────┬─────┐
+    #   # │ foo ┆ bar ┆ val │
+    #   # │ --- ┆ --- ┆ --- │
+    #   # │ i64 ┆ i64 ┆ i32 │
+    #   # ╞═════╪═════╪═════╡
+    #   # │ 1   ┆ 3   ┆ -1  │
+    #   # │ 3   ┆ 4   ┆ -1  │
+    #   # │ 4   ┆ 0   ┆ 99  │
+    #   # └─────┴─────┴─────┘
+    def when(*predicates, **constraints)
+      condition = Utils.parse_predicates_constraints_into_expression(*predicates, **constraints)
+      When.new(Plr.when(condition))
+    end
+  end
+end

data/lib/polars/functions.rb

@@ -0,0 +1,57 @@
+module Polars
+  module Functions
+    # Convert categorical variables into dummy/indicator variables.
+    #
+    # @param df [DataFrame]
+    #   DataFrame to convert.
+    # @param columns [Array, nil]
+    #   A subset of columns to convert to dummy variables. `nil` means
+    #   "all columns".
+    #
+    # @return [DataFrame]
+    def get_dummies(df, columns: nil)
+      df.to_dummies(columns: columns)
+    end
+
+    # Aggregate to list.
+    #
+    # @return [Expr]
+    def to_list(name)
+      col(name).list
+    end
+
+    # Compute the spearman rank correlation between two columns.
+    #
+    # Missing data will be excluded from the computation.
+    #
+    # @param a [Object]
+    #   Column name or Expression.
+    # @param b [Object]
+    #   Column name or Expression.
+    # @param ddof [Integer]
+    #   Delta degrees of freedom
+    # @param propagate_nans [Boolean]
+    #   If `True` any `NaN` encountered will lead to `NaN` in the output.
+    #   Defaults to `False` where `NaN` are regarded as larger than any finite number
+    #   and thus lead to the highest rank.
+    #
+    # @return [Expr]
+    def spearman_rank_corr(a, b, ddof: 1, propagate_nans: false)
+      corr(a, b, method: "spearman", ddof: ddof, propagate_nans: propagate_nans)
+    end
+
+    # Compute the pearson's correlation between two columns.
+    #
+    # @param a [Object]
+    #   Column name or Expression.
+    # @param b [Object]
+    #   Column name or Expression.
+    # @param ddof [Integer]
+    #   Delta degrees of freedom
+    #
+    # @return [Expr]
+    def pearson_corr(a, b, ddof: 1)
+      corr(a, b, method: "pearson", ddof: ddof)
+    end
+  end
+end