class_docstr: Inherits time series methods from the TSM parent class.
  
  **** AUTOREGRESSIVE INTEGRATED MOVING AVERAGE (ARIMA) MODELS ****
  
  Parameters
  ----------
  data : pd.DataFrame or np.ndarray
      Field to specify the univariate time series data that will be used.
  
  ar : int
      Field to specify how many AR lags the model will have.
  
  ma : int
      Field to specify how many MA lags the model will have.
  
  integ : int (default : 0)
      Specifies how many times to difference the time series.
  
  target : str (if data is a pd.DataFrame) or int (if data is a np.ndarray)
      Specifies which column name or array index to use. By default, first
      column/array index will be selected as the dependent variable.
  
  family : family object
      E.g pf.Normal(), pf.t(), pf.Laplace()...
code: def __init__(
      self, data, ar, ma, integ=0, target=None, family=fam.Normal()
  ):
      super(ARIMA, self).__init__("ARIMA")
  
      # Latent Variable information
      self.ar = ar
      self.ma = ma
      self.integ = integ
      self.z_no = self.ar + self.ma + 2
      self.max_lag = max(self.ar, self.ma)
      self._z_hide = (
          0  # Whether to cutoff latent variables from results table
      )
      self.supported_methods = ["MLE", "PML", "Laplace", "M-H", "BBVI"]
      self.default_method = "MLE"
      self.multivariate_model = False
  
      # Format the data
      (
          self.data,
          self.data_name,
          self.is_pandas,
          self.index,
      ) = dc.data_check(data, target)
      self.data = self.data.astype(
          np.float
      )  # treat as float for Cython
      self.data_original = self.data.copy()
  
      # Difference data
      for order in range(0, self.integ):
          self.data = np.diff(self.data)
          self.data_name = "Differenced " + self.data_name
      self.data_length = self.data.shape[0]
  
      self.X = self._ar_matrix()
      self._create_latent_variables()
  
      self.family = family
      (
          self.model_name2,
          self.link,
          self.scale,
          self.shape,
          self.skewness,
          self.mean_transform,
          self.cythonized,
      ) = self.family.setup()
      self.model_name = (
          self.model_name2
          + " ARIMA("
          + str(self.ar)
          + ","
          + str(self.integ)
          + ","
          + str(self.ma)
          + ")"
      )
  
      # Build any remaining latent variables that are specific to the family chosen
      for no, i in enumerate(self.family.build_latent_variables()):
          self.latent_variables.add_z(i[0], i[1], i[2])
          self.latent_variables.z_list[
              1 + no + self.ar + self.ma
          ].start = i[3]
      self.latent_variables.z_list[0].start = self.mean_transform(
          np.mean(self.data)
      )
  
      self.family_z_no = len(self.family.build_latent_variables())
      self.z_no = len(self.latent_variables.z_list)
  
      # If Normal family is selected, we use faster likelihood functions
      if isinstance(self.family, fam.Normal):
          self._model = self._normal_model
          self._mb_model = self._mb_normal_model
          self.neg_loglik = self.normal_neg_loglik
          self.mb_neg_loglik = self.normal_mb_neg_loglik
      elif (
          isinstance(self.family, fam.t)
          or isinstance(self.family, fam.Cauchy)
          or isinstance(self.family, fam.Laplace)
      ):
          self._model = self._normal_model
          self._mb_model = self._mb_normal_model
          self.neg_loglik = self.non_normal_neg_loglik
          self.mb_neg_loglik = self.non_normal_mb_neg_loglik
      elif isinstance(self.family, fam.Poisson):
          self._model = self._poisson_model
          self._mb_model = self._mb_poisson_model
          self.neg_loglik = self.non_normal_neg_loglik
          self.mb_neg_loglik = self.non_normal_mb_neg_loglik
      else:
          self._model = self._non_normal_model
          self._mb_model = self._mb_non_normal_model
          self.neg_loglik = self.non_normal_neg_loglik
          self.mb_neg_loglik = self.non_normal_mb_neg_loglik
  
imports: import sys
  import numpy
  import pandas
  import scipy.stats
  import scipy.special
  from ..None import families
  from ..None import output
  from ..None import tests
  from ..None import tsm
  from ..None import data_check
  from .arma_recursions import arima_recursion, arima_recursion_normal, arima_recursion_poisson
label_desc: Use image node_id 1 to create a new ARIMA object from inherited base classes: tsm with example: obj = ARIMA(data, ar, ma, integ, target, family)