q-Ph$ddlmZddlZddlmZmZddlmZddl m Z ddl m Z ddl mZeje5ddlmZdddn #1swxYwYddlmZerdd lmZmZdd lmZmZmZmZmZed d d d,dZed dd-dZed dd.dZe d d!d d.d"Zed d d d#d/d'Zed d d(d0d)Zed d d(d1d*Zd d!d!d#d1d+ZdS)2) annotationsN) TYPE_CHECKINGoverload) functions)parse_into_expression)unstable) wrap_expr)Literal)ExprSeries)ClosedIntervalIntoExprIntoExprColumnNumericLiteralTemporalLiteral.)closedeagerstart+NumericLiteral | TemporalLiteral | IntoExprend num_samplesint | IntoExprrr rLiteral[False]returnr cdSNrrrrrs c/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/polars/functions/range/linear_space.py linear_spacer s  3)r Literal[True]r cdSrrrs rr r &s Sr!bool Expr | SeriescdSrrrs rr r 1s Cr!bothFct|}t|}t|}ttj||||}|r&t j|S|S)u Create sequence of evenly-spaced points. Parameters ---------- start Lower bound of the range. end Upper bound of the range. num_samples Number of samples in the output sequence. closed : {'both', 'left', 'right', 'none'} Define which sides of the interval are closed (inclusive). eager Evaluate immediately and return a `Series`. If set to `False` (default), return an expression instead. .. warning:: This functionality is experimental. It may be changed at any point without it being considered a breaking change. Notes ----- `linear_space` works with numeric and temporal dtypes. When the `start` and `end` parameters are `Date` dtypes, the output sequence consists of equally-spaced `Datetime` elements with millisecond precision. Returns ------- Expr or Series Column of data type `:class:Time`. Examples -------- >>> pl.linear_space(start=0, end=1, num_samples=3, eager=True) shape: (3,) Series: 'literal' [f64] [ 0.0 0.5 1.0 ] >>> pl.linear_space(start=0, end=1, num_samples=3, closed="left", eager=True) shape: (3,) Series: 'literal' [f64] [ 0.0 0.333333 0.666667 ] >>> pl.linear_space(start=0, end=1, num_samples=3, closed="right", eager=True) shape: (3,) Series: 'literal' [f64] [ 0.333333 0.666667 1.0 ] >>> pl.linear_space(start=0, end=1, num_samples=3, closed="none", eager=True) shape: (3,) Series: 'literal' [f64] [ 0.25 0.5 0.75 ] >>> from datetime import time >>> pl.linear_space( ... start=time(hour=1), end=time(hour=12), num_samples=3, eager=True ... ) shape: (3,) Series: 'literal' [time] [ 01:00:00 06:30:00 12:00:00 ] `Date` endpoints generate a sequence of `Datetime` values: >>> from datetime import date >>> pl.linear_space( ... start=date(2025, 1, 1), ... end=date(2025, 2, 1), ... num_samples=3, ... closed="right", ... eager=True, ... ) shape: (3,) Series: 'literal' [datetime[ms]] [ 2025-01-11 08:00:00 2025-01-21 16:00:00 2025-02-01 00:00:00 ] When `eager=False` (default), an expression is produced. You can generate a sequence using the length of the dataframe: >>> df = pl.DataFrame({"a": [1, 2, 3, 4, 5]}) >>> df.with_columns(pl.linear_space(0, 1, pl.len()).alias("ls")) shape: (5, 2) ┌─────┬──────┐ │ a ┆ ls │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪══════╡ │ 1 ┆ 0.0 │ │ 2 ┆ 0.25 │ │ 3 ┆ 0.5 │ │ 4 ┆ 0.75 │ │ 5 ┆ 1.0 │ └─────┴──────┘ )rr plrr Fselect to_series)rrrrrresults rr r <ssv "% ( (E  $ $C' 44K s'sKHH I IF ,x))+++ Mr!)ras_arrayr1NumericLiteral | TemporalLiteral | IntoExprColumnint | IntoExprColumnr.cdSrrrrrrr.rs r linear_spacesr3s  3r!)rr.cdSrrr2s rr3r3s Sr!cdSrrr2s rr3r3s Cr!c t|}t|}t|}ttj|||||}|r&t j|S|S)u{ Generate a sequence of evenly-spaced values for each row between `start` and `end`. The number of values in each sequence is determined by `num_samples`. Parameters ---------- start Lower bound of the range. end Upper bound of the range. num_samples Number of samples in the output sequence. closed : {'both', 'left', 'right', 'none'} Define which sides of the interval are closed (inclusive). as_array Return result as a fixed-length `Array`. `num_samples` must be a constant. eager Evaluate immediately and return a `Series`. If set to `False` (default), return an expression instead. .. warning:: This functionality is experimental. It may be changed at any point without it being considered a breaking change. Returns ------- Expr or Series Column of data type `List(dtype)`. See Also -------- linear_space : Generate a single sequence of linearly-spaced values. Examples -------- >>> df = pl.DataFrame({"start": [1, -1], "end": [3, 2], "num_samples": [4, 5]}) >>> df.with_columns(ls=pl.linear_spaces("start", "end", "num_samples")) shape: (2, 4) ┌───────┬─────┬─────────────┬────────────────────────┐ │ start ┆ end ┆ num_samples ┆ ls │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 ┆ list[f64] │ ╞═══════╪═════╪═════════════╪════════════════════════╡ │ 1 ┆ 3 ┆ 4 ┆ [1.0, 1.666667, … 3.0] │ │ -1 ┆ 2 ┆ 5 ┆ [-1.0, -0.25, … 2.0] │ └───────┴─────┴─────────────┴────────────────────────┘ >>> df.with_columns(ls=pl.linear_spaces("start", "end", 3, as_array=True)) shape: (2, 4) ┌───────┬─────┬─────────────┬──────────────────┐ │ start ┆ end ┆ num_samples ┆ ls │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 ┆ array[f64, 3] │ ╞═══════╪═════╪═════════════╪══════════════════╡ │ 1 ┆ 3 ┆ 4 ┆ [1.0, 2.0, 3.0] │ │ -1 ┆ 2 ┆ 5 ┆ [-1.0, 0.5, 2.0] │ └───────┴─────┴─────────────┴──────────────────┘ )rr r)r3r*r+r,)rrrrr.rr-s rr3r3suF "% ( (E  $ $C' 44K s([&(SS T TF ,x))+++ Mr!) rrrrrrrr rrrr ) rrrrrrrr rr"rr ) rrrrrrrr rr$rr%)rr/rr/rr0rr r.r$rrrr )rr/rr/rr0rr r.r$rr"rr )rr/rr/rr0rr r.r$rr$rr%) __future__r contextlibtypingrrpolarsrr*polars._utils.parserpolars._utils.unstablerpolars._utils.wrapr suppress ImportError polars.polarsr)r r r polars._typingr rrrrr r3rr!rrBs""""""********!!!!!!555555++++++((((((Z%%                 ######## !   !   !    $ BBBBB BJ !  !   !   $KKKKKKKKsAAA