class_docstr: Nonparametric censored regression.
  
  Calculates the conditional mean ``E[y|X]`` where ``y = g(X) + e``,
  where y is left-censored.  Left censored variable Y is defined as
  ``Y = min {Y', L}`` where ``L`` is the value at which ``Y`` is censored
  and ``Y'`` is the true value of the variable.
  
  Parameters
  ----------
  endog : list with one element which is array_like
      This is the dependent variable.
  exog : list
      The training data for the independent variable(s)
      Each element in the list is a separate variable
  dep_type : str
      The type of the dependent variable(s)
      c: Continuous
      u: Unordered (Discrete)
      o: Ordered (Discrete)
  reg_type : str
      Type of regression estimator
      lc: Local Constant Estimator
      ll: Local Linear Estimator
  bw : array_like
      Either a user-specified bandwidth or
      the method for bandwidth selection.
      cv_ls: cross-validation least squares
      aic: AIC Hurvich Estimator
  ckertype : str, optional
      The kernel used for the continuous variables.
  okertype : str, optional
      The kernel used for the ordered discrete variables.
  ukertype : str, optional
      The kernel used for the unordered discrete variables.
  censor_val : float
      Value at which the dependent variable is censored
  defaults : EstimatorSettings instance, optional
      The default values for the efficient bandwidth estimation
  
  Attributes
  ----------
  bw : array_like
      The bandwidth parameters
code: def censored(self, censor_val):
      # see pp. 341-344 in [1]
      self.d = (self.endog != censor_val) * 1.0
      ix = np.argsort(np.squeeze(self.endog))
      self.sortix = ix
      self.sortix_rev = np.zeros(ix.shape, int)
      self.sortix_rev[ix] = np.arange(len(ix))
      self.endog = np.squeeze(self.endog[ix])
      self.endog = _adjust_shape(self.endog, 1)
      self.exog = np.squeeze(self.exog[ix])
      self.d = np.squeeze(self.d[ix])
      self.W_in = np.empty((self.nobs, 1))
      for i in range(1, self.nobs + 1):
          P = 1
          for j in range(1, i):
              P *= (
                  (self.nobs - j) / (float(self.nobs) - j + 1)
              ) ** self.d[j - 1]
          self.W_in[i - 1, 0] = (
              P * self.d[i - 1] / (float(self.nobs) - i + 1)
          )
  
imports: import copy
  import numpy
  from scipy import optimize
  from scipy.stats.mstats import mquantiles
  from ._kernel_base import GenericKDE, EstimatorSettings, gpke, LeaveOneOut, _get_type_pos, _adjust_shape, _compute_min_std_IQR, kernel_func
label_desc: Use image node_id 2 for calling the KernelCensoredReg obj's underlying member method code with example usage: obj.censored(censor_val) without return types