code: def make_regression(
      series_len,
      coefs,
      loc=0.0,
      scale=0.5,
      cov=None,
      noise_scale=1.0,
      bias=None,
      relevance=1.0,
      sparsity=0.2,
      seed=1,
  ):
      """Module to generate multiplicative time-series with trend, seasonality and regression components
      Parameters
      ----------
      series_len: int
          Total length of series
      coefs: 1-D array_like
          Values used as regression coefficients
      loc: float
          Location parameter to generate regressor values
      scale: float
          Scale parameter to generate regressor values
      cov: 2-D array_like, of shape (num_of_regressors, num_of_regressors)
          Covariance of regressors; need to be positive definite
      noise_scale:
          Scale parameter in the white noise generation process
      bias: float
          bias or intercept of the regression component; if None, bias is set to zero.
      relevance: float
          0 to 1; smaller value indicates less number of total useful regressors
      sparsity: float
          0 to 1 to control probability (= 1 - sparsity) at time t of a regressor value > 0
      seed: int
          Seed passed into `np.random.default_rng()`
  
      Returns
      -------
      x: 2-D array like
          Regressors simulated array. Should be with shape (series_len, num_of_regressors);
      y: 1-D array like
          Regression derived by product of X and coefficients plus noise
      coefs: float
          Coefficients modified in the process due to sparsity; if sparsity=0, it should be identical to coefs inputted
          by user
      """
  
      num_of_regressors = len(coefs)
      if (relevance > 0.0) and (relevance < 1.0):
          num_of_irr_coefs = int(num_of_regressors * (1 - relevance))
          coefs = np.copy(coefs)
          irr_idx = np.random.choice(
              num_of_regressors, num_of_irr_coefs, replace=False
          )
          coefs[irr_idx] = 0.0
  
      if cov is None:
          x = (
              np.random.default_rng(seed)
              .normal(loc, scale, series_len * num_of_regressors)
              .reshape(series_len, -1)
          )
      else:
          x = np.random.default_rng(seed).multivariate_normal(
              np.array([loc] * num_of_regressors, dtype=np.float64),
              cov,
              series_len,
          )
      # control probability of regression kick-in
      if (sparsity > 0.0) and (sparsity < 1.0):
          z = (
              np.random.default_rng(seed)
              .binomial(1, 1 - sparsity, series_len * num_of_regressors)
              .reshape(series_len, -1)
          )
          x = x * z
  
      noise = np.random.default_rng(seed).normal(
          0, noise_scale, series_len
      )
      # make observed response
      if bias:
          y = bias + np.matmul(x, coefs) + noise
      else:
          y = np.matmul(x, coefs) + noise
  
      return x, y, coefs
  
file_path: orbit/orbit/utils/simulation.py
imports: import numpy
  import pandas
  from statsmodels.tsa.arima_process import ArmaProcess
  import math
  from math import pi
  from orbit.exceptions import IllegalArgument
label_desc: Use image node_id 3 for calling a global function with example usage: make_regression(series_len, coefs, loc, scale, cov, noise_scale, bias, relevance, sparsity, seed) and returns: x,  y,  coefs