# `Explorer.Backend.Series`
[🔗](https://github.com/elixir-nx/explorer/blob/v0.12.0/lib/explorer/backend/series.ex#L1)

The behaviour for series backends.

# `df`

```elixir
@type df() :: Explorer.DataFrame.t()
```

# `dtype`

```elixir
@type dtype() :: Explorer.Series.dtype()
```

# `io_result`

```elixir
@type io_result(t) :: {:ok, t} | {:error, Exception.t()}
```

# `lazy_s`

```elixir
@type lazy_s() :: Explorer.Series.lazy_t()
```

# `non_finite`

```elixir
@type non_finite() :: Explorer.Series.non_finite()
```

# `option`

```elixir
@type option(type) :: type | nil
```

# `s`

```elixir
@type s() :: Explorer.Series.t()
```

# `t`

```elixir
@type t() :: struct()
```

# `valid_types`

```elixir
@type valid_types() ::
  number()
  | boolean()
  | String.t()
  | Date.t()
  | Time.t()
  | NaiveDateTime.t()
  | Explorer.Duration.t()
  | Decimal.t()
```

# `abs`

```elixir
@callback abs(s()) :: s()
```

# `acos`

```elixir
@callback acos(s()) :: s()
```

# `add`

```elixir
@callback add(out_dtype :: dtype(), s(), s()) :: s()
```

# `all?`

```elixir
@callback all?(s()) :: boolean() | lazy_s()
```

# `all_equal`

```elixir
@callback all_equal(s(), s()) :: boolean() | lazy_s()
```

# `any?`

```elixir
@callback any?(s()) :: boolean() | lazy_s()
```

# `argmax`

```elixir
@callback argmax(s()) :: number() | non_finite() | lazy_s() | nil
```

# `argmin`

```elixir
@callback argmin(s()) :: number() | non_finite() | lazy_s() | nil
```

# `argsort`

```elixir
@callback argsort(
  s(),
  descending? :: boolean(),
  maintain_order? :: boolean(),
  multithreaded? :: boolean(),
  nulls_last? :: boolean()
) :: s()
```

# `asin`

```elixir
@callback asin(s()) :: s()
```

# `at`

```elixir
@callback at(s(), idx :: integer()) :: s()
```

# `at_every`

```elixir
@callback at_every(s(), integer()) :: s()
```

# `atan`

```elixir
@callback atan(s()) :: s()
```

# `binary_and`

```elixir
@callback binary_and(s(), s()) :: s()
```

# `binary_in`

```elixir
@callback binary_in(s(), s()) :: s()
```

# `binary_or`

```elixir
@callback binary_or(s(), s()) :: s()
```

# `cast`

```elixir
@callback cast(s(), dtype()) :: s()
```

# `categories`

```elixir
@callback categories(s()) :: s()
```

# `categorise`

```elixir
@callback categorise(s(), s()) :: s()
```

# `ceil`

```elixir
@callback ceil(s()) :: s()
```

# `clip`

```elixir
@callback clip(s(), number(), number()) :: s()
```

# `coalesce`

```elixir
@callback coalesce(s(), s()) :: s()
```

# `concat`

```elixir
@callback concat([s()]) :: s()
```

# `contains`

```elixir
@callback contains(s(), String.t()) :: s()
```

# `correlation`

```elixir
@callback correlation(s(), s(), method :: atom()) ::
  float() | non_finite() | lazy_s() | nil
```

# `cos`

```elixir
@callback cos(s()) :: s()
```

# `count`

```elixir
@callback count(s()) :: number() | lazy_s()
```

# `count_matches`

```elixir
@callback count_matches(s(), String.t()) :: s()
```

# `covariance`

```elixir
@callback covariance(s(), s(), ddof :: non_neg_integer()) ::
  float() | non_finite() | lazy_s() | nil
```

# `cumulative_count`

```elixir
@callback cumulative_count(s(), reverse? :: boolean()) :: s()
```

# `cumulative_max`

```elixir
@callback cumulative_max(s(), reverse? :: boolean()) :: s()
```

# `cumulative_min`

```elixir
@callback cumulative_min(s(), reverse? :: boolean()) :: s()
```

# `cumulative_product`

```elixir
@callback cumulative_product(s(), reverse? :: boolean()) :: s()
```

# `cumulative_sum`

```elixir
@callback cumulative_sum(s(), reverse? :: boolean()) :: s()
```

# `cut`

```elixir
@callback cut(
  s(),
  bins :: [float()],
  labels :: option([String.t()]),
  break_point_label :: option(String.t()),
  category_label :: option(String.t()),
  left_close :: boolean(),
  include_breaks :: boolean()
) :: df()
```

# `day_of_month`

```elixir
@callback day_of_month(s()) :: s()
```

# `day_of_week`

```elixir
@callback day_of_week(s()) :: s()
```

# `day_of_year`

```elixir
@callback day_of_year(s()) :: s()
```

# `degrees`

```elixir
@callback degrees(s()) :: s()
```

# `distinct`

```elixir
@callback distinct(s()) :: s()
```

# `divide`

```elixir
@callback divide(out_dtype :: dtype(), s(), s()) :: s()
```

# `downcase`

```elixir
@callback downcase(s()) :: s()
```

# `equal`

```elixir
@callback equal(s(), s()) :: s()
```

# `ewm_mean`

```elixir
@callback ewm_mean(
  s(),
  alpha :: float(),
  adjust :: boolean(),
  min_periods :: integer(),
  ignore_nils :: boolean()
) :: s()
```

# `ewm_standard_deviation`

```elixir
@callback ewm_standard_deviation(
  s(),
  alpha :: float(),
  adjust :: boolean(),
  bias :: boolean(),
  min_periods :: integer(),
  ignore_nils :: boolean()
) :: s()
```

# `ewm_variance`

```elixir
@callback ewm_variance(
  s(),
  alpha :: float(),
  adjust :: boolean(),
  bias :: boolean(),
  min_periods :: integer(),
  ignore_nils :: boolean()
) :: s()
```

# `exp`

```elixir
@callback exp(s()) :: s()
```

# `field`

```elixir
@callback field(s(), String.t()) :: s()
```

# `fill_missing_with_strategy`

```elixir
@callback fill_missing_with_strategy(s(), :backward | :forward | :min | :max | :mean) ::
  s()
```

# `fill_missing_with_value`

```elixir
@callback fill_missing_with_value(s(), :nan | valid_types()) :: s()
```

# `first`

```elixir
@callback first(s()) :: valid_types() | lazy_s()
```

# `floor`

```elixir
@callback floor(s()) :: s()
```

# `format`

```elixir
@callback format([s()]) :: s()
```

# `frequencies`

```elixir
@callback frequencies(s()) :: df()
```

# `from_binary`

```elixir
@callback from_binary(binary(), dtype()) :: s()
```

# `from_list`

```elixir
@callback from_list(list(), dtype()) :: s()
```

# `greater`

```elixir
@callback greater(s(), s()) :: s()
```

# `greater_equal`

```elixir
@callback greater_equal(s(), s()) :: s()
```

# `head`

```elixir
@callback head(s(), n :: integer()) :: s()
```

# `hour`

```elixir
@callback hour(s()) :: s()
```

# `index_of`

```elixir
@callback index_of(s(), valid_types()) :: integer() | nil
```

# `inspect`

```elixir
@callback inspect(s(), opts :: Inspect.Opts.t()) :: Inspect.Algebra.t()
```

# `is_finite`

```elixir
@callback is_finite(s()) :: s()
```

# `is_infinite`

```elixir
@callback is_infinite(s()) :: s()
```

# `is_leap_year`

```elixir
@callback is_leap_year(s()) :: s()
```

# `is_nan`

```elixir
@callback is_nan(s()) :: s()
```

# `is_nil`

```elixir
@callback is_nil(s()) :: s()
```

# `is_not_nil`

```elixir
@callback is_not_nil(s()) :: s()
```

# `iso_year`

```elixir
@callback iso_year(s()) :: s()
```

# `join`

```elixir
@callback join(s(), String.t()) :: s()
```

# `json_decode`

```elixir
@callback json_decode(s(), dtype()) :: s()
```

# `json_path_match`

```elixir
@callback json_path_match(s(), String.t()) :: s()
```

# `last`

```elixir
@callback last(s()) :: valid_types() | lazy_s()
```

# `lengths`

```elixir
@callback lengths(s()) :: s()
```

# `less`

```elixir
@callback less(s(), s()) :: s()
```

# `less_equal`

```elixir
@callback less_equal(s(), s()) :: s()
```

# `log`

```elixir
@callback log(argument :: s()) :: s()
```

# `log`

```elixir
@callback log(argument :: s(), base :: float()) :: s()
```

# `lstrip`

```elixir
@callback lstrip(s(), String.t() | nil) :: s()
```

# `mask`

```elixir
@callback mask(s(), mask :: s()) :: s()
```

# `max`

```elixir
@callback max(s()) ::
  number() | non_finite() | Date.t() | NaiveDateTime.t() | lazy_s() | nil
```

# `mean`

```elixir
@callback mean(s()) :: float() | non_finite() | lazy_s() | nil
```

# `median`

```elixir
@callback median(s()) :: float() | non_finite() | lazy_s() | nil
```

# `member?`

```elixir
@callback member?(s(), valid_types()) :: s()
```

# `min`

```elixir
@callback min(s()) ::
  number() | non_finite() | Date.t() | NaiveDateTime.t() | lazy_s() | nil
```

# `minute`

```elixir
@callback minute(s()) :: s()
```

# `mode`

```elixir
@callback mode(s()) :: s() | lazy_s()
```

# `month`

```elixir
@callback month(s()) :: s()
```

# `multiply`

```elixir
@callback multiply(out_dtype :: dtype(), s(), s()) :: s()
```

# `n_distinct`

```elixir
@callback n_distinct(s()) :: integer() | lazy_s()
```

# `nanosecond`

```elixir
@callback nanosecond(s()) :: s()
```

# `nil_count`

```elixir
@callback nil_count(s()) :: number() | lazy_s()
```

# `not_equal`

```elixir
@callback not_equal(s(), s()) :: s()
```

# `peaks`

```elixir
@callback peaks(s(), :max | :min) :: s()
```

# `pow`

```elixir
@callback pow(out_dtype :: dtype(), s(), s()) :: s()
```

# `product`

```elixir
@callback product(s()) :: float() | non_finite() | lazy_s() | nil
```

# `qcut`

```elixir
@callback qcut(
  s(),
  quantiles :: [float()],
  labels :: option([String.t()]),
  break_point_label :: option(String.t()),
  category_label :: option(String.t()),
  allow_duplicates :: boolean(),
  left_close :: boolean(),
  include_breaks :: boolean()
) :: df()
```

# `quantile`

```elixir
@callback quantile(s(), float()) ::
  number() | non_finite() | Date.t() | NaiveDateTime.t() | lazy_s() | nil
```

# `quarter_of_year`

```elixir
@callback quarter_of_year(s()) :: s()
```

# `quotient`

```elixir
@callback quotient(s(), s()) :: s()
```

# `radians`

```elixir
@callback radians(s()) :: s()
```

# `rank`

```elixir
@callback rank(
  s(),
  method :: atom(),
  descending :: boolean(),
  seed :: option(integer())
) :: s() | lazy_s()
```

# `re_contains`

```elixir
@callback re_contains(s(), String.t()) :: s()
```

# `re_count_matches`

```elixir
@callback re_count_matches(s(), String.t()) :: s()
```

# `re_named_captures`

```elixir
@callback re_named_captures(s(), String.t()) :: s()
```

# `re_replace`

```elixir
@callback re_replace(s(), String.t(), String.t()) :: s()
```

# `re_scan`

```elixir
@callback re_scan(s(), String.t()) :: s()
```

# `remainder`

```elixir
@callback remainder(s(), s()) :: s()
```

# `replace`

```elixir
@callback replace(s(), String.t(), String.t()) :: s()
```

# `reverse`

```elixir
@callback reverse(s()) :: s()
```

# `round`

```elixir
@callback round(s(), decimals :: non_neg_integer()) :: s()
```

# `row_index`

```elixir
@callback row_index(s()) :: s() | lazy_s()
```

# `rstrip`

```elixir
@callback rstrip(s(), String.t() | nil) :: s()
```

# `sample`

```elixir
@callback sample(
  s(),
  n_or_frac :: number(),
  replacement :: boolean(),
  shuffle :: boolean(),
  seed :: option(integer())
) :: s()
```

# `second`

```elixir
@callback second(s()) :: s()
```

# `select`

```elixir
@callback select(predicate :: s(), s(), s()) :: s()
```

# `shift`

```elixir
@callback shift(s(), offset :: integer(), default :: nil) :: s()
```

# `sin`

```elixir
@callback sin(s()) :: s()
```

# `size`

```elixir
@callback size(s()) :: non_neg_integer() | lazy_s()
```

# `skew`

```elixir
@callback skew(s(), bias? :: boolean()) :: float() | non_finite() | lazy_s() | nil
```

# `slice`

```elixir
@callback slice(s(), indices :: list() | s()) :: s()
```

# `slice`

```elixir
@callback slice(s(), offset :: integer(), length :: integer()) :: s()
```

# `sort`

```elixir
@callback sort(
  s(),
  descending? :: boolean(),
  maintain_order? :: boolean(),
  multithreaded? :: boolean(),
  nulls_last? :: boolean()
) :: s()
```

# `split`

```elixir
@callback split(s(), String.t()) :: s()
```

# `split_into`

```elixir
@callback split_into(s(), String.t(), [String.t() | atom()]) :: s()
```

# `standard_deviation`

```elixir
@callback standard_deviation(s(), ddof :: non_neg_integer()) ::
  float() | non_finite() | lazy_s() | nil
```

# `strftime`

```elixir
@callback strftime(s(), String.t()) :: s()
```

# `strip`

```elixir
@callback strip(s(), String.t() | nil) :: s()
```

# `strptime`

```elixir
@callback strptime(s(), String.t()) :: s()
```

# `substring`

```elixir
@callback substring(s(), integer(), non_neg_integer() | nil) :: s()
```

# `subtract`

```elixir
@callback subtract(out_dtype :: dtype(), s(), s()) :: s()
```

# `sum`

```elixir
@callback sum(s()) :: number() | non_finite() | lazy_s() | nil
```

# `tail`

```elixir
@callback tail(s(), n :: integer()) :: s()
```

# `tan`

```elixir
@callback tan(s()) :: s()
```

# `to_iovec`

```elixir
@callback to_iovec(s()) :: [binary()]
```

# `to_list`

```elixir
@callback to_list(s()) :: list()
```

# `transform`

```elixir
@callback transform(s(), fun()) :: s()
```

# `unary_not`

```elixir
@callback unary_not(s()) :: s()
```

# `unordered_distinct`

```elixir
@callback unordered_distinct(s()) :: s()
```

# `upcase`

```elixir
@callback upcase(s()) :: s()
```

# `variance`

```elixir
@callback variance(s(), ddof :: non_neg_integer()) ::
  float() | non_finite() | lazy_s() | nil
```

# `week_of_year`

```elixir
@callback week_of_year(s()) :: s()
```

# `window_max`

```elixir
@callback window_max(
  s(),
  window_size :: integer(),
  weights :: [float()] | nil,
  min_periods :: integer() | nil,
  center :: boolean()
) :: s()
```

# `window_mean`

```elixir
@callback window_mean(
  s(),
  window_size :: integer(),
  weights :: [float()] | nil,
  min_periods :: integer() | nil,
  center :: boolean()
) :: s()
```

# `window_median`

```elixir
@callback window_median(
  s(),
  window_size :: integer(),
  weights :: [float()] | nil,
  min_periods :: integer() | nil,
  center :: boolean()
) :: s()
```

# `window_min`

```elixir
@callback window_min(
  s(),
  window_size :: integer(),
  weights :: [float()] | nil,
  min_periods :: integer() | nil,
  center :: boolean()
) :: s()
```

# `window_standard_deviation`

```elixir
@callback window_standard_deviation(
  s(),
  window_size :: integer(),
  weights :: [float()] | nil,
  min_periods :: integer() | nil,
  center :: boolean()
) :: s()
```

# `window_sum`

```elixir
@callback window_sum(
  s(),
  window_size :: integer(),
  weights :: [float()] | nil,
  min_periods :: integer() | nil,
  center :: boolean()
) :: s()
```

# `year`

```elixir
@callback year(s()) :: s()
```

# `inspect`

Default inspect implementation for backends.

# `new`

Create a new `Series`.

---

*Consult [api-reference.md](api-reference.md) for complete listing*