code: def autoregressive_timeseries(
      coef: Sequence[float],
      start_values: Optional[Sequence[float]] = None,
      start: Optional[Union[pd.Timestamp, int]] = pd.Timestamp(
          "2000-01-01"
      ),
      end: Optional[Union[pd.Timestamp, int]] = None,
      length: Optional[int] = None,
      freq: Union[str, int] = None,
      column_name: Optional[str] = "autoregressive",
  ) -> TimeSeries:
      """
      Creates a univariate, autoregressive TimeSeries whose values are calculated using specified coefficients `coef` and
      starting values `start_values`.
  
      Parameters
      ----------
      coef
          The autoregressive coefficients used for calculating the next time step.
          series[t] = coef[-1] * series[t-1] + coef[-2] * series[t-2] + ... + coef[0] * series[t-len(coef)]
      start_values
          The starting values used for calculating the first few values for which no lags exist yet.
          series[0] = coef[-1] * starting_values[-1] + coef[-2] * starting_values[-2] + ... + coef[0] * starting_values[0]
      start
          The start of the returned TimeSeries' index. If a pandas Timestamp is passed, the TimeSeries will have a pandas
          DatetimeIndex. If an integer is passed, the TimeSeries will have a pandas RangeIndex index. Works only with
          either `length` or `end`.
      end
          Optionally, the end of the returned index. Works only with either `start` or `length`. If `start` is
          set, `end` must be of same type as `start`. Else, it can be either a pandas Timestamp or an integer.
      length
          Optionally, the length of the returned index. Works only with either `start` or `end`.
      freq
          The time difference between two adjacent entries in the returned index. In case `start` is a timestamp,
          a DateOffset alias is expected; see
          `docs <https://pandas.pydata.org/pandas-docs/stable/user_guide/TimeSeries.html#dateoffset-objects>`_.
          By default, "D" (daily) is used.
          If `start` is an integer, `freq` will be interpreted as the step size in the underlying RangeIndex.
          The freq is optional for generating an integer index (if not specified, 1 is used).
      column_name
          Optionally, the name of the value column for the returned TimeSeries
  
      Returns
      -------
      TimeSeries
          An autoregressive TimeSeries created as indicated above.
      """
  
      # if no start values specified default to a list of 1s
      if start_values is None:
          start_values = np.ones(len(coef))
      else:
          raise_if_not(
              len(start_values) == len(coef),
              "start_values must have same length as coef.",
          )
  
      index = generate_index(
          start=start, end=end, freq=freq, length=length
      )
  
      values = np.empty(len(coef) + len(index))
      values[: len(coef)] = start_values
  
      for i in range(len(coef), len(coef) + len(index)):
          # calculate next time step as dot product of coefs with previous len(coef) time steps
          values[i] = np.dot(values[i - len(coef) : i], coef)
  
      return TimeSeries.from_times_and_values(
          index,
          values[len(coef) :],
          freq=freq,
          columns=pd.Index([column_name]),
      )
  
file_path: darts/darts/utils/timeseries_generation.py
imports: import math
  from typing import List, Optional, Sequence, Tuple, Union
  import holidays
  import numpy
  import pandas
  from darts import TimeSeries
  from darts.logging import get_logger, raise_if, raise_if_not, raise_log
label_desc: Use image node_id 7 for calling a global function with example usage: autoregressive_timeseries(coef, start_values, start, end, length, freq, column_name) and returns: TimeSeries