polars-df 0.1.2 → 0.1.4

data/lib/polars/series.rb

@@ -1,8 +1,7 @@
 module Polars
   # A Series represents a single column in a polars DataFrame.
   class Series
-    # @private
-    attr_accessor :_s
+    include ExprDispatch
 
     # Create a new Series.
     #
@@ -48,6 +47,8 @@ module Polars
 
       if values.nil?
         self._s = sequence_to_rbseries(name, [], dtype: dtype, dtype_if_empty: dtype_if_empty)
+      elsif values.is_a?(Series)
+        self._s = series_to_rbseries(name, values)
       elsif values.is_a?(Range)
         self._s =
           Polars.arange(
@@ -130,6 +131,9 @@ module Polars
     #
     # @return [Series]
     def &(other)
+      if !other.is_a?(Series)
+        other = Series.new([other])
+      end
       Utils.wrap_s(_s.bitand(other._s))
     end
 
@@ -137,6 +141,9 @@ module Polars
     #
     # @return [Series]
     def |(other)
+      if !other.is_a?(Series)
+        other = Series.new([other])
+      end
       Utils.wrap_s(_s.bitor(other._s))
     end
 
@@ -144,53 +151,90 @@ module Polars
     #
     # @return [Series]
     def ^(other)
+      if !other.is_a?(Series)
+        other = Series.new([other])
+      end
       Utils.wrap_s(_s.bitxor(other._s))
     end
 
-    # def ==(other)
-    # end
+    # Equal.
+    #
+    # @return [Series]
+    def ==(other)
+      _comp(other, :eq)
+    end
 
-    # def !=(other)
-    # end
+    # Not equal.
+    #
+    # @return [Series]
+    def !=(other)
+      _comp(other, :neq)
+    end
 
-    # def >(other)
-    # end
+    # Greater than.
+    #
+    # @return [Series]
+    def >(other)
+      _comp(other, :gt)
+    end
 
-    # def <(other)
-    # end
+    # Less than.
+    #
+    # @return [Series]
+    def <(other)
+      _comp(other, :lt)
+    end
 
-    # def >=(other)
-    # end
+    # Greater than or equal.
+    #
+    # @return [Series]
+    def >=(other)
+      _comp(other, :gt_eq)
+    end
 
-    # def <=(other)
-    # end
+    # Less than or equal.
+    #
+    # @return [Series]
+    def <=(other)
+      _comp(other, :lt_eq)
+    end
 
     # Performs addition.
     #
     # @return [Series]
     def +(other)
-     Utils. wrap_s(_s.add(other._s))
+      _arithmetic(other, :add)
     end
 
     # Performs subtraction.
     #
     # @return [Series]
     def -(other)
-      Utils.wrap_s(_s.sub(other._s))
+      _arithmetic(other, :sub)
     end
 
     # Performs multiplication.
     #
     # @return [Series]
     def *(other)
-      Utils.wrap_s(_s.mul(other._s))
+      _arithmetic(other, :mul)
     end
 
     # Performs division.
     #
     # @return [Series]
     def /(other)
-      Utils.wrap_s(_s.div(other._s))
+      _arithmetic(other, :div)
+    end
+
+    # Returns the modulo.
+    #
+    # @return [Series]
+    def %(other)
+      if is_datelike
+        raise ArgumentError, "first cast to integer before applying modulo on datelike dtypes"
+      end
+      _arithmetic(other, :rem)
     end
 
     # Raises to the power of exponent.
@@ -203,18 +247,63 @@ module Polars
       to_frame.select(Polars.col(name).pow(power)).to_series
     end
 
-    # def -@(other)
-    # end
+    # Performs negation.
+    #
+    # @return [Series]
+    def -@
+      0 - self
+    end
 
     # Returns elements of the Series.
     #
     # @return [Object]
     def [](item)
-      _s.get_idx(item)
+      if item.is_a?(Integer)
+        return _s.get_idx(item)
+      end
+
+      if item.is_a?(Range)
+        return Slice.new(self).apply(item)
+      end
+
+      raise ArgumentError, "Cannot get item of type: #{item.class.name}"
     end
 
-    # def []=(key, value)
-    # end
+    # Sets an element of the Series.
+    #
+    # @return [Object]
+    def []=(key, value)
+      if value.is_a?(Array)
+        if is_numeric || is_datelike
+          set_at_idx(key, value)
+          return
+        end
+        raise ArgumentError, "cannot set Series of dtype: #{dtype} with list/tuple as value; use a scalar value"
+      end
+
+      if key.is_a?(Series)
+        if key.dtype == :bool
+          self._s = set(key, value)._s
+        elsif key.dtype == :u64
+          self._s = set_at_idx(key.cast(:u32), value)._s
+        elsif key.dtype == :u32
+          self._s = set_at_idx(key, value)._s
+        else
+          raise Todo
+        end
+      end
+
+      if key.is_a?(Array)
+        s = Utils.wrap_s(sequence_to_rbseries("", key, dtype: :u32))
+        self[s] = value
+      elsif key.is_a?(Integer)
+        # TODO fix
+        # self[[key]] = value
+        set_at_idx(key, value)
+      else
+        raise ArgumentError, "cannot use #{key} for indexing"
+      end
+    end
 
     # Return an estimation of the total (heap) allocated size of the Series.
     #
@@ -268,20 +357,43 @@ module Polars
       to_frame.select(Polars.col(name).all).to_series[0]
     end
 
-    # def log
-    # end
+    # Compute the logarithm to a given base.
+    #
+    # @param base [Float]
+    #   Given base, defaults to `Math::E`.
+    #
+    # @return [Series]
+    def log(base = Math::E)
+      super
+    end
 
-    # def log10
-    # end
+    # Compute the base 10 logarithm of the input array, element-wise.
+    #
+    # @return [Series]
+    def log10
+      super
+    end
 
-    # def exp
-    # end
+    # Compute the exponential, element-wise.
+    #
+    # @return [Series]
+    def exp
+      super
+    end
 
-    # def drop_nulls
-    # end
+    # Create a new Series that copies data from this Series without null values.
+    #
+    # @return [Series]
+    def drop_nulls
+      super
+    end
 
-    # def drop_nans
-    # end
+    # Drop NaN values.
+    #
+    # @return [Series]
+    def drop_nans
+      super
+    end
 
     # Cast this Series to a DataFrame.
     #
@@ -290,8 +402,94 @@ module Polars
       Utils.wrap_df(RbDataFrame.new([_s]))
     end
 
-    # def describe
-    # end
+    # Quick summary statistics of a series.
+    #
+    # Series with mixed datatypes will return summary statistics for the datatype of
+    # the first value.
+    #
+    # @return [DataFrame]
+    #
+    # @example
+    #   series_num = Polars::Series.new([1, 2, 3, 4, 5])
+    #   series_num.describe
+    #   # =>
+    #   # shape: (6, 2)
+    #   # ┌────────────┬──────────┐
+    #   # │ statistic  ┆ value    │
+    #   # │ ---        ┆ ---      │
+    #   # │ str        ┆ f64      │
+    #   # ╞════════════╪══════════╡
+    #   # │ min        ┆ 1.0      │
+    #   # ├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┤
+    #   # │ max        ┆ 5.0      │
+    #   # ├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┤
+    #   # │ null_count ┆ 0.0      │
+    #   # ├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┤
+    #   # │ mean       ┆ 3.0      │
+    #   # ├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┤
+    #   # │ std        ┆ 1.581139 │
+    #   # ├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┤
+    #   # │ count      ┆ 5.0      │
+    #   # └────────────┴──────────┘
+    #
+    # @example
+    #   series_str = Polars::Series.new(["a", "a", nil, "b", "c"])
+    #   series_str.describe
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌────────────┬───────┐
+    #   # │ statistic  ┆ value │
+    #   # │ ---        ┆ ---   │
+    #   # │ str        ┆ i64   │
+    #   # ╞════════════╪═══════╡
+    #   # │ unique     ┆ 4     │
+    #   # ├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
+    #   # │ null_count ┆ 1     │
+    #   # ├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
+    #   # │ count      ┆ 5     │
+    #   # └────────────┴───────┘
+    def describe
+      if len == 0
+        raise ArgumentError, "Series must contain at least one value"
+      elsif is_numeric
+        s = cast(:f64)
+        stats = {
+          "min" => s.min,
+          "max" => s.max,
+          "null_count" => s.null_count,
+          "mean" => s.mean,
+          "std" => s.std,
+          "count" => s.len
+        }
+      elsif is_boolean
+        stats = {
+          "sum" => sum,
+          "null_count" => null_count,
+          "count" => len
+        }
+      elsif is_utf8
+        stats = {
+          "unique" => unique.length,
+          "null_count" => null_count,
+          "count" => len
+        }
+      elsif is_datelike
+        # we coerce all to string, because a polars column
+        # only has a single dtype and dates: datetime and count: int don't match
+        stats = {
+          "min" => dt.min.to_s,
+          "max" => dt.max.to_s,
+          "null_count" => null_count.to_s,
+          "count" => len.to_s
+        }
+      else
+        raise TypeError, "This type is not supported"
+      end
+
+      Polars::DataFrame.new(
+        {"statistic" => stats.keys, "value" => stats.values}
+      )
+    end
 
     # Reduce this Series to the sum value.
     #
@@ -352,11 +550,19 @@ module Polars
       _s.max
     end
 
-    # def nan_max
-    # end
+    # Get maximum value, but propagate/poison encountered NaN values.
+    #
+    # @return [Object]
+    def nan_max
+      to_frame.select(Polars.col(name).nan_max)[0, 0]
+    end
 
-    # def nan_min
-    # end
+    # Get minimum value, but propagate/poison encountered NaN values.
+    #
+    # @return [Object]
+    def nan_min
+      to_frame.select(Polars.col(name).nan_min)[0, 0]
+    end
 
     # Get the standard deviation of this Series.
     #
@@ -478,14 +684,86 @@ module Polars
       Utils.wrap_df(_s.value_counts(sort))
     end
 
-    # def unique_counts
-    # end
+    # Return a count of the unique values in the order of appearance.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("id", ["a", "b", "b", "c", "c", "c"])
+    #   s.unique_counts
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'id' [u32]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   # ]
+    def unique_counts
+      super
+    end
 
-    # def entropy
-    # end
+    # Computes the entropy.
+    #
+    # Uses the formula `-sum(pk * log(pk)` where `pk` are discrete probabilities.
+    #
+    # @param base [Float]
+    #   Given base, defaults to `e`
+    # @param normalize [Boolean]
+    #   Normalize pk if it doesn't sum to 1.
+    #
+    # @return [Float, nil]
+    #
+    # @example
+    #   a = Polars::Series.new([0.99, 0.005, 0.005])
+    #   a.entropy(normalize: true)
+    #   # => 0.06293300616044681
+    #
+    # @example
+    #   b = Polars::Series.new([0.65, 0.10, 0.25])
+    #   b.entropy(normalize: true)
+    #   # => 0.8568409950394724
+    def entropy(base: Math::E, normalize: false)
+      Polars.select(Polars.lit(self).entropy(base: base, normalize: normalize)).to_series[0]
+    end
 
-    # def cumulative_eval
-    # end
+    # Run an expression over a sliding window that increases `1` slot every iteration.
+    #
+    # @param expr [Expr]
+    #   Expression to evaluate
+    # @param min_periods [Integer]
+    #   Number of valid values there should be in the window before the expression
+    #   is evaluated. valid values = `length - null_count`
+    # @param parallel [Boolean]
+    #   Run in parallel. Don't do this in a groupby or another operation that
+    #   already has much parallelization.
+    #
+    # @return [Series]
+    #
+    # @note
+    #   This functionality is experimental and may change without it being considered a
+    #   breaking change.
+    #
+    # @note
+    #   This can be really slow as it can have `O(n^2)` complexity. Don't use this
+    #   for operations that visit all elements.
+    #
+    # @example
+    #   s = Polars::Series.new("values", [1, 2, 3, 4, 5])
+    #   s.cumulative_eval(Polars.element.first - Polars.element.last ** 2)
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'values' [f64]
+    #   # [
+    #   #         0.0
+    #   #         -3.0
+    #   #         -8.0
+    #   #         -15.0
+    #   #         -24.0
+    #   # ]
+    def cumulative_eval(expr, min_periods: 1, parallel: false)
+      super
+    end
 
     # Return a copy of the Series with a new alias/name.
     #
@@ -585,7 +863,7 @@ module Polars
     #   #         6
     #   # ]
     def cumsum(reverse: false)
-      Utils.wrap_s(_s.cumsum(reverse))
+      super
     end
 
     # Get an array with the cumulative min computed at every element.
@@ -607,7 +885,7 @@ module Polars
     #   #         1
     #   # ]
     def cummin(reverse: false)
-      Utils.wrap_s(_s.cummin(reverse))
+      super
     end
 
     # Get an array with the cumulative max computed at every element.
@@ -629,7 +907,7 @@ module Polars
     #   #         5
     #   # ]
     def cummax(reverse: false)
-      Utils.wrap_s(_s.cummax(reverse))
+      super
     end
 
     # Get an array with the cumulative product computed at every element.
@@ -655,7 +933,7 @@ module Polars
     #   #         6
     #   # ]
     def cumprod(reverse: false)
-      Utils.wrap_s(_s.cumprod(reverse))
+      super
     end
 
     # Get the first `n` rows.
@@ -702,8 +980,7 @@ module Polars
     #   #         3
     #   # ]
     def slice(offset, length = nil)
-      length = len if length.nil?
-      Utils.wrap_s(_s.slice(offset, length))
+      super
     end
 
     # Append a Series to this one.
@@ -835,8 +1112,23 @@ module Polars
       to_frame.select(Utils.col(name).tail(n)).to_series
     end
 
-    # def take_every
-    # end
+    # Take every nth value in the Series and return as new Series.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3, 4])
+    #   s.take_every(2)
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         3
+    #   # ]
+    def take_every(n)
+      super
+    end
 
     # Sort this Series.
     #
@@ -878,17 +1170,78 @@ module Polars
       end
     end
 
-    # def top_k
-    # end
+    # Return the `k` largest elements.
+    #
+    # If `reverse: true`, the smallest elements will be given.
+    #
+    # @param k [Integer]
+    #   Number of elements to return.
+    # @param reverse [Boolean]
+    #   Return the smallest elements.
+    #
+    # @return [Boolean]
+    def top_k(k: 5, reverse: false)
+      super
+    end
 
-    # def arg_sort
-    # end
+    # Get the index values that would sort this Series.
+    #
+    # @param reverse [Boolean]
+    #   Sort in reverse (descending) order.
+    # @param nulls_last [Boolean]
+    #   Place null values last instead of first.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [5, 3, 4, 1, 2])
+    #   s.arg_sort
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'a' [u32]
+    #   # [
+    #   #         3
+    #   #         4
+    #   #         1
+    #   #         2
+    #   #         0
+    #   # ]
+    def arg_sort(reverse: false, nulls_last: false)
+      super
+    end
 
-    # def argsort
-    # end
+    # Get the index values that would sort this Series.
+    #
+    # Alias for {#arg_sort}.
+    #
+    # @param reverse [Boolean]
+    #   Sort in reverse (descending) order.
+    # @param nulls_last [Boolean]
+    #   Place null values last instead of first.
+    #
+    # @return [Series]
+    def argsort(reverse: false, nulls_last: false)
+      super
+    end
 
-    # def arg_unique
-    # end
+    # Get unique index as Series.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 2, 3])
+    #   s.arg_unique
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [u32]
+    #   # [
+    #   #         0
+    #   #         1
+    #   #         3
+    #   # ]
+    def arg_unique
+      super
+    end
 
     # Get the index of the minimal value.
     #
@@ -914,14 +1267,58 @@ module Polars
       _s.arg_max
     end
 
-    # def search_sorted
-    # end
+    # Find indices where elements should be inserted to maintain order.
+    #
+    # @param element [Object]
+    #   Expression or scalar value.
+    #
+    # @return [Integer]
+    def search_sorted(element)
+      Polars.select(Polars.lit(self).search_sorted(element))[0, 0]
+    end
 
-    # def unique
-    # end
+    # Get unique elements in series.
+    #
+    # @param maintain_order [Boolean]
+    #   Maintain order of data. This requires more work.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 2, 3])
+    #   s.unique.sort
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   # ]
+    def unique(maintain_order: false)
+      super
+    end
 
-    # def take
-    # end
+    # Take values by index.
+    #
+    # @param indices [Array]
+    #   Index location used for selection.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3, 4])
+    #   s.take([1, 3])
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         2
+    #   #         4
+    #   # ]
+    def take(indices)
+      to_frame.select(Polars.col(name).take(indices)).to_series
+    end
 
     # Count the null values in this Series.
     #
@@ -930,7 +1327,7 @@ module Polars
       _s.null_count
     end
 
-    # Return True if the Series has a validity bitmask.
+    # Return `true` if the Series has a validity bitmask.
     #
     # If there is none, it means that there are no null values.
     # Use this to swiftly assert a Series does not have null values.
@@ -953,41 +1350,263 @@ module Polars
     end
     alias_method :empty?, :is_empty
 
-    # def is_null
-    # end
-
-    # def is_not_null
-    # end
-
-    # def is_finite
-    # end
-
-    # def is_infinite
-    # end
+    # Returns a boolean Series indicating which values are null.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 2.0, 3.0, nil])
+    #   s.is_null
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'a' [bool]
+    #   # [
+    #   #         false
+    #   #         false
+    #   #         false
+    #   #         true
+    #   # ]
+    def is_null
+      super
+    end
 
-    # def is_nan
-    # end
+    # Returns a boolean Series indicating which values are not null.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 2.0, 3.0, nil])
+    #   s.is_not_null
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'a' [bool]
+    #   # [
+    #   #         true
+    #   #         true
+    #   #         true
+    #   #         false
+    #   # ]
+    def is_not_null
+      super
+    end
 
-    # def is_not_nan
-    # end
+    # Returns a boolean Series indicating which values are finite.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 2.0, Float::INFINITY])
+    #   s.is_finite
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [bool]
+    #   # [
+    #   #         true
+    #   #         true
+    #   #         false
+    #   # ]
+    def is_finite
+      super
+    end
 
-    # def is_in
-    # end
+    # Returns a boolean Series indicating which values are infinite.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 2.0, Float::INFINITY])
+    #   s.is_infinite
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [bool]
+    #   # [
+    #   #         false
+    #   #         false
+    #   #         true
+    #   # ]
+    def is_infinite
+      super
+    end
 
-    # def arg_true
-    # end
+    # Returns a boolean Series indicating which values are NaN.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 2.0, 3.0, Float::NAN])
+    #   s.is_nan
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'a' [bool]
+    #   # [
+    #   #         false
+    #   #         false
+    #   #         false
+    #   #         true
+    #   # ]
+    def is_nan
+      super
+    end
 
-    # def is_unique
-    # end
+    # Returns a boolean Series indicating which values are not NaN.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 2.0, 3.0, Float::NAN])
+    #   s.is_not_nan
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'a' [bool]
+    #   # [
+    #   #         true
+    #   #         true
+    #   #         true
+    #   #         false
+    #   # ]
+    def is_not_nan
+      super
+    end
 
-    # def is_first
-    # end
+    # Check if elements of this Series are in the other Series.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3])
+    #   s2 = Polars::Series.new("b", [2, 4])
+    #   s2.is_in(s)
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'b' [bool]
+    #   # [
+    #   #         true
+    #   #         false
+    #   # ]
+    #
+    # @example
+    #   sets = Polars::Series.new("sets", [[1, 2, 3], [1, 2], [9, 10]])
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'sets' [list]
+    #   # [
+    #   #         [1, 2, 3]
+    #   #         [1, 2]
+    #   #         [9, 10]
+    #   # ]
+    #
+    # @example
+    #   optional_members = Polars::Series.new("optional_members", [1, 2, 3])
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'optional_members' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   # ]
+    #
+    # @example
+    #   optional_members.is_in(sets)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'optional_members' [bool]
+    #   # [
+    #   #         true
+    #   #         true
+    #   #         false
+    #   # ]
+    def is_in(other)
+      super
+    end
 
-    # def is_duplicated
-    # end
+    # Get index values where Boolean Series evaluate `true`.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3])
+    #   (s == 2).arg_true
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: 'a' [u32]
+    #   # [
+    #   #         1
+    #   # ]
+    def arg_true
+      Polars.arg_where(self, eager: true)
+    end
 
-    # def explode
-    # end
+    # Get mask of all unique values.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 2, 3])
+    #   s.is_unique
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'a' [bool]
+    #   # [
+    #   #         true
+    #   #         false
+    #   #         false
+    #   #         true
+    #   # ]
+    def is_unique
+      super
+    end
+
+    # Get a mask of the first unique value.
+    #
+    # @return [Series]
+    def is_first
+      super
+    end
+
+    # Get mask of all duplicated values.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 2, 3])
+    #   s.is_duplicated
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'a' [bool]
+    #   # [
+    #   #         false
+    #   #         true
+    #   #         true
+    #   #         false
+    #   # ]
+    def is_duplicated
+      super
+    end
+
+    # Explode a list or utf8 Series.
+    #
+    # This means that every item is expanded to a new row.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [[1, 2], [3, 4], [9, 10]])
+    #   s.explode
+    #   # =>
+    #   # shape: (6,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   #         4
+    #   #         9
+    #   #         10
+    #   # ]
+    def explode
+      super
+    end
 
     # Check if series is equal with another Series.
     #
@@ -1025,8 +1644,29 @@ module Polars
     end
     alias_method :length, :len
 
-    # def cast
-    # end
+    # Cast between data types.
+    #
+    # @param dtype [Symbol]
+    #   DataType to cast to
+    # @param strict [Boolean]
+    #   Throw an error if a cast could not be done for instance due to an overflow
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [true, false, true])
+    #   s.cast(:u32)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [u32]
+    #   # [
+    #   #         1
+    #   #         0
+    #   #         1
+    #   # ]
+    def cast(dtype, strict: true)
+      super
+    end
 
     # def to_physical
     # end
@@ -1054,8 +1694,24 @@ module Polars
       in_place ? self : Utils.wrap_s(opt_s)
     end
 
-    # def reverse
-    # end
+    # Return Series in reverse order.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3], dtype: :i8)
+    #   s.reverse
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [i8]
+    #   # [
+    #   #         3
+    #   #         2
+    #   #         1
+    #   # ]
+    def reverse
+      super
+    end
 
     # Check if this Series datatype is numeric.
     #
@@ -1132,52 +1788,176 @@ module Polars
     # def set
     # end
 
-    # def set_at_idx
-    # end
-
-    # def cleared
-    # end
-
-    # clone handled by initialize_copy
-
-    # def fill_nan
-    # end
-
-    # def fill_null
-    # end
-
-    # Rounds down to the nearest integer value.
+    # Set values at the index locations.
     #
-    # Only works on floating point Series.
+    # @param idx [Object]
+    #   Integers representing the index locations.
+    # @param value [Object]
+    #   Replacement values.
     #
     # @return [Series]
     #
     # @example
-    #   s = Polars::Series.new("a", [1.12345, 2.56789, 3.901234])
-    #   s.floor
+    #   s = Polars::Series.new("a", [1, 2, 3])
+    #   s.set_at_idx(1, 10)
     #   # =>
     #   # shape: (3,)
-    #   # Series: 'a' [f64]
+    #   # Series: 'a' [i64]
     #   # [
-    #   #         1.0
-    #   #         2.0
-    #   #         3.0
+    #   #         1
+    #   #         10
+    #   #         3
     #   # ]
-    def floor
-      Utils.wrap_s(_s.floor)
+    def set_at_idx(idx, value)
+      if idx.is_a?(Integer)
+        idx = [idx]
+      end
+      if idx.length == 0
+        return self
+      end
+
+      idx = Series.new("", idx)
+      if value.is_a?(Integer) || value.is_a?(Float) || Utils.bool?(value) || value.is_a?(String) || value.nil?
+        value = Series.new("", [value])
+
+        # if we need to set more than a single value, we extend it
+        if idx.length > 0
+          value = value.extend_constant(value[0], idx.length - 1)
+        end
+      elsif !value.is_a?(Series)
+        value = Series.new("", value)
+      end
+      _s.set_at_idx(idx._s, value._s)
+      self
     end
 
-    # Rounds up to the nearest integer value.
+    # Create an empty copy of the current Series.
     #
-    # Only works on floating point Series.
+    # The copy has identical name/dtype but no data.
     #
     # @return [Series]
     #
     # @example
-    #   s = Polars::Series.new("a", [1.12345, 2.56789, 3.901234])
-    #   s.ceil
+    #   s = Polars::Series.new("a", [nil, true, false])
+    #   s.cleared
     #   # =>
-    #   # shape: (3,)
+    #   # shape: (0,)
+    #   # Series: 'a' [bool]
+    #   # [
+    #   # ]
+    def cleared
+      len > 0 ? limit(0) : clone
+    end
+
+    # clone handled by initialize_copy
+
+    # Fill floating point NaN value with a fill value.
+    #
+    # @param fill_value [Object]
+    #   Value used to fill nan values.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 2.0, 3.0, Float::NAN])
+    #   s.fill_nan(0)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         1.0
+    #   #         2.0
+    #   #         3.0
+    #   #         0.0
+    #   # ]
+    def fill_nan(fill_value)
+      super
+    end
+
+    # Fill null values using the specified value or strategy.
+    #
+    # @param value [Object]
+    #   Value used to fill null values.
+    # @param strategy [nil, "forward", "backward", "min", "max", "mean", "zero", "one"]
+    #   Strategy used to fill null values.
+    # @param limit
+    #   Number of consecutive null values to fill when using the "forward" or
+    #   "backward" strategy.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3, nil])
+    #   s.fill_null(strategy: "forward")
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   #         3
+    #   # ]
+    #
+    # @example
+    #   s.fill_null(strategy: "min")
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   #         1
+    #   # ]
+    #
+    # @example
+    #   s = Polars::Series.new("b", ["x", nil, "z"])
+    #   s.fill_null(Polars.lit(""))
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'b' [str]
+    #   # [
+    #   #         "x"
+    #   #         ""
+    #   #         "z"
+    #   # ]
+    def fill_null(value = nil, strategy: nil, limit: nil)
+      super
+    end
+
+    # Rounds down to the nearest integer value.
+    #
+    # Only works on floating point Series.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.12345, 2.56789, 3.901234])
+    #   s.floor
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         1.0
+    #   #         2.0
+    #   #         3.0
+    #   # ]
+    def floor
+      Utils.wrap_s(_s.floor)
+    end
+
+    # Rounds up to the nearest integer value.
+    #
+    # Only works on floating point Series.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.12345, 2.56789, 3.901234])
+    #   s.ceil
+    #   # =>
+    #   # shape: (3,)
     #   # Series: 'a' [f64]
     #   # [
     #   #         2.0
@@ -1185,7 +1965,7 @@ module Polars
     #   #         4.0
     #   # ]
     def ceil
-      Utils.wrap_s(_s.ceil)
+      super
     end
 
     # Round underlying floating point data by `decimals` digits.
@@ -1207,98 +1987,900 @@ module Polars
     #   #         3.9
     #   # ]
     def round(decimals = 0)
-      Utils.wrap_s(_s.round(decimals))
+      super
     end
 
-    # def dot
-    # end
+    # Compute the dot/inner product between two Series.
+    #
+    # @param other [Object]
+    #   Series (or array) to compute dot product with.
+    #
+    # @return [Numeric]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3])
+    #   s2 = Polars::Series.new("b", [4.0, 5.0, 6.0])
+    #   s.dot(s2)
+    #   # => 32.0
+    def dot(other)
+      if !other.is_a?(Series)
+        other = Series.new(other)
+      end
+      if len != other.len
+        n, m = len, other.len
+        raise ArgumentError, "Series length mismatch: expected #{n}, found #{m}"
+      end
+      _s.dot(other._s)
+    end
 
-    # def mode
-    # end
+    # Compute the most occurring value(s).
+    #
+    # Can return multiple Values.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 2, 3])
+    #   s.mode
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         2
+    #   # ]
+    def mode
+      super
+    end
 
-    # def sign
-    # end
+    # Compute the element-wise indication of the sign.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [-9.0, -0.0, 0.0, 4.0, nil])
+    #   s.sign
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         -1
+    #   #         0
+    #   #         0
+    #   #         1
+    #   #         null
+    #   # ]
+    def sign
+      super
+    end
 
-    # def sin
-    # end
+    # Compute the element-wise value for the sine.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [0.0, Math::PI / 2.0, Math::PI])
+    #   s.sin
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         0.0
+    #   #         1.0
+    #   #         1.2246e-16
+    #   # ]
+    def sin
+      super
+    end
 
-    # def cos
-    # end
+    # Compute the element-wise value for the cosine.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [0.0, Math::PI / 2.0, Math::PI])
+    #   s.cos
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         1.0
+    #   #         6.1232e-17
+    #   #         -1.0
+    #   # ]
+    def cos
+      super
+    end
 
-    # def tan
-    # end
+    # Compute the element-wise value for the tangent.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [0.0, Math::PI / 2.0, Math::PI])
+    #   s.tan
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         0.0
+    #   #         1.6331e16
+    #   #         -1.2246e-16
+    #   # ]
+    def tan
+      super
+    end
 
-    # def arcsin
-    # end
+    # Compute the element-wise value for the inverse sine.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 0.0, -1.0])
+    #   s.arcsin
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         1.570796
+    #   #         0.0
+    #   #         -1.570796
+    #   # ]
+    def arcsin
+      super
+    end
 
-    # def arccos
-    # end
+    # Compute the element-wise value for the inverse cosine.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 0.0, -1.0])
+    #   s.arccos
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         0.0
+    #   #         1.570796
+    #   #         3.141593
+    #   # ]
+    def arccos
+      super
+    end
 
-    # def arctan
-    # end
+    # Compute the element-wise value for the inverse tangent.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 0.0, -1.0])
+    #   s.arctan
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         0.785398
+    #   #         0.0
+    #   #         -0.785398
+    #   # ]
+    def arctan
+      super
+    end
 
-    # def arcsinh
-    # end
+    # Compute the element-wise value for the inverse hyperbolic sine.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 0.0, -1.0])
+    #   s.arcsinh
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         0.881374
+    #   #         0.0
+    #   #         -0.881374
+    #   # ]
+    def arcsinh
+      super
+    end
 
-    # def arccosh
-    # end
+    # Compute the element-wise value for the inverse hyperbolic cosine.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [5.0, 1.0, 0.0, -1.0])
+    #   s.arccosh
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         2.292432
+    #   #         0.0
+    #   #         NaN
+    #   #         NaN
+    #   # ]
+    def arccosh
+      super
+    end
 
-    # def arctanh
-    # end
+    # Compute the element-wise value for the inverse hyperbolic tangent.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [2.0, 1.0, 0.5, 0.0, -0.5, -1.0, -1.1])
+    #   s.arctanh
+    #   # =>
+    #   # shape: (7,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         NaN
+    #   #         inf
+    #   #         0.549306
+    #   #         0.0
+    #   #         -0.549306
+    #   #         -inf
+    #   #         NaN
+    #   # ]
+    def arctanh
+      super
+    end
 
-    # def sinh
-    # end
+    # Compute the element-wise value for the hyperbolic sine.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 0.0, -1.0])
+    #   s.sinh
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         1.175201
+    #   #         0.0
+    #   #         -1.175201
+    #   # ]
+    def sinh
+      super
+    end
 
-    # def cosh
-    # end
+    # Compute the element-wise value for the hyperbolic cosine.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 0.0, -1.0])
+    #   s.cosh
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         1.543081
+    #   #         1.0
+    #   #         1.543081
+    #   # ]
+    def cosh
+      super
+    end
 
-    # def tanh
-    # end
+    # Compute the element-wise value for the hyperbolic tangent.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 0.0, -1.0])
+    #   s.tanh
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         0.761594
+    #   #         0.0
+    #   #         -0.761594
+    #   # ]
+    def tanh
+      super
+    end
 
     # def apply
     # end
 
-    # def shift
-    # end
+    # Shift the values by a given period.
+    #
+    # @param periods [Integer]
+    #   Number of places to shift (may be negative).
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3])
+    #   s.shift(1)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         null
+    #   #         1
+    #   #         2
+    #   # ]
+    #
+    # @example
+    #   s.shift(-1)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         2
+    #   #         3
+    #   #         null
+    #   # ]
+    def shift(periods = 1)
+      super
+    end
 
-    # def shift_and_fill
-    # end
+    # Shift the values by a given period and fill the resulting null values.
+    #
+    # @param periods [Integer]
+    #   Number of places to shift (may be negative).
+    # @param fill_value [Object]
+    #   Fill None values with the result of this expression.
+    #
+    # @return [Series]
+    def shift_and_fill(periods, fill_value)
+      super
+    end
 
-    # def zip_with
-    # end
+    # Take values from self or other based on the given mask.
+    #
+    # Where mask evaluates true, take values from self. Where mask evaluates false,
+    # take values from other.
+    #
+    # @param mask [Series]
+    #   Boolean Series.
+    # @param other [Series]
+    #   Series of same type.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s1 = Polars::Series.new([1, 2, 3, 4, 5])
+    #   s2 = Polars::Series.new([5, 4, 3, 2, 1])
+    #   s1.zip_with(s1 < s2, s2)
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: '' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   #         2
+    #   #         1
+    #   # ]
+    #
+    # @example
+    #   mask = Polars::Series.new([true, false, true, false, true])
+    #   s1.zip_with(mask, s2)
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: '' [i64]
+    #   # [
+    #   #         1
+    #   #         4
+    #   #         3
+    #   #         2
+    #   #         5
+    #   # ]
+    def zip_with(mask, other)
+      Utils.wrap_s(_s.zip_with(mask._s, other._s))
+    end
 
-    # def rolling_min
-    # end
+    # Apply a rolling min (moving min) over the values in this array.
+    #
+    # A window of length `window_size` will traverse the array. The values that fill
+    # this window will (optionally) be multiplied with the weights given by the
+    # `weight` vector. The resulting values will be aggregated to their sum.
+    #
+    # @param window_size [Integer]
+    #   The length of the window.
+    # @param weights [Array]
+    #   An optional slice with the same length as the window that will be multiplied
+    #   elementwise with the values in the window.
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If None, it will be set equal to window size.
+    # @param center [Boolean]
+    #   Set the labels at the center of the window
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [100, 200, 300, 400, 500])
+    #   s.rolling_min(3)
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         null
+    #   #         null
+    #   #         100
+    #   #         200
+    #   #         300
+    #   # ]
+    def rolling_min(
+      window_size,
+      weights: nil,
+      min_periods: nil,
+      center: false
+    )
+      to_frame
+        .select(
+          Polars.col(name).rolling_min(
+            window_size,
+            weights: weights,
+            min_periods: min_periods,
+            center: center
+          )
+        )
+        .to_series
+    end
 
-    # def rolling_max
-    # end
+    # Apply a rolling max (moving max) over the values in this array.
+    #
+    # A window of length `window_size` will traverse the array. The values that fill
+    # this window will (optionally) be multiplied with the weights given by the
+    # `weight` vector. The resulting values will be aggregated to their sum.
+    #
+    # @param window_size [Integer]
+    #   The length of the window.
+    # @param weights [Array]
+    #   An optional slice with the same length as the window that will be multiplied
+    #   elementwise with the values in the window.
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If None, it will be set equal to window size.
+    # @param center [Boolean]
+    #   Set the labels at the center of the window
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [100, 200, 300, 400, 500])
+    #   s.rolling_max(2)
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         null
+    #   #         200
+    #   #         300
+    #   #         400
+    #   #         500
+    #   # ]
+    def rolling_max(
+      window_size,
+      weights: nil,
+      min_periods: nil,
+      center: false
+    )
+      to_frame
+        .select(
+          Polars.col(name).rolling_max(
+            window_size,
+            weights: weights,
+            min_periods: min_periods,
+            center: center
+          )
+        )
+        .to_series
+    end
 
-    # def rolling_mean
-    # end
+    # Apply a rolling mean (moving mean) over the values in this array.
+    #
+    # A window of length `window_size` will traverse the array. The values that fill
+    # this window will (optionally) be multiplied with the weights given by the
+    # `weight` vector. The resulting values will be aggregated to their sum.
+    #
+    # @param window_size [Integer]
+    #   The length of the window.
+    # @param weights [Array]
+    #   An optional slice with the same length as the window that will be multiplied
+    #   elementwise with the values in the window.
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If None, it will be set equal to window size.
+    # @param center [Boolean]
+    #   Set the labels at the center of the window
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [100, 200, 300, 400, 500])
+    #   s.rolling_mean(2)
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         null
+    #   #         150.0
+    #   #         250.0
+    #   #         350.0
+    #   #         450.0
+    #   # ]
+    def rolling_mean(
+      window_size,
+      weights: nil,
+      min_periods: nil,
+      center: false
+    )
+      to_frame
+        .select(
+          Polars.col(name).rolling_mean(
+            window_size,
+            weights: weights,
+            min_periods: min_periods,
+            center: center
+          )
+        )
+        .to_series
+    end
 
-    # def rolling_sum
-    # end
+    # Apply a rolling sum (moving sum) over the values in this array.
+    #
+    # A window of length `window_size` will traverse the array. The values that fill
+    # this window will (optionally) be multiplied with the weights given by the
+    # `weight` vector. The resulting values will be aggregated to their sum.
+    #
+    # @param window_size [Integer]
+    #   The length of the window.
+    # @param weights [Array]
+    #   An optional slice with the same length as the window that will be multiplied
+    #   elementwise with the values in the window.
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If None, it will be set equal to window size.
+    # @param center [Boolean]
+    #   Set the labels at the center of the window
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3, 4, 5])
+    #   s.rolling_sum(2)
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         null
+    #   #         3
+    #   #         5
+    #   #         7
+    #   #         9
+    #   # ]
+    def rolling_sum(
+      window_size,
+      weights: nil,
+      min_periods: nil,
+      center: false
+    )
+      to_frame
+        .select(
+          Polars.col(name).rolling_sum(
+            window_size,
+            weights: weights,
+            min_periods: min_periods,
+            center: center
+          )
+        )
+        .to_series
+    end
 
-    # def rolling_std
-    # end
+    # Compute a rolling std dev.
+    #
+    # A window of length `window_size` will traverse the array. The values that fill
+    # this window will (optionally) be multiplied with the weights given by the
+    # `weight` vector. The resulting values will be aggregated to their sum.
+    #
+    # @param window_size [Integer]
+    #   The length of the window.
+    # @param weights [Array]
+    #   An optional slice with the same length as the window that will be multiplied
+    #   elementwise with the values in the window.
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If None, it will be set equal to window size.
+    # @param center [Boolean]
+    #   Set the labels at the center of the window
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 2.0, 3.0, 4.0, 6.0, 8.0])
+    #   s.rolling_std(3)
+    #   # =>
+    #   # shape: (6,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         null
+    #   #         null
+    #   #         1.0
+    #   #         1.0
+    #   #         1.527525
+    #   #         2.0
+    #   # ]
+    def rolling_std(
+      window_size,
+      weights: nil,
+      min_periods: nil,
+      center: false
+    )
+      to_frame
+        .select(
+          Polars.col(name).rolling_std(
+            window_size,
+            weights: weights,
+            min_periods: min_periods,
+            center: center
+          )
+        )
+        .to_series
+    end
 
-    # def rolling_var
-    # end
+    # Compute a rolling variance.
+    #
+    # A window of length `window_size` will traverse the array. The values that fill
+    # this window will (optionally) be multiplied with the weights given by the
+    # `weight` vector. The resulting values will be aggregated to their sum.
+    #
+    # @param window_size [Integer]
+    #   The length of the window.
+    # @param weights [Array]
+    #   An optional slice with the same length as the window that will be multiplied
+    #   elementwise with the values in the window.
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If None, it will be set equal to window size.
+    # @param center [Boolean]
+    #   Set the labels at the center of the window
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 2.0, 3.0, 4.0, 6.0, 8.0])
+    #   s.rolling_var(3)
+    #   # =>
+    #   # shape: (6,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         null
+    #   #         null
+    #   #         1.0
+    #   #         1.0
+    #   #         2.333333
+    #   #         4.0
+    #   # ]
+    def rolling_var(
+      window_size,
+      weights: nil,
+      min_periods: nil,
+      center: false
+    )
+      to_frame
+        .select(
+          Polars.col(name).rolling_var(
+            window_size,
+            weights: weights,
+            min_periods: min_periods,
+            center: center
+          )
+        )
+        .to_series
+    end
 
     # def rolling_apply
     # end
 
-    # def rolling_median
-    # end
+    # Compute a rolling median.
+    #
+    # @param window_size [Integer]
+    #   The length of the window.
+    # @param weights [Array]
+    #   An optional slice with the same length as the window that will be multiplied
+    #   elementwise with the values in the window.
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If None, it will be set equal to window size.
+    # @param center [Boolean]
+    #   Set the labels at the center of the window
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 2.0, 3.0, 4.0, 6.0, 8.0])
+    #   s.rolling_median(3)
+    #   # =>
+    #   # shape: (6,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         null
+    #   #         null
+    #   #         2.0
+    #   #         3.0
+    #   #         4.0
+    #   #         6.0
+    #   # ]
+    def rolling_median(
+      window_size,
+      weights: nil,
+      min_periods: nil,
+      center: false
+    )
+      if min_periods.nil?
+        min_periods = window_size
+      end
 
-    # def rolling_quantile
-    # end
+      to_frame
+        .select(
+          Polars.col(name).rolling_median(
+            window_size,
+            weights: weights,
+            min_periods: min_periods,
+            center: center
+          )
+        )
+        .to_series
+    end
+
+    # Compute a rolling quantile.
+    #
+    # @param quantile [Float]
+    #   Quantile between 0.0 and 1.0.
+    # @param interpolation ["nearest", "higher", "lower", "midpoint", "linear"]
+    #   Interpolation method.
+    # @param window_size [Integer]
+    #   The length of the window.
+    # @param weights [Array]
+    #   An optional slice with the same length as the window that will be multiplied
+    #   elementwise with the values in the window.
+    # @param min_periods [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If None, it will be set equal to window size.
+    # @param center [Boolean]
+    #   Set the labels at the center of the window
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 2.0, 3.0, 4.0, 6.0, 8.0])
+    #   s.rolling_quantile(0.33, window_size: 3)
+    #   # =>
+    #   # shape: (6,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         null
+    #   #         null
+    #   #         1.0
+    #   #         2.0
+    #   #         3.0
+    #   #         4.0
+    #   # ]
+    #
+    # @example
+    #   s.rolling_quantile(0.33, interpolation: "linear", window_size: 3)
+    #   # =>
+    #   # shape: (6,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         null
+    #   #         null
+    #   #         1.66
+    #   #         2.66
+    #   #         3.66
+    #   #         5.32
+    #   # ]
+    def rolling_quantile(
+      quantile,
+      interpolation: "nearest",
+      window_size: 2,
+      weights: nil,
+      min_periods: nil,
+      center: false
+    )
+      if min_periods.nil?
+        min_periods = window_size
+      end
+
+      to_frame
+        .select(
+          Polars.col(name).rolling_quantile(
+            quantile,
+            interpolation: interpolation,
+            window_size: window_size,
+            weights: weights,
+            min_periods: min_periods,
+            center: center
+          )
+        )
+        .to_series
+    end
+
+    # Compute a rolling skew.
+    #
+    # @param window_size [Integer]
+    #   Integer size of the rolling window.
+    # @param bias [Boolean]
+    #   If false, the calculations are corrected for statistical bias.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1.0, 2.0, 3.0, 4.0, 6.0, 8.0])
+    #   s.rolling_skew(3)
+    #   # =>
+    #   # shape: (6,)
+    #   # Series: 'a' [f64]
+    #   # [
+    #   #         null
+    #   #         null
+    #   #         0.0
+    #   #         0.0
+    #   #         0.381802
+    #   #         0.0
+    #   # ]
+    def rolling_skew(window_size, bias: true)
+      super
+    end
+
+    # Sample from this Series.
+    #
+    # @param n [Integer]
+    #   Number of items to return. Cannot be used with `frac`. Defaults to 1 if
+    #   `frac` is None.
+    # @param frac [Float]
+    #   Fraction of items to return. Cannot be used with `n`.
+    # @param with_replacement [Boolean]
+    #   Allow values to be sampled more than once.
+    # @param shuffle [Boolean]
+    #   Shuffle the order of sampled data points.
+    # @param seed [Integer]
+    #   Seed for the random number generator. If set to None (default), a random
+    #   seed is used.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3, 4, 5])
+    #   s.sample(n: 2, seed: 0)
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #     1
+    #   #     5
+    #   # ]
+    def sample(
+      n: nil,
+      frac: nil,
+      with_replacement: false,
+      shuffle: false,
+      seed: nil
+    )
+      if !n.nil? && !frac.nil?
+        raise ArgumentError, "cannot specify both `n` and `frac`"
+      end
 
-    # def rolling_skew
-    # end
+      if n.nil? && !frac.nil?
+        return Utils.wrap_s(_s.sample_frac(frac, with_replacement, shuffle, seed))
+      end
 
-    # def sample
-    # end
+      if n.nil?
+        n = 1
+      end
+      Utils.wrap_s(_s.sample_n(n, with_replacement, shuffle, seed))
+    end
 
     # Get a boolean mask of the local maximum peaks.
     #
@@ -1354,62 +2936,384 @@ module Polars
       _s.n_unique
     end
 
-    # def shrink_to_fit
-    # end
+    # Shrink Series memory usage.
+    #
+    # Shrinks the underlying array capacity to exactly fit the actual data.
+    # (Note that this function does not change the Series data type).
+    #
+    # @return [Series]
+    def shrink_to_fit(in_place: false)
+      if in_place
+        _s.shrink_to_fit
+        self
+      else
+        series = clone
+        series._s.shrink_to_fit
+        series
+      end
+    end
 
     # def _hash
     # end
 
-    # def reinterpret
-    # end
+    # Reinterpret the underlying bits as a signed/unsigned integer.
+    #
+    # This operation is only allowed for 64bit integers. For lower bits integers,
+    # you can safely use that cast operation.
+    #
+    # @param signed [Boolean]
+    #   If true, reinterpret as `:i64`. Otherwise, reinterpret as `:u64`.
+    #
+    # @return [Series]
+    def reinterpret(signed: true)
+      super
+    end
 
-    # def interpolate
-    # end
+    # Interpolate intermediate values. The interpolation method is linear.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, nil, nil, 5])
+    #   s.interpolate
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   #         4
+    #   #         5
+    #   # ]
+    def interpolate
+      super
+    end
 
-    # def abs
-    # end
+    # Compute absolute values.
+    #
+    # @return [Series]
+    def abs
+      super
+    end
 
-    # def rank
-    # end
+    # Assign ranks to data, dealing with ties appropriately.
+    #
+    # @param method ["average", "min", "max", "dense", "ordinal", "random"]
+    #   The method used to assign ranks to tied elements.
+    #   The following methods are available (default is 'average'):
+    #
+    #   - 'average' : The average of the ranks that would have been assigned to
+    #     all the tied values is assigned to each value.
+    #   - 'min' : The minimum of the ranks that would have been assigned to all
+    #     the tied values is assigned to each value. (This is also referred to
+    #     as "competition" ranking.)
+    #   - 'max' : The maximum of the ranks that would have been assigned to all
+    #     the tied values is assigned to each value.
+    #   - 'dense' : Like 'min', but the rank of the next highest element is
+    #     assigned the rank immediately after those assigned to the tied
+    #     elements.
+    #   - 'ordinal' : All values are given a distinct rank, corresponding to
+    #     the order that the values occur in the Series.
+    #   - 'random' : Like 'ordinal', but the rank for ties is not dependent
+    #     on the order that the values occur in the Series.
+    # @param reverse [Boolean]
+    #   Reverse the operation.
+    #
+    # @return [Series]
+    #
+    # @example The 'average' method:
+    #   s = Polars::Series.new("a", [3, 6, 1, 1, 6])
+    #   s.rank
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'a' [f32]
+    #   # [
+    #   #         3.0
+    #   #         4.5
+    #   #         1.5
+    #   #         1.5
+    #   #         4.5
+    #   # ]
+    #
+    # @example The 'ordinal' method:
+    #   s = Polars::Series.new("a", [3, 6, 1, 1, 6])
+    #   s.rank(method: "ordinal")
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'a' [u32]
+    #   # [
+    #   #         3
+    #   #         4
+    #   #         1
+    #   #         2
+    #   #         5
+    #   # ]
+    def rank(method: "average", reverse: false)
+      super
+    end
 
-    # def diff
-    # end
+    # Calculate the n-th discrete difference.
+    #
+    # @param n [Integer]
+    #   Number of slots to shift.
+    # @param null_behavior ["ignore", "drop"]
+    #   How to handle null values.
+    #
+    # @return [Series]
+    def diff(n: 1, null_behavior: "ignore")
+      super
+    end
 
-    # def pct_change
-    # end
+    # Computes percentage change between values.
+    #
+    # Percentage change (as fraction) between current element and most-recent
+    # non-null element at least `n` period(s) before the current element.
+    #
+    # Computes the change from the previous row by default.
+    #
+    # @param n [Integer]
+    #   periods to shift for forming percent change.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   Polars::Series.new(0..9).pct_change
+    #   # =>
+    #   # shape: (10,)
+    #   # Series: '' [f64]
+    #   # [
+    #   #         null
+    #   #         inf
+    #   #         1.0
+    #   #         0.5
+    #   #         0.333333
+    #   #         0.25
+    #   #         0.2
+    #   #         0.166667
+    #   #         0.142857
+    #   #         0.125
+    #   # ]
+    #
+    # @example
+    #   Polars::Series.new([1, 2, 4, 8, 16, 32, 64, 128, 256, 512]).pct_change(n: 2)
+    #   # =>
+    #   # shape: (10,)
+    #   # Series: '' [f64]
+    #   # [
+    #   #         null
+    #   #         null
+    #   #         3.0
+    #   #         3.0
+    #   #         3.0
+    #   #         3.0
+    #   #         3.0
+    #   #         3.0
+    #   #         3.0
+    #   #         3.0
+    #   # ]
+    def pct_change(n: 1)
+      super
+    end
 
-    # def skew
-    # end
+    # Compute the sample skewness of a data set.
+    #
+    # For normally distributed data, the skewness should be about zero. For
+    # unimodal continuous distributions, a skewness value greater than zero means
+    # that there is more weight in the right tail of the distribution. The
+    # function `skewtest` can be used to determine if the skewness value
+    # is close enough to zero, statistically speaking.
+    #
+    # @param bias [Boolean]
+    #   If `false`, the calculations are corrected for statistical bias.
+    #
+    # @return [Float, nil]
+    def skew(bias: true)
+      _s.skew(bias)
+    end
 
-    # def kurtosis
-    # end
+    # Compute the kurtosis (Fisher or Pearson) of a dataset.
+    #
+    # Kurtosis is the fourth central moment divided by the square of the
+    # variance. If Fisher's definition is used, then 3.0 is subtracted from
+    # the result to give 0.0 for a normal distribution.
+    # If bias is false, then the kurtosis is calculated using k statistics to
+    # eliminate bias coming from biased moment estimators
+    #
+    # @param fisher [Boolean]
+    #   If `true`, Fisher's definition is used (normal ==> 0.0). If `false`,
+    #   Pearson's definition is used (normal ==> 3.0).
+    # @param bias [Boolean]
+    #   If `false`, the calculations are corrected for statistical bias.
+    #
+    # @return [Float, nil]
+    def kurtosis(fisher: true, bias: true)
+      _s.kurtosis(fisher, bias)
+    end
 
-    # def clip
-    # end
+    # Clip (limit) the values in an array to a `min` and `max` boundary.
+    #
+    # Only works for numerical types.
+    #
+    # If you want to clip other dtypes, consider writing a "when, then, otherwise"
+    # expression. See {#when} for more information.
+    #
+    # @param min_val [Numeric]
+    #   Minimum value.
+    # @param max_val [Numeric]
+    #   Maximum value.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("foo", [-50, 5, nil, 50])
+    #   s.clip(1, 10)
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'foo' [i64]
+    #   # [
+    #   #         1
+    #   #         5
+    #   #         null
+    #   #         10
+    #   # ]
+    def clip(min_val, max_val)
+      super
+    end
 
-    # def clip_min
-    # end
+    # Clip (limit) the values in an array to a `min` boundary.
+    #
+    # Only works for numerical types.
+    #
+    # If you want to clip other dtypes, consider writing a "when, then, otherwise"
+    # expression. See {#when} for more information.
+    #
+    # @param min_val [Numeric]
+    #   Minimum value.
+    #
+    # @return [Series]
+    def clip_min(min_val)
+      super
+    end
 
-    # def clip_max
-    # end
+    # Clip (limit) the values in an array to a `max` boundary.
+    #
+    # Only works for numerical types.
+    #
+    # If you want to clip other dtypes, consider writing a "when, then, otherwise"
+    # expression. See {#when} for more information.
+    #
+    # @param max_val [Numeric]
+    #   Maximum value.
+    #
+    # @return [Series]
+    def clip_max(max_val)
+      super
+    end
 
-    # def reshape
-    # end
+    # Reshape this Series to a flat Series or a Series of Lists.
+    #
+    # @param dims [Array]
+    #   Tuple of the dimension sizes. If a -1 is used in any of the dimensions, that
+    #   dimension is inferred.
+    #
+    # @return [Series]
+    def reshape(dims)
+      super
+    end
 
-    # def shuffle
-    # end
+    # Shuffle the contents of this Series.
+    #
+    # @param seed [Integer, nil]
+    #   Seed for the random number generator.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3])
+    #   s.shuffle(seed: 1)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         2
+    #   #         1
+    #   #         3
+    #   # ]
+    def shuffle(seed: nil)
+      super
+    end
 
-    # def ewm_mean
-    # end
+    # Exponentially-weighted moving average.
+    #
+    # @return [Series]
+    def ewm_mean(
+      com: nil,
+      span: nil,
+      half_life: nil,
+      alpha: nil,
+      adjust: true,
+      min_periods: 1
+    )
+      super
+    end
 
-    # def ewm_std
-    # end
+    # Exponentially-weighted moving standard deviation.
+    #
+    # @return [Series]
+    def ewm_std(
+      com: nil,
+      span: nil,
+      half_life: nil,
+      alpha: nil,
+      adjust: true,
+      bias: false,
+      min_periods: 1
+    )
+      super
+    end
 
-    # def ewm_var
-    # end
+    # Exponentially-weighted moving variance.
+    #
+    # @return [Series]
+    def ewm_var(
+      com: nil,
+      span: nil,
+      half_life: nil,
+      alpha: nil,
+      adjust: true,
+      bias: false,
+      min_periods: 1
+    )
+      super
+    end
 
-    # def extend_constant
-    # end
+    # Extend the Series with given number of values.
+    #
+    # @param value [Object]
+    #   The value to extend the Series with. This value may be `nil` to fill with
+    #   nulls.
+    # @param n [Integer]
+    #   The number of values to extend.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3])
+    #   s.extend_constant(99, 2)
+    #   # =>
+    #   # shape: (5,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         2
+    #   #         3
+    #   #         99
+    #   #         99
+    #   # ]
+    def extend_constant(value, n)
+      super
+    end
 
     # Flags the Series as sorted.
     #
@@ -1432,26 +3336,57 @@ module Polars
       Utils.wrap_s(_s.set_sorted(reverse))
     end
 
-    # def new_from_index
-    # end
+    # Create a new Series filled with values from the given index.
+    #
+    # @return [Series]
+    def new_from_index(index, length)
+      Utils.wrap_s(_s.new_from_index(index, length))
+    end
 
-    # def shrink_dtype
-    # end
+    # Shrink numeric columns to the minimal required datatype.
+    #
+    # Shrink to the dtype needed to fit the extrema of this Series.
+    # This can be used to reduce memory pressure.
+    #
+    # @return [Series]
+    def shrink_dtype
+      super
+    end
 
-    # def arr
-    # end
+    # Create an object namespace of all list related methods.
+    #
+    # @return [ListNameSpace]
+    def arr
+      ListNameSpace.new(self)
+    end
 
-    # def cat
-    # end
+    # Create an object namespace of all categorical related methods.
+    #
+    # @return [CatNameSpace]
+    def cat
+      CatNameSpace.new(self)
+    end
 
-    # def dt
-    # end
+    # Create an object namespace of all datetime related methods.
+    #
+    # @return [DateTimeNameSpace]
+    def dt
+      DateTimeNameSpace.new(self)
+    end
 
-    # def str
-    # end
+    # Create an object namespace of all string related methods.
+    #
+    # @return [StringNameSpace]
+    def str
+      StringNameSpace.new(self)
+    end
 
-    # def struct
-    # end
+    # Create an object namespace of all struct related methods.
+    #
+    # @return [StructNameSpace]
+    def struct
+      StructNameSpace.new(self)
+    end
 
     private
 
@@ -1460,8 +3395,47 @@ module Polars
       self._s = _s._clone
     end
 
+    def coerce(other)
+      if other.is_a?(Numeric)
+        # TODO improve
+        series = to_frame.select(Polars.lit(other)).to_series
+        [series, self]
+      else
+        raise TypeError, "#{self.class} can't be coerced into #{other.class}"
+      end
+    end
+
+    def _comp(other, op)
+      if other.is_a?(Series)
+        return Utils.wrap_s(_s.send(op, other._s))
+      end
+
+      if dtype == :str
+        raise Todo
+      end
+      Utils.wrap_s(_s.send("#{op}_#{dtype}", other))
+    end
+
+    def _arithmetic(other, op)
+      if other.is_a?(Expr)
+        other = to_frame.select(other).to_series
+      end
+      if other.is_a?(Series)
+        return Utils.wrap_s(_s.send(op, other._s))
+      end
+
+      raise Todo
+    end
+
+    def series_to_rbseries(name, values)
+      # should not be in-place?
+      values.rename(name, in_place: true)
+      values._s
+    end
+
     def sequence_to_rbseries(name, values, dtype: nil, strict: true, dtype_if_empty: nil)
       ruby_dtype = nil
+      nested_dtype = nil
 
       if (values.nil? || values.empty?) && dtype.nil?
         if dtype_if_empty
@@ -1470,7 +3444,7 @@ module Polars
           dtype = dtype_if_empty
         else
           # default to Float32 type
-          dtype = "f32"
+          dtype = :f32
         end
       end
 
@@ -1479,8 +3453,7 @@ module Polars
       rb_temporal_types << DateTime if defined?(DateTime)
       rb_temporal_types << Time if defined?(Time)
 
-      # _get_first_non_none
-      value = values.find { |v| !v.nil? }
+      value = _get_first_non_none(values)
 
       if !dtype.nil? && Utils.is_polars_dtype(dtype) && ruby_dtype.nil?
         constructor = polars_type_to_constructor(dtype)
@@ -1504,7 +3477,45 @@ module Polars
           #   dtype = rb_type_to_dtype(dtype)
           # end
 
-          raise Todo
+          if ruby_dtype == Date
+            RbSeries.new_opt_date(name, values, strict)
+          elsif ruby_dtype == Time
+            RbSeries.new_opt_datetime(name, values, strict)
+          elsif ruby_dtype == DateTime
+            RbSeries.new_opt_datetime(name, values.map(&:to_time), strict)
+          else
+            raise Todo
+          end
+        elsif ruby_dtype == Array
+          if nested_dtype.nil?
+            nested_value = _get_first_non_none(value)
+            nested_dtype = nested_value.nil? ? Float : nested_value.class
+          end
+
+          if nested_dtype == Array
+            raise Todo
+          end
+
+          if value.is_a?(Array)
+            count = 0
+            equal_to_inner = true
+            values.each do |lst|
+              lst.each do |vl|
+                equal_to_inner = vl.class == nested_dtype
+                if !equal_to_inner || count > 50
+                  break
+                end
+                count += 1
+              end
+            end
+            if equal_to_inner
+              dtype = Utils.rb_type_to_dtype(nested_dtype)
+              # TODO rescue and fallback to new_object
+              return RbSeries.new_list(name, values, dtype)
+            end
+          end
+
+          RbSeries.new_object(name, values, strict)
         else
           constructor = rb_type_to_constructor(value.class)
           constructor.call(name, values, strict)
@@ -1544,8 +3555,11 @@ module Polars
     def rb_type_to_constructor(dtype)
       RB_TYPE_TO_CONSTRUCTOR.fetch(dtype)
     rescue KeyError
-      # RbSeries.method(:new_object)
-      raise ArgumentError, "Cannot determine type"
+      RbSeries.method(:new_object)
+    end
+
+    def _get_first_non_none(values)
+      values.find { |v| !v.nil? }
     end
   end
 end