class_docstr: Simulation of a Cox regression for proportional hazards with cut-points
  effects in the features
  
  Parameters
  ----------
  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=5
      Number of features
  
  times_distribution : `str`, default="weibull"
      The distrubution of times. Only ``"weibull"``
      is implemented for now
  
  scale : `float`, default=1.0
      Scaling parameter to use in the distribution of times
  
  shape : `float`, default=1.0
      Shape parameter to use in the distribution of times
  
  censoring_factor : `float`, default=2.0
      Level of censoring. Increasing censoring_factor leads
      to less censored times and conversely.
  
  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`, default=None
      The seed of the random number generator. If `None` it is not
      seeded
  
  verbose : `bool`, default=True
      If True, print things
  
  n_cut_points : `int`, default="none"
      Number of cut-points generated per feature. If `None` it is sampled from
      a geometric distribution of parameter n_cut_points_factor.
  
  n_cut_points_factor : `float`, default=0.7
      Parameter of the geometric distribution used to generate the number of
      cut-points when n_cut_points is `None`. Increasing n_cut_points_factor
      leads to less cut-points per feature on average.
  
  sparsity : `float`, default=0
      Percentage of block sparsity induced in the coefficient vector. Must be
      in [0, 1].
  
  Attributes
  ----------
  features : `numpy.ndarray`, shape=(n_samples, n_features)
      The simulated (or given) features matrix
  
  times : `numpy.ndarray`, shape=(n_samples,)
      Simulated times
  
  censoring : `numpy.ndarray`, shape=(n_samples,)
      Simulated censoring indicator, where ``censoring[i] == 1``
      indicates that the time of the i-th individual is a failure
      time, and where ``censoring[i] == 0`` means that the time of
      the i-th individual is a censoring time
  
  Notes
  -----
  There is no intercept in this model
code: def __init__(
      self,
      features: np.ndarray = None,
      n_samples: int = 200,
      n_features: int = 5,
      n_cut_points: int = None,
      n_cut_points_factor: float = 0.7,
      times_distribution: str = "weibull",
      shape: float = 1.0,
      scale: float = 1.0,
      censoring_factor: float = 2.0,
      features_type: str = "cov_toeplitz",
      cov_corr: float = 0.5,
      features_scaling: str = "none",
      seed: int = None,
      verbose: bool = True,
      sparsity=0,
  ):
      # intercept=None in this model
      SimuWithFeatures.__init__(
          self,
          None,
          features,
          n_samples,
          n_features,
          features_type,
          cov_corr,
          features_scaling,
          seed,
          verbose,
      )
  
      self.shape = shape
      self.scale = scale
      self.censoring_factor = censoring_factor
      self.times_distribution = times_distribution
      self.n_cut_points = n_cut_points
      self.n_cut_points_factor = n_cut_points_factor
      self.sparsity = sparsity
      self.features = None
      self.times = None
      self.censoring = None
  
imports: import numpy
  from tick.base.simulation import SimuWithFeatures
  from tick.preprocessing.features_binarizer import FeaturesBinarizer
label_desc: Use image node_id 1 to create a new SimuCoxRegWithCutPoints object from inherited base classes: SimuWithFeatures with example: obj = SimuCoxRegWithCutPoints(features, n_samples, n_features, n_cut_points, n_cut_points_factor, times_distribution, shape, scale, censoring_factor, features_type, cov_corr, features_scaling, seed, verbose, sparsity)