polars-df 0.5.0-x86_64-darwin → 0.7.0-x86_64-darwin

data/lib/polars/lazy_functions.rb

@@ -14,7 +14,7 @@ module Polars
 
       if name.is_a?(DataType)
         Utils.wrap_expr(_dtype_cols([name]))
-      elsif name.is_a?(Array)
+      elsif name.is_a?(::Array)
         if name.length == 0 || Utils.strlike?(name[0])
           name = name.map { |v| v.is_a?(Symbol) ? v.to_s : v }
           Utils.wrap_expr(RbExpr.cols(name))
@@ -36,14 +36,14 @@ module Polars
     # @example A horizontal rank computation by taking the elements of a list
     #   df = Polars::DataFrame.new({"a" => [1, 8, 3], "b" => [4, 5, 2]})
     #   df.with_column(
-    #     Polars.concat_list(["a", "b"]).arr.eval(Polars.element.rank).alias("rank")
+    #     Polars.concat_list(["a", "b"]).list.eval(Polars.element.rank).alias("rank")
     #   )
     #   # =>
     #   # shape: (3, 3)
     #   # ┌─────┬─────┬────────────┐
     #   # │ a   ┆ b   ┆ rank       │
     #   # │ --- ┆ --- ┆ ---        │
-    #   # │ i64 ┆ i64 ┆ list[f32]  │
+    #   # │ i64 ┆ i64 ┆ list[f64]  │
     #   # ╞═════╪═════╪════════════╡
     #   # │ 1   ┆ 4   ┆ [1.0, 2.0] │
     #   # │ 8   ┆ 5   ┆ [2.0, 1.0] │
@@ -156,10 +156,9 @@ module Polars
         column.sum
       elsif Utils.strlike?(column)
         col(column.to_s).sum
-      elsif column.is_a?(Array)
+      elsif column.is_a?(::Array)
         exprs = Utils.selection_to_rbexpr_list(column)
-        # TODO
-        Utils.wrap_expr(_sum_exprs(exprs))
+        Utils.wrap_expr(_sum_horizontal(exprs))
       else
         fold(lit(0).cast(:u32), ->(a, b) { a + b }, column).alias("sum")
       end
@@ -283,18 +282,33 @@ module Polars
     # Return an expression representing a literal value.
     #
     # @return [Expr]
-    def lit(value)
-      if value.is_a?(Polars::Series)
+    def lit(value, dtype: nil, allow_object: nil)
+      if value.is_a?(::Time) || value.is_a?(::DateTime)
+        time_unit = dtype&.time_unit || "ns"
+        time_zone = dtype.&time_zone
+        e = lit(Utils._datetime_to_pl_timestamp(value, time_unit)).cast(Datetime.new(time_unit))
+        if time_zone
+          return e.dt.replace_time_zone(time_zone.to_s)
+        else
+          return e
+        end
+      elsif value.is_a?(::Date)
+        return lit(::Time.utc(value.year, value.month, value.day)).cast(Date)
+      elsif value.is_a?(Polars::Series)
         name = value.name
         value = value._s
-        e = Utils.wrap_expr(RbExpr.lit(value))
+        e = Utils.wrap_expr(RbExpr.lit(value, allow_object))
         if name == ""
           return e
         end
         return e.alias(name)
+      elsif (defined?(Numo::NArray) && value.is_a?(Numo::NArray)) || value.is_a?(::Array)
+        return lit(Series.new("", value))
+      elsif dtype
+        return Utils.wrap_expr(RbExpr.lit(value, allow_object)).cast(dtype)
       end
 
-      Utils.wrap_expr(RbExpr.lit(value))
+      Utils.wrap_expr(RbExpr.lit(value, allow_object))
     end
 
     # Cumulatively sum values in a column/Series, or horizontally across list of columns/expressions.
@@ -611,39 +625,43 @@ module Polars
     # This can be used in a `select`, `with_column`, etc. Be sure that the resulting
     # range size is equal to the length of the DataFrame you are collecting.
     #
-    # @param low [Integer, Expr, Series]
+    # @param start [Integer, Expr, Series]
     #   Lower bound of range.
-    # @param high [Integer, Expr, Series]
+    # @param stop [Integer, Expr, Series]
     #   Upper bound of range.
     # @param step [Integer]
     #   Step size of the range.
     # @param eager [Boolean]
     #   If eager evaluation is `True`, a Series is returned instead of an Expr.
     # @param dtype [Symbol]
-    #   Apply an explicit integer dtype to the resulting expression (default is `:i64`).
+    #   Apply an explicit integer dtype to the resulting expression (default is `Int64`).
     #
     # @return [Expr, Series]
     #
     # @example
-    #   df.lazy.filter(Polars.col("foo") < Polars.arange(0, 100)).collect
-    def arange(low, high, step: 1, eager: false, dtype: nil)
-      low = Utils.expr_to_lit_or_expr(low, str_to_lit: false)
-      high = Utils.expr_to_lit_or_expr(high, str_to_lit: false)
-      range_expr = Utils.wrap_expr(RbExpr.arange(low._rbexpr, high._rbexpr, step))
-
-      if !dtype.nil? && dtype != "i64"
-        range_expr = range_expr.cast(dtype)
-      end
+    #   Polars.arange(0, 3, eager: true)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'arange' [i64]
+    #   # [
+    #   #         0
+    #   #         1
+    #   #         2
+    #   # ]
+    def int_range(start, stop, step: 1, eager: false, dtype: nil)
+      start = Utils.parse_as_expression(start)
+      stop = Utils.parse_as_expression(stop)
+      dtype ||= Int64
+      dtype = dtype.to_s if dtype.is_a?(Symbol)
+      result = Utils.wrap_expr(RbExpr.int_range(start, stop, step, dtype)).alias("arange")
 
-      if !eager
-        range_expr
-      else
-        DataFrame.new
-          .select(range_expr)
-          .to_series
-          .rename("arange", in_place: true)
+      if eager
+        return select(result).to_series
       end
+
+      result
     end
+    alias_method :arange, :int_range
 
     # Find the indexes that would sort the columns.
     #
@@ -658,7 +676,7 @@ module Polars
     #
     # @return [Expr]
     def arg_sort_by(exprs, reverse: false)
-      if !exprs.is_a?(Array)
+      if !exprs.is_a?(::Array)
         exprs = [exprs]
       end
       if reverse == true || reverse == false
@@ -702,15 +720,22 @@ module Polars
     #   # │ 2022-01-16 00:00:00 ┆ 2022-01-04 00:00:00 ┆ 2022-01-02 00:00:02 ┆ 2022-01-02 00:00:00.002 ┆ 2022-01-02 02:00:00 │
     #   # └─────────────────────┴─────────────────────┴─────────────────────┴─────────────────────────┴─────────────────────┘
     def duration(
+      weeks: nil,
       days: nil,
+      hours: nil,
+      minutes: nil,
       seconds: nil,
-      nanoseconds: nil,
-      microseconds: nil,
       milliseconds: nil,
-      minutes: nil,
-      hours: nil,
-      weeks: nil
+      microseconds: nil,
+      nanoseconds: nil,
+      time_unit: "us"
     )
+      if !weeks.nil?
+        weeks = Utils.expr_to_lit_or_expr(weeks, str_to_lit: false)._rbexpr
+      end
+      if !days.nil?
+        days = Utils.expr_to_lit_or_expr(days, str_to_lit: false)._rbexpr
+      end
       if !hours.nil?
         hours = Utils.expr_to_lit_or_expr(hours, str_to_lit: false)._rbexpr
       end
@@ -729,23 +754,18 @@ module Polars
       if !nanoseconds.nil?
         nanoseconds = Utils.expr_to_lit_or_expr(nanoseconds, str_to_lit: false)._rbexpr
       end
-      if !days.nil?
-        days = Utils.expr_to_lit_or_expr(days, str_to_lit: false)._rbexpr
-      end
-      if !weeks.nil?
-        weeks = Utils.expr_to_lit_or_expr(weeks, str_to_lit: false)._rbexpr
-      end
 
       Utils.wrap_expr(
         _rb_duration(
+          weeks,
           days,
+          hours,
+          minutes,
           seconds,
-          nanoseconds,
-          microseconds,
           milliseconds,
-          minutes,
-          hours,
-          weeks
+          microseconds,
+          nanoseconds,
+          time_unit
         )
       )
     end
@@ -911,7 +931,8 @@ module Polars
           simplify_expression,
           slice_pushdown,
           common_subplan_elimination,
-          allow_streaming
+          allow_streaming,
+          false
         )
         prepared << ldf
       end
@@ -997,19 +1018,24 @@ module Polars
     #   Only used in `eager` mode. As expression, use `alias`.
     #
     # @return [Expr]
-    def repeat(value, n, eager: false, name: nil)
+    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_as_expression(value, str_as_lit: true)
+      expr = Utils.wrap_expr(RbExpr.repeat(value, n._rbexpr, dtype))
+      if !name.nil?
+        expr = expr.alias(name)
+      end
       if eager
-        if name.nil?
-          name = ""
-        end
-        dtype = py_type_to_dtype(type(value))
-        Series._repeat(name, value, n, dtype)
-      else
-        if n.is_a?(Integer)
-          n = lit(n)
-        end
-        Utils.wrap_expr(RbExpr.repeat(value, n._rbexpr))
+        return select(expr).to_series
       end
+      expr
     end
 
     # Return indices where `condition` evaluates `true`.
@@ -1124,13 +1150,11 @@ module Polars
       end
 
       if unit == "d"
-        expr = column.cast(:date)
+        expr = column.cast(Date)
       elsif unit == "s"
-        raise Todo
-        # expr = (column.cast(:i64) * 1_000_000).cast(Datetime("us"))
+        expr = (column.cast(Int64) * 1_000_000).cast(Datetime.new("us"))
       elsif Utils::DTYPE_TEMPORAL_UNITS.include?(unit)
-        raise Todo
-        # expr = column.cast(Datetime(unit))
+        expr = column.cast(Datetime.new(unit))
       else
         raise ArgumentError, "'unit' must be one of {{'ns', 'us', 'ms', 's', 'd'}}, got '#{unit}'."
       end

data/lib/polars/lazy_group_by.rb

@@ -1,10 +1,9 @@
 module Polars
-  # Created by `df.lazy.groupby("foo")`.
+  # Created by `df.lazy.group_by("foo")`.
   class LazyGroupBy
     # @private
-    def initialize(lgb, lazyframe_class)
+    def initialize(lgb)
       @lgb = lgb
-      @lazyframe_class = lazyframe_class
     end
 
     # Describe the aggregation that need to be done on a group.
@@ -12,7 +11,7 @@ module Polars
     # @return [LazyFrame]
     def agg(aggs)
       rbexprs = Utils.selection_to_rbexpr_list(aggs)
-      @lazyframe_class._from_rbldf(@lgb.agg(rbexprs))
+      Utils.wrap_ldf(@lgb.agg(rbexprs))
     end
 
     # Get the first `n` rows of each group.
@@ -29,7 +28,7 @@ module Polars
     #       "nrs" => [1, 2, 3, 4, 5, 6]
     #     }
     #   )
-    #   df.groupby("letters").head(2).sort("letters")
+    #   df.group_by("letters").head(2).sort("letters")
     #   # =>
     #   # shape: (5, 2)
     #   # ┌─────────┬─────┐
@@ -44,7 +43,7 @@ module Polars
     #   # │ c       ┆ 2   │
     #   # └─────────┴─────┘
     def head(n = 5)
-      @lazyframe_class._from_rbldf(@lgb.head(n))
+      Utils.wrap_ldf(@lgb.head(n))
     end
 
     # Get the last `n` rows of each group.
@@ -61,7 +60,7 @@ module Polars
     #       "nrs" => [1, 2, 3, 4, 5, 6]
     #     }
     #   )
-    #   df.groupby("letters").tail(2).sort("letters")
+    #   df.group_by("letters").tail(2).sort("letters")
     #   # =>
     #   # shape: (5, 2)
     #   # ┌─────────┬─────┐
@@ -76,7 +75,7 @@ module Polars
     #   # │ c       ┆ 4   │
     #   # └─────────┴─────┘
     def tail(n = 5)
-      @lazyframe_class._from_rbldf(@lgb.tail(n))
+      Utils.wrap_ldf(@lgb.tail(n))
     end
 
     # def apply

data/lib/polars/list_expr.rb

@@ -15,7 +15,7 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"foo" => [1, 2], "bar" => [["a", "b"], ["c"]]})
-    #   df.select(Polars.col("bar").arr.lengths)
+    #   df.select(Polars.col("bar").list.lengths)
     #   # =>
     #   # shape: (2, 1)
     #   # ┌─────┐
@@ -27,8 +27,9 @@ module Polars
     #   # │ 1   │
     #   # └─────┘
     def lengths
-      Utils.wrap_expr(_rbexpr.list_lengths)
+      Utils.wrap_expr(_rbexpr.list_len)
     end
+    alias_method :len, :lengths
 
     # Sum all the lists in the array.
     #
@@ -36,7 +37,7 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"values" => [[1], [2, 3]]})
-    #   df.select(Polars.col("values").arr.sum)
+    #   df.select(Polars.col("values").list.sum)
     #   # =>
     #   # shape: (2, 1)
     #   # ┌────────┐
@@ -57,7 +58,7 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"values" => [[1], [2, 3]]})
-    #   df.select(Polars.col("values").arr.max)
+    #   df.select(Polars.col("values").list.max)
     #   # =>
     #   # shape: (2, 1)
     #   # ┌────────┐
@@ -78,7 +79,7 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"values" => [[1], [2, 3]]})
-    #   df.select(Polars.col("values").arr.min)
+    #   df.select(Polars.col("values").list.min)
     #   # =>
     #   # shape: (2, 1)
     #   # ┌────────┐
@@ -99,7 +100,7 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"values" => [[1], [2, 3]]})
-    #   df.select(Polars.col("values").arr.mean)
+    #   df.select(Polars.col("values").list.mean)
     #   # =>
     #   # shape: (2, 1)
     #   # ┌────────┐
@@ -124,7 +125,7 @@ module Polars
     #       "a" => [[3, 2, 1], [9, 1, 2]]
     #     }
     #   )
-    #   df.select(Polars.col("a").arr.sort)
+    #   df.select(Polars.col("a").list.sort)
     #   # =>
     #   # shape: (2, 1)
     #   # ┌───────────┐
@@ -149,7 +150,7 @@ module Polars
     #       "a" => [[3, 2, 1], [9, 1, 2]]
     #     }
     #   )
-    #   df.select(Polars.col("a").arr.reverse)
+    #   df.select(Polars.col("a").list.reverse)
     #   # =>
     #   # shape: (2, 1)
     #   # ┌───────────┐
@@ -174,7 +175,7 @@ module Polars
     #       "a" => [[1, 1, 2]]
     #     }
     #   )
-    #   df.select(Polars.col("a").arr.unique)
+    #   df.select(Polars.col("a").list.unique)
     #   # =>
     #   # shape: (1, 1)
     #   # ┌───────────┐
@@ -202,7 +203,7 @@ module Polars
     #       "b" => [["b", "c"], ["y", "z"]]
     #     }
     #   )
-    #   df.select(Polars.col("a").arr.concat("b"))
+    #   df.select(Polars.col("a").list.concat("b"))
     #   # =>
     #   # shape: (2, 1)
     #   # ┌─────────────────┐
@@ -214,11 +215,11 @@ module Polars
     #   # │ ["x", "y", "z"] │
     #   # └─────────────────┘
     def concat(other)
-      if other.is_a?(Array) && ![Expr, String, Series].any? { |c| other[0].is_a?(c) }
+      if other.is_a?(::Array) && ![Expr, String, Series].any? { |c| other[0].is_a?(c) }
         return concat(Series.new([other]))
       end
 
-      if !other.is_a?(Array)
+      if !other.is_a?(::Array)
         other_list = [other]
       else
         other_list = other.dup
@@ -241,7 +242,7 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"foo" => [[3, 2, 1], [], [1, 2]]})
-    #   df.select(Polars.col("foo").arr.get(0))
+    #   df.select(Polars.col("foo").list.get(0))
     #   # =>
     #   # shape: (3, 1)
     #   # ┌──────┐
@@ -254,7 +255,7 @@ module Polars
     #   # │ 1    │
     #   # └──────┘
     def get(index)
-      index = Utils.expr_to_lit_or_expr(index, str_to_lit: false)._rbexpr
+      index = Utils.parse_as_expression(index)
       Utils.wrap_expr(_rbexpr.list_get(index))
     end
 
@@ -280,7 +281,7 @@ module Polars
     #
     # @return [Expr]
     def take(index, null_on_oob: false)
-      if index.is_a?(Array)
+      if index.is_a?(::Array)
         index = Series.new(index)
       end
       index = Utils.expr_to_lit_or_expr(index, str_to_lit: false)._rbexpr
@@ -293,7 +294,7 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"foo" => [[3, 2, 1], [], [1, 2]]})
-    #   df.select(Polars.col("foo").arr.first)
+    #   df.select(Polars.col("foo").list.first)
     #   # =>
     #   # shape: (3, 1)
     #   # ┌──────┐
@@ -315,7 +316,7 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"foo" => [[3, 2, 1], [], [1, 2]]})
-    #   df.select(Polars.col("foo").arr.last)
+    #   df.select(Polars.col("foo").list.last)
     #   # =>
     #   # shape: (3, 1)
     #   # ┌──────┐
@@ -340,7 +341,7 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"foo" => [[3, 2, 1], [], [1, 2]]})
-    #   df.select(Polars.col("foo").arr.contains(1))
+    #   df.select(Polars.col("foo").list.contains(1))
     #   # =>
     #   # shape: (3, 1)
     #   # ┌───────┐
@@ -367,7 +368,7 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"s" => [["a", "b", "c"], ["x", "y"]]})
-    #   df.select(Polars.col("s").arr.join(" "))
+    #   df.select(Polars.col("s").list.join(" "))
     #   # =>
     #   # shape: (2, 1)
     #   # ┌───────┐
@@ -379,6 +380,7 @@ module Polars
     #   # │ x y   │
     #   # └───────┘
     def join(separator)
+      separator = Utils.parse_as_expression(separator, str_as_lit: true)
       Utils.wrap_expr(_rbexpr.list_join(separator))
     end
 
@@ -392,7 +394,7 @@ module Polars
     #       "a" => [[1, 2], [2, 1]]
     #     }
     #   )
-    #   df.select(Polars.col("a").arr.arg_min)
+    #   df.select(Polars.col("a").list.arg_min)
     #   # =>
     #   # shape: (2, 1)
     #   # ┌─────┐
@@ -417,7 +419,7 @@ module Polars
     #       "a" => [[1, 2], [2, 1]]
     #     }
     #   )
-    #   df.select(Polars.col("a").arr.arg_max)
+    #   df.select(Polars.col("a").list.arg_max)
     #   # =>
     #   # shape: (2, 1)
     #   # ┌─────┐
@@ -443,7 +445,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new("a", [[1, 2, 3, 4], [10, 2, 1]])
-    #   s.arr.diff
+    #   s.list.diff
     #   # =>
     #   # shape: (2,)
     #   # Series: 'a' [list[i64]]
@@ -457,14 +459,14 @@ module Polars
 
     # Shift values by the given period.
     #
-    # @param periods [Integer]
+    # @param n [Integer]
     #   Number of places to shift (may be negative).
     #
     # @return [Expr]
     #
     # @example
     #   s = Polars::Series.new("a", [[1, 2, 3, 4], [10, 2, 1]])
-    #   s.arr.shift
+    #   s.list.shift
     #   # =>
     #   # shape: (2,)
     #   # Series: 'a' [list[i64]]
@@ -472,8 +474,9 @@ module Polars
     #   #         [null, 1, … 3]
     #   #         [null, 10, 2]
     #   # ]
-    def shift(periods = 1)
-      Utils.wrap_expr(_rbexpr.list_shift(periods))
+    def shift(n = 1)
+      n = Utils.parse_as_expression(n)
+      Utils.wrap_expr(_rbexpr.list_shift(n))
     end
 
     # Slice every sublist.
@@ -488,7 +491,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new("a", [[1, 2, 3, 4], [10, 2, 1]])
-    #   s.arr.slice(1, 2)
+    #   s.list.slice(1, 2)
     #   # =>
     #   # shape: (2,)
     #   # Series: 'a' [list[i64]]
@@ -511,7 +514,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new("a", [[1, 2, 3, 4], [10, 2, 1]])
-    #   s.arr.head(2)
+    #   s.list.head(2)
     #   # =>
     #   # shape: (2,)
     #   # Series: 'a' [list[i64]]
@@ -532,7 +535,7 @@ module Polars
     #
     # @example
     #   s = Polars::Series.new("a", [[1, 2, 3, 4], [10, 2, 1]])
-    #   s.arr.tail(2)
+    #   s.list.tail(2)
     #   # =>
     #   # shape: (2,)
     #   # Series: 'a' [list[i64]]
@@ -554,7 +557,7 @@ module Polars
     #
     # @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"))
+    #   df.select(Polars.col("listcol").list.count_match(2).alias("number_of_twos"))
     #   # =>
     #   # shape: (5, 1)
     #   # ┌────────────────┐
@@ -568,9 +571,10 @@ module Polars
     #   # │ 1              │
     #   # │ 0              │
     #   # └────────────────┘
-    def count_match(element)
-      Utils.wrap_expr(_rbexpr.list_count_match(Utils.expr_to_lit_or_expr(element)._rbexpr))
+    def count_matches(element)
+      Utils.wrap_expr(_rbexpr.list_count_matches(Utils.expr_to_lit_or_expr(element)._rbexpr))
     end
+    alias_method :count_match, :count_matches
 
     # Convert the series of type `List` to a series of type `Struct`.
     #
@@ -584,7 +588,7 @@ module Polars
     #
     # @example
     #   df = Polars::DataFrame.new({"a" => [[1, 2, 3], [1, 2]]})
-    #   df.select([Polars.col("a").arr.to_struct])
+    #   df.select([Polars.col("a").list.to_struct])
     #   # =>
     #   # shape: (2, 1)
     #   # ┌────────────┐
@@ -609,7 +613,7 @@ module Polars
     #   Run all expression parallel. Don't activate this blindly.
     #   Parallelism is worth it if there is enough work to do per thread.
     #
-    #   This likely should not be use in the groupby context, because we already
+    #   This likely should not be use in the group by context, because we already
     #   parallel execution per group
     #
     # @return [Expr]
@@ -617,14 +621,14 @@ module Polars
     # @example
     #   df = Polars::DataFrame.new({"a" => [1, 8, 3], "b" => [4, 5, 2]})
     #   df.with_column(
-    #     Polars.concat_list(["a", "b"]).arr.eval(Polars.element.rank).alias("rank")
+    #     Polars.concat_list(["a", "b"]).list.eval(Polars.element.rank).alias("rank")
     #   )
     #   # =>
     #   # shape: (3, 3)
     #   # ┌─────┬─────┬────────────┐
     #   # │ a   ┆ b   ┆ rank       │
     #   # │ --- ┆ --- ┆ ---        │
-    #   # │ i64 ┆ i64 ┆ list[f32]  │
+    #   # │ i64 ┆ i64 ┆ list[f64]  │
     #   # ╞═════╪═════╪════════════╡
     #   # │ 1   ┆ 4   ┆ [1.0, 2.0] │
     #   # │ 8   ┆ 5   ┆ [2.0, 1.0] │