class_docstr: Abstract class for the simulation of a model with a features
  matrix.
  
  Parameters
  ----------
  intercept : `float`, default=`None`
      The intercept. If None, then no intercept is used
  
  features : `numpy.ndarray`, shape=(n_samples, n_features), default=`None`
      The features matrix to use. If None, it is simulated
  
  n_samples : `int`, default=200
      Number of samples
  
  n_features : `int`, default=30
      Number of features
  
  features_type : `str`, default="cov_toeplitz"
      The type of features matrix to simulate
  
      * If ``"cov_toeplitz"`` : a Gaussian distribution with
        Toeplitz correlation matrix
  
      * If ``"cov_uniform"`` : a Gaussian distribution with
        correlation matrix given by O.5 * (U + U.T), where U is
        uniform on [0, 1] and diagonal filled with ones.
  
  cov_corr : `float`, default=0.5
      Correlation to use in the Toeplitz correlation matrix
  
  features_scaling : `str`, default="none"
      The way the features matrix is scaled after simulation
  
      * If ``"standard"`` : the columns are centered and
        normalized
  
      * If ``"min-max"`` : remove the minimum and divide by
        max-min
  
      * If ``"norm"`` : the columns are normalized but not centered
  
      * If ``"none"`` : nothing is done to the features
  
  seed : `int`
      The seed of the random number generator
  
  verbose : `bool`
      If True, print things
  
  dtype : `{'float64', 'float32'}`, default='float64'
      Type of the generated arrays.
      Used in the case features is None
code: def __init__(
      self,
      intercept: float = None,
      features: np.ndarray = None,
      n_samples: int = 200,
      n_features: int = 30,
      features_type: str = "cov_toeplitz",
      cov_corr: float = 0.5,
      features_scaling: str = "none",
      seed: int = None,
      verbose: bool = True,
      dtype="float64",
  ):
      Simu.__init__(self, seed, verbose)
      self.intercept = intercept
      self.features = features
      self.n_samples = n_samples
      self.n_features = n_features
      self.features_type = features_type
      self.cov_corr = cov_corr
      self.features_scaling = features_scaling
      self.features = None
      self.dtype = dtype
  
      if features is not None:
          if n_features != features.shape[1]:
              raise ValueError(
                  "``n_features`` does not match size of" "``features``"
              )
          if n_samples != features.shape[0]:
              raise ValueError(
                  "``n_samples`` does not match size of" "``features``"
              )
          features_type = "given"
  
          self.features = features
          n_samples, n_features = features.shape
          self.n_samples = n_samples
          self.n_features = n_features
          self.features_type = features_type
          self.dtype = self.features.dtype
  
file_path: tick/tick/base/simulation/simu_with_features.py
imports: import numpy
  from warnings import warn
  from os import linesep
  from .None import Simu
  from tick.simulation import features_normal_cov_toeplitz, features_normal_cov_uniform
label_desc: Use image node_id 1 to create a new SimuWithFeatures object from inherited base classes: Simu with example: obj = SimuWithFeatures(intercept, features, n_samples, n_features, features_type, cov_corr, features_scaling, seed, verbose, dtype)