"""
This type stub file was generated by pyright.
"""

import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore
import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel

class vtkStatisticsAlgorithm(__vtkmodules_vtkCommonExecutionModel.vtkTableAlgorithm):
    """
    vtkStatisticsAlgorithm - Base class for statistics algorithms
    
    Superclass: vtkTableAlgorithm
    
    All statistics algorithms can conceptually be operated with several
    operations:
    * Learn: given an input data set, calculate a minimal statistical
      model (e.g., sums, raw moments, joint probabilities).
    * Derive: given an input minimal statistical model, derive the full
      model (e.g., descriptive statistics, quantiles, correlations,
      conditional probabilities). NB: It may be, or not be, a problem
      that a full model was not derived. For instance, when doing
      parallel calculations, one only wants to derive the full model
      after all partial calculations have completed. On the other hand,
      one can also directly provide a full model, that was previously
      calculated or guessed, and not derive a new one.
    * Assess: given an input data set, input statistics, and some form of
      threshold, assess a subset of the data set.
    * Test: perform at least one statistical test. Therefore, a
      vtkStatisticsAlgorithm has the following ports
    * 3 optional input ports:
    * Data (vtkTable)
    * Parameters to the learn operation (vtkTable)
    * Input model (vtkMultiBlockDataSet)
    * 3 output ports:
    * Data (input annotated with assessments when the Assess operation is
    ON).
    * Output model (identical to the input model when Learn operation is
      OFF).
    * Output of statistical tests. Some engines do not offer such tests
      yet, in which case this output will always be empty even when the
      Test operation is ON.
    
    @par Thanks: Thanks to Philippe Pebay and David Thompson from Sandia
    National Laboratories for implementing this class. Updated by
    Philippe Pebay, Kitware SAS 2012
    """
    def AddColumn(self, string):
        """
        V.AddColumn(string)
        C++: void AddColumn(const char *namCol)
        
        Convenience method to create a request with a single column name
        namCol in a single call; this is the preferred method to select
        columns, ensuring selection consistency (a single column per
        request). Warning: no name checking is performed on namCol; it is
        the user's responsibility to use valid column names.
        """
        ...
    
    def AddColumnPair(self, string, string_1):
        """
        V.AddColumnPair(string, string)
        C++: void AddColumnPair(const char *namColX, const char *namColY)
        
        Convenience method to create a request with a single column name
        pair ( namColX, namColY) in a single call; this is the preferred
        method to select columns pairs, ensuring selection consistency (a
        pair of columns per request).
        
        * Unlike SetColumnStatus(), you need not call
          RequestSelectedColumns() after AddColumnPair().
        
        * Warning: namColX and namColY are only checked for their
          validity as strings;
        * no check is made that either are valid column names.
        """
        ...
    
    def Aggregate(self, vtkDataObjectCollection, vtkMultiBlockDataSet):
        """
        V.Aggregate(vtkDataObjectCollection, vtkMultiBlockDataSet)
        C++: virtual void Aggregate(vtkDataObjectCollection *,
            vtkMultiBlockDataSet *)
        
        Given a collection of models, calculate aggregate model
        """
        ...
    
    def GetAssessNames(self):
        """
        V.GetAssessNames() -> vtkStringArray
        C++: virtual vtkStringArray *GetAssessNames()
        
        Set/get assessment names.
        """
        ...
    
    def GetAssessOption(self):
        """
        V.GetAssessOption() -> bool
        C++: virtual bool GetAssessOption()
        
        Set/Get the Assess operation.
        """
        ...
    
    def GetColumnForRequest(self, p_int, p_int_1):
        """
        V.GetColumnForRequest(int, int) -> string
        C++: virtual const char *GetColumnForRequest(vtkIdType r,
            vtkIdType c)
        V.GetColumnForRequest(int, int, string) -> int
        C++: virtual int GetColumnForRequest(vtkIdType r, vtkIdType c,
            vtkStdString &columnName)
        
        Provide the name of the c-th column for the r-th request.
        
        * For the version of this routine that returns an integer,
        * if the request or column does not exist because r or c is out
          of bounds,
        * this routine returns 0 and the value of columnName is
          unspecified.
        * Otherwise, it returns 1 and the value of columnName is set.
        
        * For the version of this routine that returns const char*,
        * if the request or column does not exist because r or c is out
          of bounds,
        * the routine returns nullptr. Otherwise it returns the column
          name.
        * This version is not thread-safe.
        """
        ...
    
    def GetDeriveOption(self):
        """
        V.GetDeriveOption() -> bool
        C++: virtual bool GetDeriveOption()
        
        Set/Get the Derive operation.
        """
        ...
    
    def GetLearnOption(self):
        """
        V.GetLearnOption() -> bool
        C++: virtual bool GetLearnOption()
        
        Set/Get the Learn operation.
        """
        ...
    
    def GetNumberOfColumnsForRequest(self, p_int):
        """
        V.GetNumberOfColumnsForRequest(int) -> int
        C++: virtual vtkIdType GetNumberOfColumnsForRequest(
            vtkIdType request)
        
        Return the number of columns for a given request.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfPrimaryTables(self):
        """
        V.GetNumberOfPrimaryTables() -> int
        C++: virtual vtkIdType GetNumberOfPrimaryTables()
        
        Set/Get the number of tables in the primary model.
        """
        ...
    
    def GetNumberOfRequests(self):
        """
        V.GetNumberOfRequests() -> int
        C++: virtual vtkIdType GetNumberOfRequests()
        
        Return the number of requests. This does not include any request
        that is in the column-status buffer but for which
        RequestSelectedColumns() has not yet been called (even though it
        is possible this request will be honored when the filter is run
        -- see SetColumnStatus() for more information).
        """
        ...
    
    def GetTestOption(self):
        """
        V.GetTestOption() -> bool
        C++: virtual bool GetTestOption()
        
        Set/Get the Test operation.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkStatisticsAlgorithm
        C++: vtkStatisticsAlgorithm *NewInstance()
        """
        ...
    
    def RequestSelectedColumns(self):
        """
        V.RequestSelectedColumns() -> int
        C++: virtual int RequestSelectedColumns()
        
        Use the current column status values to produce a new request for
        statistics to be produced when RequestData() is called. See
        SetColumnStatus() for more information.
        """
        ...
    
    def ResetAllColumnStates(self):
        """
        V.ResetAllColumnStates()
        C++: virtual void ResetAllColumnStates()
        
        Set the status of each and every column in the current request to
        OFF (0).
        """
        ...
    
    def ResetRequests(self):
        """
        V.ResetRequests()
        C++: virtual void ResetRequests()
        
        Empty the list of current requests.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkStatisticsAlgorithm
        C++: static vtkStatisticsAlgorithm *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetAssessNames(self, vtkStringArray):
        """
        V.SetAssessNames(vtkStringArray)
        C++: virtual void SetAssessNames(vtkStringArray *)
        
        Set/get assessment names.
        """
        ...
    
    def SetAssessOption(self, bool):
        """
        V.SetAssessOption(bool)
        C++: virtual void SetAssessOption(bool _arg)
        
        Set/Get the Assess operation.
        """
        ...
    
    def SetColumnStatus(self, string, p_int):
        """
        V.SetColumnStatus(string, int)
        C++: virtual void SetColumnStatus(const char *namCol, int status)
        
        Add or remove a column from the current analysis request. Once
        all the column status values are set, call
        RequestSelectedColumns() before selecting another set of columns
        for a different analysis request. The way that columns selections
        are used varies from algorithm to algorithm.
        
        * Note: the set of selected columns is maintained in
          vtkStatisticsAlgorithmPrivate::Buffer
        * until RequestSelectedColumns() is called, at which point the
          set is appended
        * to vtkStatisticsAlgorithmPrivate::Requests.
        * If there are any columns in
          vtkStatisticsAlgorithmPrivate::Buffer at the time
        * RequestData() is called, RequestSelectedColumns() will be
          called and the
        * selection added to the list of requests.
        """
        ...
    
    def SetDeriveOption(self, bool):
        """
        V.SetDeriveOption(bool)
        C++: virtual void SetDeriveOption(bool _arg)
        
        Set/Get the Derive operation.
        """
        ...
    
    def SetInputModel(self, vtkDataObject):
        """
        V.SetInputModel(vtkDataObject)
        C++: virtual void SetInputModel(vtkDataObject *model)
        
        A convenience method for setting the input model (if one is
        expected or allowed). It is equivalent to calling SetInputData(
        2, model );
        """
        ...
    
    def SetInputModelConnection(self, vtkAlgorithmOutput):
        """
        V.SetInputModelConnection(vtkAlgorithmOutput)
        C++: virtual void SetInputModelConnection(
            vtkAlgorithmOutput *model)
        
        A convenience method for setting the input model connection (if
        one is expected or allowed). It is equivalent to calling
        SetInputConnection( 2, model );
        """
        ...
    
    def SetLearnOption(self, bool):
        """
        V.SetLearnOption(bool)
        C++: virtual void SetLearnOption(bool _arg)
        
        Set/Get the Learn operation.
        """
        ...
    
    def SetLearnOptionParameterConnection(self, vtkAlgorithmOutput):
        """
        V.SetLearnOptionParameterConnection(vtkAlgorithmOutput)
        C++: virtual void SetLearnOptionParameterConnection(
            vtkAlgorithmOutput *params)
        
        A convenience method for setting learn input parameters (if one
        is expected or allowed). It is equivalent to calling
        SetInputConnection( 1, params );
        """
        ...
    
    def SetLearnOptionParameters(self, vtkDataObject):
        """
        V.SetLearnOptionParameters(vtkDataObject)
        C++: virtual void SetLearnOptionParameters(vtkDataObject *params)
        
        A convenience method for setting learn input parameters (if one
        is expected or allowed). It is equivalent to calling
        SetInputData( 1, params );
        """
        ...
    
    def SetNumberOfPrimaryTables(self, p_int):
        """
        V.SetNumberOfPrimaryTables(int)
        C++: virtual void SetNumberOfPrimaryTables(vtkIdType _arg)
        
        Set/Get the number of tables in the primary model.
        """
        ...
    
    def SetParameter(self, string, p_int, vtkVariant):
        """
        V.SetParameter(string, int, vtkVariant) -> bool
        C++: virtual bool SetParameter(const char *parameter, int index,
            vtkVariant value)
        
        A convenience method (in particular for access from other
        applications) to set parameter values of Learn mode. Return true
        if setting of requested parameter name was executed, false
        otherwise. NB: default method (which is sufficient for most
        statistics algorithms) does not have any Learn parameters to set
        and always returns false.
        """
        ...
    
    def SetTestOption(self, bool):
        """
        V.SetTestOption(bool)
        C++: virtual void SetTestOption(bool _arg)
        
        Set/Get the Test operation.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    InputPorts = ...
    INPUT_DATA = ...
    INPUT_MODEL = ...
    LEARN_PARAMETERS = ...
    OutputIndices = ...
    OUTPUT_DATA = ...
    OUTPUT_MODEL = ...
    OUTPUT_TEST = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkAutoCorrelativeStatistics(vtkStatisticsAlgorithm):
    """
    vtkAutoCorrelativeStatistics - A class for univariate
    auto-correlative statistics
    
    Superclass: vtkStatisticsAlgorithm
    
    Given a selection of columns of interest in an input data table, this
    class provides the following functionalities, depending on the chosen
    execution options:
    * Learn: calculate sample mean and M2 aggregates for each variable
      w.r.t. itself (cf. P. Pebay, Formulas for robust, one-pass parallel
    computation of covariances and Arbitrary-Order Statistical Moments,
      Sandia Report SAND2008-6212, Sep 2008,
      http://infoserve.sandia.gov/sand_doc/2008/086212.pdf for details)
      for each specified time lag.
    * Derive: calculate unbiased autocovariance matrix estimators and its
    determinant, linear regressions, and Pearson correlation coefficient,
    for each specified time lag.
    * Assess: given an input data set, two means and a 2x2 covariance
      matrix, mark each datum with corresponding relative deviation
      (2-dimensional Mahlanobis distance).
    
    @par Thanks: This class was written by Philippe Pebay, Kitware SAS
    2012
    """
    def Aggregate(self, vtkDataObjectCollection, vtkMultiBlockDataSet):
        """
        V.Aggregate(vtkDataObjectCollection, vtkMultiBlockDataSet)
        C++: void Aggregate(vtkDataObjectCollection *,
            vtkMultiBlockDataSet *) override;
        
        Given a collection of models, calculate aggregate model
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetSliceCardinality(self):
        """
        V.GetSliceCardinality() -> int
        C++: virtual vtkIdType GetSliceCardinality()
        
        Set/get the cardinality of the data set at given time, i.e., of
        any given time slice. It cannot be negative. The input data set
        is assumed to have a cardinality which is a multiple of this
        value. The default is 0, meaning that the user must specify a
        value that is consistent with the input data set.
        """
        ...
    
    def GetSliceCardinalityMaxValue(self):
        """
        V.GetSliceCardinalityMaxValue() -> int
        C++: virtual vtkIdType GetSliceCardinalityMaxValue()
        
        Set/get the cardinality of the data set at given time, i.e., of
        any given time slice. It cannot be negative. The input data set
        is assumed to have a cardinality which is a multiple of this
        value. The default is 0, meaning that the user must specify a
        value that is consistent with the input data set.
        """
        ...
    
    def GetSliceCardinalityMinValue(self):
        """
        V.GetSliceCardinalityMinValue() -> int
        C++: virtual vtkIdType GetSliceCardinalityMinValue()
        
        Set/get the cardinality of the data set at given time, i.e., of
        any given time slice. It cannot be negative. The input data set
        is assumed to have a cardinality which is a multiple of this
        value. The default is 0, meaning that the user must specify a
        value that is consistent with the input data set.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkAutoCorrelativeStatistics
        C++: vtkAutoCorrelativeStatistics *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkAutoCorrelativeStatistics
        C++: static vtkAutoCorrelativeStatistics *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def SetSliceCardinality(self, p_int):
        """
        V.SetSliceCardinality(int)
        C++: virtual void SetSliceCardinality(vtkIdType _arg)
        
        Set/get the cardinality of the data set at given time, i.e., of
        any given time slice. It cannot be negative. The input data set
        is assumed to have a cardinality which is a multiple of this
        value. The default is 0, meaning that the user must specify a
        value that is consistent with the input data set.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkBivariateLinearTableThreshold(__vtkmodules_vtkCommonExecutionModel.vtkTableAlgorithm):
    """
    vtkBivariateLinearTableThreshold - performs line-based thresholding
    for vtkTable data.
    
    Superclass: vtkTableAlgorithm
    
    Class for filtering the rows of a two numeric columns of a vtkTable. 
    The columns are treated as the two variables of a line.  This filter
    will then iterate through the rows of the table determining if X,Y
    values pairs are above/below/between/near one or more lines.
    
    The "between" mode checks to see if a row is contained within the
    convex hull of all of the specified lines.  The "near" mode checks if
    a row is within a distance threshold two one of the specified lines. 
    This class is used in conjunction with various plotting classes, so
    it is useful to rescale the X,Y axes to a particular range of values.
     Distance comparisons can be performed in the scaled space by setting
    the CustomRanges ivar and enabling UseNormalizedDistance.
    """
    def AddColumnToThreshold(self, p_int, p_int_1):
        """
        V.AddColumnToThreshold(int, int)
        C++: void AddColumnToThreshold(vtkIdType column,
            vtkIdType component)
        
        Add a numeric column to the pair of columns to be thresholded. 
        Call twice.
        """
        ...
    
    def AddLineEquation(self, *float, **kwargs):
        """
        V.AddLineEquation([float, ...], [float, ...])
        C++: void AddLineEquation(double *p1, double *p2)
        V.AddLineEquation([float, ...], float)
        C++: void AddLineEquation(double *p, double slope)
        V.AddLineEquation(float, float, float)
        C++: void AddLineEquation(double a, double b, double c)
        
        Add a line for thresholding from two x,y points.
        """
        ...
    
    def ClearColumnsToThreshold(self):
        """
        V.ClearColumnsToThreshold()
        C++: void ClearColumnsToThreshold()
        
        Reset the columns to be thresholded.
        """
        ...
    
    def ClearLineEquations(self):
        """
        V.ClearLineEquations()
        C++: void ClearLineEquations()
        
        Reset the list of line equations.
        """
        ...
    
    def ComputeImplicitLineFunction(self, *float, **kwargs):
        """
        V.ComputeImplicitLineFunction([float, ...], [float, ...], [float,
            ...])
        C++: static void ComputeImplicitLineFunction(double *p1,
            double *p2, double *abc)
        V.ComputeImplicitLineFunction([float, ...], float, [float, ...])
        C++: static void ComputeImplicitLineFunction(double *p,
            double slope, double *abc)
        
        Convert the two-point line formula to implicit form.
        """
        ...
    
    def GetColumnRanges(self):
        """
        V.GetColumnRanges() -> (float, float)
        C++: virtual double *GetColumnRanges()
        
        Manually access the maximum/minimum x,y values.  This is used in
        conjunction with UseNormalizedDistance when determining if a row
        passes the threshold.
        """
        ...
    
    def GetColumnToThreshold(self, p_int, p_int_1, p_int_2):
        """
        V.GetColumnToThreshold(int, int, int)
        C++: void GetColumnToThreshold(vtkIdType idx, vtkIdType &column,
            vtkIdType &component)
        
        Return the column number from the input table for the idx'th
        added column.
        """
        ...
    
    def GetDistanceThreshold(self):
        """
        V.GetDistanceThreshold() -> float
        C++: virtual double GetDistanceThreshold()
        
        The Cartesian distance within which a point will pass the near
        threshold.
        """
        ...
    
    def GetInclusive(self):
        """
        V.GetInclusive() -> int
        C++: virtual int GetInclusive()
        
        Include the line in the threshold.  Essentially whether the
        threshold operation uses > versus >=.
        """
        ...
    
    def GetLinearThresholdType(self):
        """
        V.GetLinearThresholdType() -> int
        C++: virtual int GetLinearThresholdType()
        
        Set the threshold type.  Above: find all rows that are above the
        specified lines.  Below: find all rows that are below the
        specified lines.  Near: find all rows that are near the specified
        lines.  Between: find all rows that are between the specified
        lines.
        """
        ...
    
    def GetNumberOfColumnsToThreshold(self):
        """
        V.GetNumberOfColumnsToThreshold() -> int
        C++: int GetNumberOfColumnsToThreshold()
        
        Return how many columns have been added.  Hopefully 2.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetSelectedRowIds(self, p_int):
        """
        V.GetSelectedRowIds(int) -> vtkIdTypeArray
        C++: vtkIdTypeArray *GetSelectedRowIds(int selection=0)
        
        Get the output as a table of row ids.
        """
        ...
    
    def GetUseNormalizedDistance(self):
        """
        V.GetUseNormalizedDistance() -> int
        C++: virtual vtkTypeBool GetUseNormalizedDistance()
        
        Renormalize the space of the data such that the X and Y axes are
        "square" over the specified ColumnRanges.  This essentially
        scales the data space so that ColumnRanges[1]-ColumnRanges[0] =
        1.0 and ColumnRanges[3]-ColumnRanges[2] = 1.0.  Used for scatter
        plot distance calculations.  Be sure to set DistanceThreshold
        accordingly, when used.
        """
        ...
    
    def Initialize(self):
        """
        V.Initialize()
        C++: void Initialize()
        
        Reset the columns to threshold, column ranges, etc.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkBivariateLinearTableThreshold
        C++: vtkBivariateLinearTableThreshold *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkBivariateLinearTableThreshold
        C++: static vtkBivariateLinearTableThreshold *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def SetColumnRanges(self, p_float, p_float_1):
        """
        V.SetColumnRanges(float, float)
        C++: virtual void SetColumnRanges(double _arg1, double _arg2)
        V.SetColumnRanges((float, float))
        C++: void SetColumnRanges(const double _arg[2])
        
        Manually access the maximum/minimum x,y values.  This is used in
        conjunction with UseNormalizedDistance when determining if a row
        passes the threshold.
        """
        ...
    
    def SetDistanceThreshold(self, p_float):
        """
        V.SetDistanceThreshold(float)
        C++: virtual void SetDistanceThreshold(double _arg)
        
        The Cartesian distance within which a point will pass the near
        threshold.
        """
        ...
    
    def SetInclusive(self, p_int):
        """
        V.SetInclusive(int)
        C++: virtual void SetInclusive(int _arg)
        
        Include the line in the threshold.  Essentially whether the
        threshold operation uses > versus >=.
        """
        ...
    
    def SetLinearThresholdType(self, p_int):
        """
        V.SetLinearThresholdType(int)
        C++: virtual void SetLinearThresholdType(int _arg)
        
        Set the threshold type.  Above: find all rows that are above the
        specified lines.  Below: find all rows that are below the
        specified lines.  Near: find all rows that are near the specified
        lines.  Between: find all rows that are between the specified
        lines.
        """
        ...
    
    def SetLinearThresholdTypeToAbove(self):
        """
        V.SetLinearThresholdTypeToAbove()
        C++: void SetLinearThresholdTypeToAbove()
        
        Set the threshold type.  Above: find all rows that are above the
        specified lines.  Below: find all rows that are below the
        specified lines.  Near: find all rows that are near the specified
        lines.  Between: find all rows that are between the specified
        lines.
        """
        ...
    
    def SetLinearThresholdTypeToBelow(self):
        """
        V.SetLinearThresholdTypeToBelow()
        C++: void SetLinearThresholdTypeToBelow()
        
        Set the threshold type.  Above: find all rows that are above the
        specified lines.  Below: find all rows that are below the
        specified lines.  Near: find all rows that are near the specified
        lines.  Between: find all rows that are between the specified
        lines.
        """
        ...
    
    def SetLinearThresholdTypeToBetween(self):
        """
        V.SetLinearThresholdTypeToBetween()
        C++: void SetLinearThresholdTypeToBetween()
        
        Set the threshold type.  Above: find all rows that are above the
        specified lines.  Below: find all rows that are below the
        specified lines.  Near: find all rows that are near the specified
        lines.  Between: find all rows that are between the specified
        lines.
        """
        ...
    
    def SetLinearThresholdTypeToNear(self):
        """
        V.SetLinearThresholdTypeToNear()
        C++: void SetLinearThresholdTypeToNear()
        
        Set the threshold type.  Above: find all rows that are above the
        specified lines.  Below: find all rows that are below the
        specified lines.  Near: find all rows that are near the specified
        lines.  Between: find all rows that are between the specified
        lines.
        """
        ...
    
    def SetUseNormalizedDistance(self, p_int):
        """
        V.SetUseNormalizedDistance(int)
        C++: virtual void SetUseNormalizedDistance(vtkTypeBool _arg)
        
        Renormalize the space of the data such that the X and Y axes are
        "square" over the specified ColumnRanges.  This essentially
        scales the data space so that ColumnRanges[1]-ColumnRanges[0] =
        1.0 and ColumnRanges[3]-ColumnRanges[2] = 1.0.  Used for scatter
        plot distance calculations.  Be sure to set DistanceThreshold
        accordingly, when used.
        """
        ...
    
    def UseNormalizedDistanceOff(self):
        """
        V.UseNormalizedDistanceOff()
        C++: virtual void UseNormalizedDistanceOff()
        
        Renormalize the space of the data such that the X and Y axes are
        "square" over the specified ColumnRanges.  This essentially
        scales the data space so that ColumnRanges[1]-ColumnRanges[0] =
        1.0 and ColumnRanges[3]-ColumnRanges[2] = 1.0.  Used for scatter
        plot distance calculations.  Be sure to set DistanceThreshold
        accordingly, when used.
        """
        ...
    
    def UseNormalizedDistanceOn(self):
        """
        V.UseNormalizedDistanceOn()
        C++: virtual void UseNormalizedDistanceOn()
        
        Renormalize the space of the data such that the X and Y axes are
        "square" over the specified ColumnRanges.  This essentially
        scales the data space so that ColumnRanges[1]-ColumnRanges[0] =
        1.0 and ColumnRanges[3]-ColumnRanges[2] = 1.0.  Used for scatter
        plot distance calculations.  Be sure to set DistanceThreshold
        accordingly, when used.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    BLT_ABOVE = ...
    BLT_BELOW = ...
    BLT_BETWEEN = ...
    BLT_NEAR = ...
    LinearThresholdType = ...
    OutputPorts = ...
    OUTPUT_ROW_DATA = ...
    OUTPUT_ROW_IDS = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkComputeQuartiles(__vtkmodules_vtkCommonExecutionModel.vtkTableAlgorithm):
    """
    vtkComputeQuartiles - Extract quartiles and extremum values of all
    columns of a table or all fields of a dataset.
    
    Superclass: vtkTableAlgorithm
    
    vtkComputeQuartiles accepts any vtkDataObject as input and produces a
    vtkTable data as output. This filter can be used to generate a table
    to create box plots using a vtkPlotBox instance. The filter
    internally uses vtkOrderStatistics to compute quartiles.
    
    @sa
    vtkTableAlgorithm vtkOrderStatistics vtkPlotBox vtkChartBox
    
    @par Thanks: This class was written by Kitware SAS and supported by
    EDF - www.edf.fr
    """
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkComputeQuartiles
        C++: vtkComputeQuartiles *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkComputeQuartiles
        C++: static vtkComputeQuartiles *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkContingencyStatistics(vtkStatisticsAlgorithm):
    """
    vtkContingencyStatistics - A class for bivariate correlation
    contigency tables, conditional probabilities, and information entropy
    
    Superclass: vtkStatisticsAlgorithm
    
    Given a pair of columns of interest, this class provides the
    following functionalities, depending on the operation in which it is
    executed:
    * Learn: calculate contigency tables and corresponding discrete joint
      probability distribution.
    * Derive: calculate conditional probabilities, information entropies,
    and pointwise mutual information.
    * Assess: given two columns of interest with the same number of
      entries as input in port INPUT_DATA, and a corresponding bivariate
      probability distribution,
    * Test: calculate Chi-square independence statistic and, if VTK to R
      interface is available, retrieve corresponding p-value for
      independence testing.
    
    @par Thanks: Thanks to Philippe Pebay and David Thompson from Sandia
    National Laboratories for implementing this class. Updated by
    Philippe Pebay, Kitware SAS 2012
    """
    def Aggregate(self, vtkDataObjectCollection, vtkMultiBlockDataSet):
        """
        V.Aggregate(vtkDataObjectCollection, vtkMultiBlockDataSet)
        C++: void Aggregate(vtkDataObjectCollection *,
            vtkMultiBlockDataSet *) override;
        
        Given a collection of models, calculate aggregate model NB: not
        implemented
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkContingencyStatistics
        C++: vtkContingencyStatistics *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkContingencyStatistics
        C++: static vtkContingencyStatistics *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkCorrelativeStatistics(vtkStatisticsAlgorithm):
    """
    vtkCorrelativeStatistics - A class for bivariate linear correlation
    
    Superclass: vtkStatisticsAlgorithm
    
    Given a selection of pairs of columns of interest, this class
    provides the following functionalities, depending on the chosen
    execution options:
    * Learn: calculate sample mean and M2 aggregates for each pair of
      variables (cf. P. Pebay, Formulas for robust, one-pass parallel
      computation of covariances and Arbitrary-Order Statistical Moments,
    Sandia Report SAND2008-6212, Sep 2008,
      http://infoserve.sandia.gov/sand_doc/2008/086212.pdf for details)
    * Derive: calculate unbiased covariance matrix estimators and its
      determinant, linear regressions, and Pearson correlation
      coefficient.
    * Assess: given an input data set, two means and a 2x2 covariance
      matrix, mark each datum with corresponding relative deviation
      (2-dimensional Mahlanobis distance).
    * Test: Perform Jarque-Bera-Srivastava test of 2-d normality
    
    @par Thanks: Thanks to Philippe Pebay and David Thompson from Sandia
    National Laboratories for implementing this class. Updated by
    Philippe Pebay, Kitware SAS 2012
    """
    def Aggregate(self, vtkDataObjectCollection, vtkMultiBlockDataSet):
        """
        V.Aggregate(vtkDataObjectCollection, vtkMultiBlockDataSet)
        C++: void Aggregate(vtkDataObjectCollection *,
            vtkMultiBlockDataSet *) override;
        
        Given a collection of models, calculate aggregate model
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkCorrelativeStatistics
        C++: vtkCorrelativeStatistics *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkCorrelativeStatistics
        C++: static vtkCorrelativeStatistics *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkDescriptiveStatistics(vtkStatisticsAlgorithm):
    """
    vtkDescriptiveStatistics - A class for univariate descriptive
    statistics
    
    Superclass: vtkStatisticsAlgorithm
    
    Given a selection of columns of interest in an input data table, this
    class provides the following functionalities, depending on the chosen
    execution options:
    * Learn: calculate extremal values, sample mean, and M2, M3, and M4
      aggregates (cf. P. Pebay, Formulas for robust, one-pass parallel
      computation of covariances and Arbitrary-Order Statistical Moments,
    Sandia Report SAND2008-6212, Sep 2008,
      http://infoserve.sandia.gov/sand_doc/2008/086212.pdf for details)
    * Derive: calculate unbiased variance estimator, standard deviation
      estimator, two skewness estimators, and two kurtosis excess
      estimators.
    * Assess: given an input data set, a reference value and a
      non-negative deviation, mark each datum with corresponding relative
    deviation (1-dimensional Mahlanobis distance). If the deviation is
      zero, then mark each datum which are equal to the reference value
      with 0, and all others with 1. By default, the reference value and
      the deviation are, respectively, the mean and the standard
      deviation of the input model.
    * Test: calculate Jarque-Bera statistic and, if VTK to R interface is
    available, retrieve corresponding p-value for normality testing.
    
    @par Thanks: Thanks to Philippe Pebay and David Thompson from Sandia
    National Laboratories for implementing this class. Updated by
    Philippe Pebay, Kitware SAS 2012
    """
    def Aggregate(self, vtkDataObjectCollection, vtkMultiBlockDataSet):
        """
        V.Aggregate(vtkDataObjectCollection, vtkMultiBlockDataSet)
        C++: void Aggregate(vtkDataObjectCollection *,
            vtkMultiBlockDataSet *) override;
        
        Given a collection of models, calculate aggregate model
        """
        ...
    
    def G1SkewnessOff(self):
        """
        V.G1SkewnessOff()
        C++: virtual void G1SkewnessOff()
        
        Set/get whether the G1 estimator for the skewness should be used,
        or if the g1 skewness will be calculated. The default is that the
        g1 skewness estimator will be used.
        """
        ...
    
    def G1SkewnessOn(self):
        """
        V.G1SkewnessOn()
        C++: virtual void G1SkewnessOn()
        
        Set/get whether the G1 estimator for the skewness should be used,
        or if the g1 skewness will be calculated. The default is that the
        g1 skewness estimator will be used.
        """
        ...
    
    def G2KurtosisOff(self):
        """
        V.G2KurtosisOff()
        C++: virtual void G2KurtosisOff()
        
        Set/get whether the G2 estimator for the kurtosis should be used,
        or if the g2 kurtosis will be calculated. The default is that the
        g2 kurtosis estimator will be used.
        """
        ...
    
    def G2KurtosisOn(self):
        """
        V.G2KurtosisOn()
        C++: virtual void G2KurtosisOn()
        
        Set/get whether the G2 estimator for the kurtosis should be used,
        or if the g2 kurtosis will be calculated. The default is that the
        g2 kurtosis estimator will be used.
        """
        ...
    
    def GetG1Skewness(self):
        """
        V.GetG1Skewness() -> int
        C++: virtual vtkTypeBool GetG1Skewness()
        
        Set/get whether the G1 estimator for the skewness should be used,
        or if the g1 skewness will be calculated. The default is that the
        g1 skewness estimator will be used.
        """
        ...
    
    def GetG2Kurtosis(self):
        """
        V.GetG2Kurtosis() -> int
        C++: virtual vtkTypeBool GetG2Kurtosis()
        
        Set/get whether the G2 estimator for the kurtosis should be used,
        or if the g2 kurtosis will be calculated. The default is that the
        g2 kurtosis estimator will be used.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetSignedDeviations(self):
        """
        V.GetSignedDeviations() -> int
        C++: virtual vtkTypeBool GetSignedDeviations()
        
        Set/get whether the deviations returned should be signed, or
        should only have their magnitude reported. The default is that
        signed deviations will be computed.
        """
        ...
    
    def GetUnbiasedVariance(self):
        """
        V.GetUnbiasedVariance() -> int
        C++: virtual vtkTypeBool GetUnbiasedVariance()
        
        Set/get whether the unbiased estimator for the variance should be
        used, or if the population variance will be calculated. The
        default is that the unbiased estimator will be used.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkDescriptiveStatistics
        C++: vtkDescriptiveStatistics *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkDescriptiveStatistics
        C++: static vtkDescriptiveStatistics *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def SetG1Skewness(self, p_int):
        """
        V.SetG1Skewness(int)
        C++: virtual void SetG1Skewness(vtkTypeBool _arg)
        
        Set/get whether the G1 estimator for the skewness should be used,
        or if the g1 skewness will be calculated. The default is that the
        g1 skewness estimator will be used.
        """
        ...
    
    def SetG2Kurtosis(self, p_int):
        """
        V.SetG2Kurtosis(int)
        C++: virtual void SetG2Kurtosis(vtkTypeBool _arg)
        
        Set/get whether the G2 estimator for the kurtosis should be used,
        or if the g2 kurtosis will be calculated. The default is that the
        g2 kurtosis estimator will be used.
        """
        ...
    
    def SetSignedDeviations(self, p_int):
        """
        V.SetSignedDeviations(int)
        C++: virtual void SetSignedDeviations(vtkTypeBool _arg)
        
        Set/get whether the deviations returned should be signed, or
        should only have their magnitude reported. The default is that
        signed deviations will be computed.
        """
        ...
    
    def SetUnbiasedVariance(self, p_int):
        """
        V.SetUnbiasedVariance(int)
        C++: virtual void SetUnbiasedVariance(vtkTypeBool _arg)
        
        Set/get whether the unbiased estimator for the variance should be
        used, or if the population variance will be calculated. The
        default is that the unbiased estimator will be used.
        """
        ...
    
    def SignedDeviationsOff(self):
        """
        V.SignedDeviationsOff()
        C++: virtual void SignedDeviationsOff()
        
        Set/get whether the deviations returned should be signed, or
        should only have their magnitude reported. The default is that
        signed deviations will be computed.
        """
        ...
    
    def SignedDeviationsOn(self):
        """
        V.SignedDeviationsOn()
        C++: virtual void SignedDeviationsOn()
        
        Set/get whether the deviations returned should be signed, or
        should only have their magnitude reported. The default is that
        signed deviations will be computed.
        """
        ...
    
    def UnbiasedVarianceOff(self):
        """
        V.UnbiasedVarianceOff()
        C++: virtual void UnbiasedVarianceOff()
        
        Set/get whether the unbiased estimator for the variance should be
        used, or if the population variance will be calculated. The
        default is that the unbiased estimator will be used.
        """
        ...
    
    def UnbiasedVarianceOn(self):
        """
        V.UnbiasedVarianceOn()
        C++: virtual void UnbiasedVarianceOn()
        
        Set/get whether the unbiased estimator for the variance should be
        used, or if the population variance will be calculated. The
        default is that the unbiased estimator will be used.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkExtractFunctionalBagPlot(__vtkmodules_vtkCommonExecutionModel.vtkTableAlgorithm):
    """
    vtkExtractFunctionalBagPlot - From an input table containing series
    on port 0 and another table describing densities on port 1 (for
    instance obtained by applying filter 
    vtkHighestDensityRegionsStatistics, this filter generates a table
    containing all t
    
    Superclass: vtkTableAlgorithm
    
    he columns of the input port 0 plus two 2 components columns
    containing the bag series to be used by vtkFunctionalBagPlot.
    
    @sa
    vtkFunctionalBagPlot vtkHighestDensityRegionsStatistics
    """
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkExtractFunctionalBagPlot
        C++: vtkExtractFunctionalBagPlot *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkExtractFunctionalBagPlot
        C++: static vtkExtractFunctionalBagPlot *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def SetDensityForP50(self, p_float):
        """
        V.SetDensityForP50(float)
        C++: virtual void SetDensityForP50(double _arg)
        """
        ...
    
    def SetDensityForPUser(self, p_float):
        """
        V.SetDensityForPUser(float)
        C++: virtual void SetDensityForPUser(double _arg)
        
        Density value for the user defined quartile.
        """
        ...
    
    def SetPUser(self, p_int):
        """
        V.SetPUser(int)
        C++: virtual void SetPUser(int _arg)
        
        Density value for the user defined quartile.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkHighestDensityRegionsStatistics(vtkStatisticsAlgorithm):
    """
    vtkHighestDensityRegionsStatistics - Compute a random vector of
    density f from input observations points.
    
    Superclass: vtkStatisticsAlgorithm
    
    f is computed using a smooth kernel method.
    
    Given a selection of pairs of columns of interest, this class
    provides the following functionalities, depending on the chosen
    execution options:
    * Learn: calculates density estimator f of a random vector using a
      smooth gaussian kernel. The output metadata on port OUTPUT_MODEL is
    a multiblock dataset containing at one vtkTable holding three columns
    which are for the first columns the input columns of interest and for
    the last columns the density estimators of each input pair of columns
    of interest.
    * Derive: calculate normalized (as a percentage) quantiles coming
      from Learn output. The second block of the multibloc dataset
      contains a vtkTable holding some pairs of columns which are for the
    second one the quantiles ordered from the stronger to the lower and
      for the first one the correspondand quantile index.
    * Assess: not implemented.
    * Test: not implemented.
    """
    def Aggregate(self, vtkDataObjectCollection, vtkMultiBlockDataSet):
        """
        V.Aggregate(vtkDataObjectCollection, vtkMultiBlockDataSet)
        C++: void Aggregate(vtkDataObjectCollection *,
            vtkMultiBlockDataSet *) override;
        
        Given a collection of models, calculate aggregate model
        """
        ...
    
    def ComputeHDR(self, vtkDataArray, vtkDataArray_1):
        """
        V.ComputeHDR(vtkDataArray, vtkDataArray) -> float
        C++: double ComputeHDR(vtkDataArray *inObservations,
            vtkDataArray *outDensity)
        V.ComputeHDR(vtkDataArray, vtkDataArray, vtkDataArray) -> float
        C++: double ComputeHDR(vtkDataArray *inObs, vtkDataArray *inPOI,
            vtkDataArray *outDensity)
        
        Fill outDensity with density vector that is computed from
        inObservations values. This method uses a Gaussian kernel. For n
        observations and with X an observation point: f(X) = (1 / n) *
        Sum(KH(X -Xi)) for (i = 1 to n). Look ComputeSmoothGaussianKernel
        for KH kernel definition.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkHighestDensityRegionsStatistics
        C++: vtkHighestDensityRegionsStatistics *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase)
            -> vtkHighestDensityRegionsStatistics
        C++: static vtkHighestDensityRegionsStatistics *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def SetSigma(self, p_float):
        """
        V.SetSigma(float)
        C++: void SetSigma(double sigma)
        
        Set the width of the gaussian kernel.
        """
        ...
    
    def SetSigmaMatrix(self, p_float, p_float_1, p_float_2, p_float_3):
        """
        V.SetSigmaMatrix(float, float, float, float)
        C++: void SetSigmaMatrix(double s11, double s12, double s21,
            double s22)
        
        Set the gaussian kernel matrix.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkKMeansDistanceFunctor(__vtkmodules_vtkCommonCore.vtkObject):
    """
    vtkKMeansDistanceFunctor - measure distance from k-means cluster
    centers
    
    Superclass: vtkObject
    
    This is an abstract class (with a default concrete subclass) that
    implements algorithms used by the vtkKMeansStatistics filter that
    rely on a distance metric. If you wish to use a non-Euclidean
    distance metric (this could include working with strings that do not
    have a Euclidean distance metric, implementing k-mediods, or trying
    distance metrics in norms other than L2), you should subclass
    vtkKMeansDistanceFunctor.
    """
    def AllocateElementArray(self, p_int):
        """
        V.AllocateElementArray(int) -> void
        C++: virtual void *AllocateElementArray(vtkIdType size)
        
        Allocate an array large enough to hold size coordinates and
        return a void pointer to this array. This is used by
        vtkPKMeansStatistics to send (receive) cluster center coordinates
        to (from) other processes.
        """
        ...
    
    def CreateCoordinateArray(self):
        """
        V.CreateCoordinateArray() -> vtkAbstractArray
        C++: virtual vtkAbstractArray *CreateCoordinateArray()
        
        Return a vtkAbstractArray capable of holding cluster center
        coordinates. This is used by vtkPKMeansStatistics to hold cluster
        center coordinates sent to (received from) other processes.
        """
        ...
    
    def DeallocateElementArray(self, void):
        """
        V.DeallocateElementArray(void)
        C++: virtual void DeallocateElementArray(void *)
        
        Free an array allocated with AllocateElementArray.
        """
        ...
    
    def GetDataType(self):
        """
        V.GetDataType() -> int
        C++: virtual int GetDataType()
        
        Return the data type used to store cluster center coordinates.
        """
        ...
    
    def GetEmptyTuple(self, p_int):
        """
        V.GetEmptyTuple(int) -> vtkVariantArray
        C++: virtual vtkVariantArray *GetEmptyTuple(vtkIdType dimension)
        
        Return an empty tuple. These values are used as cluster center
        coordinates when no initial cluster centers are specified.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkKMeansDistanceFunctor
        C++: vtkKMeansDistanceFunctor *NewInstance()
        """
        ...
    
    def PackElements(self, vtkTable, void):
        """
        V.PackElements(vtkTable, void)
        C++: virtual void PackElements(vtkTable *curTable,
            void *vElements)
        
        Pack the cluster center coordinates in vElements into columns of
        curTable. This code may assume that the columns in curTable are
        all of the type returned by \a GetNewVTKArray().
        """
        ...
    
    def PairwiseUpdate(self, vtkTable, p_int, vtkVariantArray, p_int_1, p_int_2):
        """
        V.PairwiseUpdate(vtkTable, int, vtkVariantArray, int, int)
        C++: virtual void PairwiseUpdate(vtkTable *clusterCenters,
            vtkIdType row, vtkVariantArray *data,
            vtkIdType dataCardinality, vtkIdType totalCardinality)
        
        This is called once per observation per run per iteration in
        order to assign the observation to its nearest cluster center
        after the distance functor has been evaluated for all the cluster
        centers.
        
        * The distance functor is responsible for incrementally updating
          the cluster centers
        * to account for the assignment.
        """
        ...
    
    def PerturbElement(self, vtkTable, vtkTable_1, p_int, p_int_1, p_int_2, p_float):
        """
        V.PerturbElement(vtkTable, vtkTable, int, int, int, float)
        C++: virtual void PerturbElement(vtkTable *, vtkTable *,
            vtkIdType, vtkIdType, vtkIdType, double)
        
        When a cluster center (1) has no observations that are closer to
        it than other cluster centers or (2) has exactly the same
        coordinates as another cluster center, its coordinates should be
        perturbed. This function should perform that perturbation.
        
        * Since perturbation relies on a distance metric, this function
          is the responsibility of the
        * distance functor.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkKMeansDistanceFunctor
        C++: static vtkKMeansDistanceFunctor *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def UnPackElements(self, vtkTable, vtkTable_1, void, void_1, p_int):
        """
        V.UnPackElements(vtkTable, vtkTable, void, void, int)
        C++: virtual void UnPackElements(vtkTable *curTable,
            vtkTable *newTable, void *vLocalElements,
            void *vGlobalElements, int np)
        V.UnPackElements(vtkTable, void, int, int)
        C++: virtual void UnPackElements(vtkTable *curTable,
            void *vLocalElements, vtkIdType numRows, vtkIdType numCols)
        
        Unpack the cluster center coordinates in vElements into columns
        of curTable. This code may assume that the columns in curTable
        are all of the type returned by \a GetNewVTKArray().
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkKMeansDistanceFunctorCalculator(vtkKMeansDistanceFunctor):
    """
    vtkKMeansDistanceFunctorCalculator - measure distance from k-means
    cluster centers using a user-specified expression
    
    Superclass: vtkKMeansDistanceFunctor
    
    This is a subclass of the default k-means distance functor that
    allows the user to specify a distance function as a string. The
    provided expression is evaluated whenever the parenthesis operator is
    invoked but this is much slower than the default distance
    calculation.
    
    User-specified distance expressions should be written in terms of two
    vector variables named "x" and "y". The length of the vectors will be
    determined by the k-means request and all columns of interest in the
    request must contain values that may be converted to a floating point
    representation. (Strings and vtkObject pointers are not allowed.) An
    example distance expression is "sqrt( (x0-y0)^2 + (x1-y1)^2 )" which
    computes Euclidian distance in a plane defined by the first 2
    coordinates of the vectors specified.
    """
    def GetDistanceExpression(self):
        """
        V.GetDistanceExpression() -> string
        C++: virtual char *GetDistanceExpression()
        
        Set/get the distance function expression.
        """
        ...
    
    def GetFunctionParser(self):
        """
        V.GetFunctionParser() -> vtkFunctionParser
        C++: virtual vtkFunctionParser *GetFunctionParser()
        
        Set/get the string containing an expression which evaluates to
        the distance metric used for k-means computation. The scalar
        variables "x0", "x1", ... "xn" and "y0", "y1", ..., "yn" refer to
        the coordinates involved in the computation.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkKMeansDistanceFunctorCalculator
        C++: vtkKMeansDistanceFunctorCalculator *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase)
            -> vtkKMeansDistanceFunctorCalculator
        C++: static vtkKMeansDistanceFunctorCalculator *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def SetDistanceExpression(self, string):
        """
        V.SetDistanceExpression(string)
        C++: virtual void SetDistanceExpression(const char *_arg)
        
        Set/get the distance function expression.
        """
        ...
    
    def SetFunctionParser(self, vtkFunctionParser):
        """
        V.SetFunctionParser(vtkFunctionParser)
        C++: virtual void SetFunctionParser(vtkFunctionParser *)
        
        Set/get the string containing an expression which evaluates to
        the distance metric used for k-means computation. The scalar
        variables "x0", "x1", ... "xn" and "y0", "y1", ..., "yn" refer to
        the coordinates involved in the computation.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkKMeansStatistics(vtkStatisticsAlgorithm):
    """
    vtkKMeansStatistics - A class for KMeans clustering
    
    Superclass: vtkStatisticsAlgorithm
    
    This class takes as input an optional vtkTable on port
    LEARN_PARAMETERS specifying initial  set(s) of cluster values of the
    following form:
    
    
              K     | Col1            |  ...    | ColN
    -----------+-----------------+---------+--------------- M    
        |clustCoord(1, 1) |  ...    | clustCoord(1, N) M    
        |clustCoord(2, 1) |  ...    | clustCoord(2, N) .     |       .   
         |   .     |        . .     |       .         |   .     |       
        . .     |       .         |   .     |        . M    
        |clustCoord(M, 1) |  ...    | clustCoord(M, N) L    
        |clustCoord(1, 1) |  ...    | clustCoord(1, N) L    
        |clustCoord(2, 1) |  ...    | clustCoord(2, N) .     |       .   
         |   .     |        . .     |       .         |   .     |       
        . .     |       .         |   .     |        . L    
        |clustCoord(L, 1) |  ...    | clustCoord(L, N) 
    
    Because the desired value of K is often not known in advance and the
    results of the algorithm are dependent on the initial cluster
    centers, we provide a mechanism for the user to test multiple runs or
    sets of cluster centers within a single call to the Learn phase.  The
    first column of the table identifies the number of clusters K in the
    particular run (the entries in this column should be of type
    vtkIdType), while the remaining columns are a subset of the columns
    contained in the table on port INPUT_DATA.  We require that all user
    specified clusters be of the same dimension N and consequently, that
    the LEARN_PARAMETERS table have N+1 columns. Due to this restriction,
    only one request can be processed for each call to the Learn phase
    and subsequent requests are silently ignored. Note that, if the first
    column of the LEARN_PARAMETERS table is not of type vtkIdType, then
    the table will be ignored and a single run will be performed using
    the first DefaultNumberOfClusters input data observations as initial
    cluster centers.
    
    When the user does not supply an initial set of clusters, then the
    first DefaultNumberOfClusters input data observations are used as
    initial cluster centers and a single run is performed.
    
    This class provides the following functionalities, depending on the
    operation in which it is executed:
    * Learn: calculates new cluster centers for each run.  The output
      metadata on port OUTPUT_MODEL is a multiblock dataset containing at
    a minimum one vtkTable with columns specifying the following for each
    run: the run ID, number of clusters, number of iterations required
      for convergence, total error associated with the cluster (sum of
      squared Euclidean distance from each observation to its nearest
      cluster center), the cardinality of the cluster, and the new
      cluster coordinates.
    
    * Derive:  An additional vtkTable is stored in the multiblock dataset
    output on port OUTPUT_MODEL. This table contains columns that store
      for each run: the runID, number of clusters, total error for all
      clusters in the run, local rank, and global rank. The local rank is
    computed by comparing squared Euclidean errors of all runs with the
      same number of clusters.  The global rank is computed analagously
      across all runs.
    
    * Assess: This requires a multiblock dataset (as computed from Learn
      and Derive) on input port INPUT_MODEL and tabular data on input
      port INPUT_DATA that contains column names matching those of the
      tables on input port INPUT_MODEL. The assess mode reports the
      closest cluster center and associated squared Euclidean distance of
    each observation in port INPUT_DATA's table to the cluster centers
      for each run in the multiblock dataset provided on port
      INPUT_MODEL.
    
    The code can handle a wide variety of data types as it operates on
    vtkAbstractArrays and is not limited to vtkDataArrays.  A default
    distance functor that computes the sum of the squares of the
    Euclidean distance between two objects is provided
    (vtkKMeansDistanceFunctor). The default distance functor can be
    overridden to use alternative distance metrics.
    
    @par Thanks: Thanks to Janine Bennett, David Thompson, and Philippe
    Pebay of Sandia National Laboratories for implementing this class.
    Updated by Philippe Pebay, Kitware SAS 2012
    """
    def Aggregate(self, vtkDataObjectCollection, vtkMultiBlockDataSet):
        """
        V.Aggregate(vtkDataObjectCollection, vtkMultiBlockDataSet)
        C++: void Aggregate(vtkDataObjectCollection *,
            vtkMultiBlockDataSet *) override;
        
        Given a collection of models, calculate aggregate model NB: not
        implemented
        """
        ...
    
    def GetDefaultNumberOfClusters(self):
        """
        V.GetDefaultNumberOfClusters() -> int
        C++: virtual int GetDefaultNumberOfClusters()
        
        Set/get the DefaultNumberOfClusters, used when no initial cluster
        coordinates are specified.
        """
        ...
    
    def GetDistanceFunctor(self):
        """
        V.GetDistanceFunctor() -> vtkKMeansDistanceFunctor
        C++: virtual vtkKMeansDistanceFunctor *GetDistanceFunctor()
        
        Set the DistanceFunctor.
        """
        ...
    
    def GetKValuesArrayName(self):
        """
        V.GetKValuesArrayName() -> string
        C++: virtual char *GetKValuesArrayName()
        
        Set/get the KValuesArrayName.
        """
        ...
    
    def GetMaxNumIterations(self):
        """
        V.GetMaxNumIterations() -> int
        C++: virtual int GetMaxNumIterations()
        
        Set/get the MaxNumIterations used to terminate iterations on
        cluster center coordinates when the relative tolerance can not be
        met.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetTolerance(self):
        """
        V.GetTolerance() -> float
        C++: virtual double GetTolerance()
        
        Set/get the relative Tolerance used to terminate iterations on
        cluster center coordinates.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkKMeansStatistics
        C++: vtkKMeansStatistics *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkKMeansStatistics
        C++: static vtkKMeansStatistics *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetDefaultNumberOfClusters(self, p_int):
        """
        V.SetDefaultNumberOfClusters(int)
        C++: virtual void SetDefaultNumberOfClusters(int _arg)
        
        Set/get the DefaultNumberOfClusters, used when no initial cluster
        coordinates are specified.
        """
        ...
    
    def SetDistanceFunctor(self, vtkKMeansDistanceFunctor):
        """
        V.SetDistanceFunctor(vtkKMeansDistanceFunctor)
        C++: virtual void SetDistanceFunctor(vtkKMeansDistanceFunctor *)
        
        Set the DistanceFunctor.
        """
        ...
    
    def SetKValuesArrayName(self, string):
        """
        V.SetKValuesArrayName(string)
        C++: virtual void SetKValuesArrayName(const char *_arg)
        
        Set/get the KValuesArrayName.
        """
        ...
    
    def SetMaxNumIterations(self, p_int):
        """
        V.SetMaxNumIterations(int)
        C++: virtual void SetMaxNumIterations(int _arg)
        
        Set/get the MaxNumIterations used to terminate iterations on
        cluster center coordinates when the relative tolerance can not be
        met.
        """
        ...
    
    def SetParameter(self, string, p_int, vtkVariant):
        """
        V.SetParameter(string, int, vtkVariant) -> bool
        C++: bool SetParameter(const char *parameter, int index,
            vtkVariant value) override;
        
        A convenience method for setting properties by name.
        """
        ...
    
    def SetTolerance(self, p_float):
        """
        V.SetTolerance(float)
        C++: virtual void SetTolerance(double _arg)
        
        Set/get the relative Tolerance used to terminate iterations on
        cluster center coordinates.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkMultiCorrelativeStatistics(vtkStatisticsAlgorithm):
    """
    vtkMultiCorrelativeStatistics - A class for multivariate linear
    correlation
    
    Superclass: vtkStatisticsAlgorithm
    
    Given a selection of sets of columns of interest, this class provides
    the following functionalities, depending on the operation in which it
    is executed:
    * Learn: calculates means, unbiased variance and covariance
      estimators of column pairs coefficient. More precisely, Learn
      calculates the averages and centered variance/covariance sums; if
      finalize is set to true (default), the final statistics are
      calculated. The output metadata on port OUTPUT_MODEL is a
      multiblock dataset containing at a minimum one vtkTable holding the
    raw sums in a sparse matrix style. If finalize is true, then one
      additional vtkTable will be present for each requested set of
      column correlations. These additional tables contain column
      averages, the upper triangular portion of the covariance matrix (in
    the upper right hand portion of the table) and the Cholesky
      decomposition of the covariance matrix (in the lower portion of the
    table beneath the covariance triangle). The leftmost column will be a
    vector of column averages. The last entry in the column averages
      vector is the number of samples. As an example, consider a request
      for a 3-column correlation with columns named ColA, ColB, and ColC.
      The resulting table will look like this:
    
    
         Column  |Mean     |ColA     |ColB     |ColC
    --------+---------+---------+---------+--------- ColA    |avg(A)  
        |cov(A,A) |cov(A,B) |cov(A,C) ColB    |avg(B)  
        |chol(1,1)|cov(B,B) |cov(B,C) ColC    |avg(C)  
        |chol(2,1)|chol(2,2)|cov(C,C)
        Cholesky|length(A)|chol(3,1)|chol(3,2)|chol(3,3)  The mean point
        and the covariance matrix can be replaced by the median point and
    the MAD matrix (Median Absolute Deviation) thanks to the
        MedianAbsoluteDeviation boolean. In this mode, the resulting
        table will look like this:
    
    
         Column  |Mean     |ColA     |ColB     |ColC
    --------+---------+---------+---------+--------- ColA    |med(A)  
        |MAD(A,A) |MAD(A,B) |MAD(A,C) ColB    |med(B)  
        |chol(1,1)|MAD(B,B) |MAD(B,C) ColC    |med(C)  
        |chol(2,1)|chol(2,2)|MAD(C,C)
        Cholesky|length(A)|chol(3,1)|chol(3,2)|chol(3,3)  The Median
        Absolute Deviation is known to be more robust than the
        covariance. It is used in the robust PCA computation for
        instance.
    * Assess: given a set of results matrices as specified above in input
    port INPUT_MODEL and tabular data on input port INPUT_DATA that
      contains column names matching those of the tables on input port
      INPUT_MODEL, the assess mode computes the relative deviation of
      each observation in port INPUT_DATA's table according to the linear
      correlations implied by each table in port INPUT_MODEL.
    
    @par Thanks: Thanks to Philippe Pebay, Jackson Mayo, and David
    Thompson of Sandia National Laboratories for implementing this class.
    Updated by Philippe Pebay, Kitware SAS 2012 Updated by Tristan
    Coulange and Joachim Pouderoux, Kitware SAS 2013
    """
    def Aggregate(self, vtkDataObjectCollection, vtkMultiBlockDataSet):
        """
        V.Aggregate(vtkDataObjectCollection, vtkMultiBlockDataSet)
        C++: void Aggregate(vtkDataObjectCollection *,
            vtkMultiBlockDataSet *) override;
        
        Given a collection of models, calculate aggregate model
        """
        ...
    
    def GetMedianAbsoluteDeviation(self):
        """
        V.GetMedianAbsoluteDeviation() -> bool
        C++: virtual bool GetMedianAbsoluteDeviation()
        
        If set to true, the covariance matrix is replaced by the Median
        Absolute Deviation matrix. Default is false.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def MedianAbsoluteDeviationOff(self):
        """
        V.MedianAbsoluteDeviationOff()
        C++: virtual void MedianAbsoluteDeviationOff()
        
        If set to true, the covariance matrix is replaced by the Median
        Absolute Deviation matrix. Default is false.
        """
        ...
    
    def MedianAbsoluteDeviationOn(self):
        """
        V.MedianAbsoluteDeviationOn()
        C++: virtual void MedianAbsoluteDeviationOn()
        
        If set to true, the covariance matrix is replaced by the Median
        Absolute Deviation matrix. Default is false.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkMultiCorrelativeStatistics
        C++: vtkMultiCorrelativeStatistics *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkMultiCorrelativeStatistics
        C++: static vtkMultiCorrelativeStatistics *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def SetMedianAbsoluteDeviation(self, bool):
        """
        V.SetMedianAbsoluteDeviation(bool)
        C++: virtual void SetMedianAbsoluteDeviation(bool _arg)
        
        If set to true, the covariance matrix is replaced by the Median
        Absolute Deviation matrix. Default is false.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkOrderStatistics(vtkStatisticsAlgorithm):
    """
    vtkOrderStatistics - A class for univariate order statistics
    
    Superclass: vtkStatisticsAlgorithm
    
    Given a selection of columns of interest in an input data table, this
    class provides the following functionalities, depending on the
    execution mode it is executed in:
    * Learn: calculate histogram.
    * Derive: calculate PDFs and arbitrary quantiles. Provide specific
      names when 5-point statistics (minimum, 1st quartile, median, third
    quartile, maximum) requested.
    * Assess: given an input data set and a set of q-quantiles, label
      each datum either with the quantile interval to which it belongs,
      or 0 if it is smaller than smaller quantile, or q if it is larger
      than largest quantile.
    * Test: calculate Kolmogorov-Smirnov goodness-of-fit statistic
      between CDF based on model quantiles, and empirical CDF
    
    @par Thanks: Thanks to Philippe Pebay and David Thompson from Sandia
    National Laboratories for implementing this class. Updated by
    Philippe Pebay, Kitware SAS 2012
    """
    def Aggregate(self, vtkDataObjectCollection, vtkMultiBlockDataSet):
        """
        V.Aggregate(vtkDataObjectCollection, vtkMultiBlockDataSet)
        C++: void Aggregate(vtkDataObjectCollection *,
            vtkMultiBlockDataSet *) override;
        
        Given a collection of models, calculate aggregate model NB: not
        implemented
        """
        ...
    
    def GetMaximumHistogramSize(self):
        """
        V.GetMaximumHistogramSize() -> int
        C++: virtual vtkIdType GetMaximumHistogramSize()
        
        Set/Get the maximum histogram size. This maximum size is enforced
        only when Quantize is TRUE.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfIntervals(self):
        """
        V.GetNumberOfIntervals() -> int
        C++: virtual vtkIdType GetNumberOfIntervals()
        
        Set/Get the number of quantiles (with uniform spacing).
        """
        ...
    
    def GetQuantileDefinition(self):
        """
        V.GetQuantileDefinition() -> int
        C++: vtkIdType GetQuantileDefinition()
        
        Get the quantile definition.
        """
        ...
    
    def GetQuantize(self):
        """
        V.GetQuantize() -> bool
        C++: virtual bool GetQuantize()
        
        Set/Get whether quantization will be allowed to enforce maximum
        histogram size.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkOrderStatistics
        C++: vtkOrderStatistics *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkOrderStatistics
        C++: static vtkOrderStatistics *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetMaximumHistogramSize(self, p_int):
        """
        V.SetMaximumHistogramSize(int)
        C++: virtual void SetMaximumHistogramSize(vtkIdType _arg)
        
        Set/Get the maximum histogram size. This maximum size is enforced
        only when Quantize is TRUE.
        """
        ...
    
    def SetNumberOfIntervals(self, p_int):
        """
        V.SetNumberOfIntervals(int)
        C++: virtual void SetNumberOfIntervals(vtkIdType _arg)
        
        Set/Get the number of quantiles (with uniform spacing).
        """
        ...
    
    def SetParameter(self, string, p_int, vtkVariant):
        """
        V.SetParameter(string, int, vtkVariant) -> bool
        C++: bool SetParameter(const char *parameter, int index,
            vtkVariant value) override;
        
        A convenience method (in particular for access from other
        applications) to set parameter values. Return true if setting of
        requested parameter name was executed, false otherwise.
        """
        ...
    
    def SetQuantileDefinition(self, QuantileDefinitionType):
        """
        V.SetQuantileDefinition(QuantileDefinitionType)
        C++: virtual void SetQuantileDefinition(
            QuantileDefinitionType _arg)
        V.SetQuantileDefinition(int)
        C++: void SetQuantileDefinition(int)
        
        Set the quantile definition.
        """
        ...
    
    def SetQuantize(self, bool):
        """
        V.SetQuantize(bool)
        C++: virtual void SetQuantize(bool _arg)
        
        Set/Get whether quantization will be allowed to enforce maximum
        histogram size.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    InverseCDF = ...
    InverseCDFAveragedSteps = ...
    NearestObservation = ...
    QuantileDefinitionType = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkPCAStatistics(vtkMultiCorrelativeStatistics):
    """
    vtkPCAStatistics - A class for multivariate principal component
    analysis
    
    Superclass: vtkMultiCorrelativeStatistics
    
    This class derives from the multi-correlative statistics algorithm
    and uses the covariance matrix and Cholesky decomposition computed by
    it. However, when it finalizes the statistics in learn operation, the
    PCA class computes the SVD of the covariance matrix in order to
    obtain its eigenvectors.
    
    In the assess operation, the input data are
    - projected into the basis defined by the eigenvectors,
    - the energy associated with each datum is computed,
    - or some combination thereof. Additionally, the user may specify
      some threshold energy or eigenvector entry below which the basis is
    truncated. This allows projection into a lower-dimensional state
      while minimizing (in a least squares sense) the projection error.
    
    In the test operation, a Jarque-Bera-Srivastava test of n-d normality
    is performed.
    
    The Robust PCA can be computed by using the median instead of the
    mean, and the MAD matrix (Median Absolute Deviation) instead of the
    covariance matrix. This can be done by activating the
    MedianAbsoluteDeviation boolean (declared in the superclass).
    
    @par Thanks: Thanks to David Thompson, Philippe Pebay and Jackson
    Mayo from Sandia National Laboratories for implementing this class.
    Updated by Philippe Pebay, Kitware SAS 2012 Updated by Tristan
    Coulange and Joachim Pouderoux, Kitware SAS 2013
    """
    def GetBasisScheme(self):
        """
        V.GetBasisScheme() -> int
        C++: virtual int GetBasisScheme()
        
        This variable controls the dimensionality of output tuples in
        Assess operation. Consider the case where you have requested a
        PCA on D columns.
        
        * When set to vtkPCAStatistics::FULL_BASIS, the entire set of
          basis vectors
        * is used to derive new coordinates for each tuple being
          assessed.
        * In this mode, you are guaranteed to have output tuples of the
          same dimension
        * as the input tuples. (That dimension is D, so there will be D
          additional
        * columns added to the table for the request.)
        
        * When set to vtkPCAStatistics::FIXED_BASIS_SIZE, only the first
          N basis vectors
        * are used to derive new coordinates for each tuple being
          assessed.
        * In this mode, you are guaranteed to have output tuples of
          dimension min(N,D).
        * You must set N prior to assessing data using the
          SetFixedBasisSize() method.
        * When N < D, this turns the PCA into a projection (instead of
          change of basis).
        
        * When set to vtkPCAStatistics::FIXED_BASIS_ENERGY, the number of
        basis vectors
        * used to derive new coordinates for each tuple will be the
          minimum number
        * of columns N that satisfy
        * \[
        * \frac{\sum_{i=1}^{N} \lambda_i}{\sum_{i=1}^{D} \lambda_i} < T
        * \]
        * You must set T prior to assessing data using the
          SetFixedBasisEnergy() method.
        * When T < 1, this turns the PCA into a projection (instead of
          change of basis).
        
        * By default BasisScheme is set to vtkPCAStatistics::FULL_BASIS.
        """
        ...
    
    def GetBasisSchemeName(self, p_int):
        """
        V.GetBasisSchemeName(int) -> string
        C++: virtual const char *GetBasisSchemeName(int schemeIndex)
        
        This variable controls the dimensionality of output tuples in
        Assess operation. Consider the case where you have requested a
        PCA on D columns.
        
        * When set to vtkPCAStatistics::FULL_BASIS, the entire set of
          basis vectors
        * is used to derive new coordinates for each tuple being
          assessed.
        * In this mode, you are guaranteed to have output tuples of the
          same dimension
        * as the input tuples. (That dimension is D, so there will be D
          additional
        * columns added to the table for the request.)
        
        * When set to vtkPCAStatistics::FIXED_BASIS_SIZE, only the first
          N basis vectors
        * are used to derive new coordinates for each tuple being
          assessed.
        * In this mode, you are guaranteed to have output tuples of
          dimension min(N,D).
        * You must set N prior to assessing data using the
          SetFixedBasisSize() method.
        * When N < D, this turns the PCA into a projection (instead of
          change of basis).
        
        * When set to vtkPCAStatistics::FIXED_BASIS_ENERGY, the number of
        basis vectors
        * used to derive new coordinates for each tuple will be the
          minimum number
        * of columns N that satisfy
        * \[
        * \frac{\sum_{i=1}^{N} \lambda_i}{\sum_{i=1}^{D} \lambda_i} < T
        * \]
        * You must set T prior to assessing data using the
          SetFixedBasisEnergy() method.
        * When T < 1, this turns the PCA into a projection (instead of
          change of basis).
        
        * By default BasisScheme is set to vtkPCAStatistics::FULL_BASIS.
        """
        ...
    
    def GetEigenvalue(self, p_int, p_int_1):
        """
        V.GetEigenvalue(int, int) -> float
        C++: double GetEigenvalue(int request, int i)
        V.GetEigenvalue(int) -> float
        C++: double GetEigenvalue(int i)
        
        Get the eigenvalues. The eigenvalues are ordered according from
        largest to smallest. This function: void GetEigenvalues(int
        request, int i, vtkDoubleArray*); does all of the work. The other
        functions simply call this function with the appropriate
        parameters. These functions are not valid unless Update() has
        been called and the Derive option is turned on.
        """
        ...
    
    def GetEigenvalues(self, p_int, vtkDoubleArray):
        """
        V.GetEigenvalues(int, vtkDoubleArray)
        C++: void GetEigenvalues(int request, vtkDoubleArray *)
        V.GetEigenvalues(vtkDoubleArray)
        C++: void GetEigenvalues(vtkDoubleArray *)
        
        Get the eigenvalues. The eigenvalues are ordered according from
        largest to smallest. This function: void GetEigenvalues(int
        request, int i, vtkDoubleArray*); does all of the work. The other
        functions simply call this function with the appropriate
        parameters. These functions are not valid unless Update() has
        been called and the Derive option is turned on.
        """
        ...
    
    def GetEigenvector(self, p_int, vtkDoubleArray):
        """
        V.GetEigenvector(int, vtkDoubleArray)
        C++: void GetEigenvector(int i, vtkDoubleArray *eigenvector)
        V.GetEigenvector(int, int, vtkDoubleArray)
        C++: void GetEigenvector(int request, int i,
            vtkDoubleArray *eigenvector)
        
        Get the eigenvectors. The eigenvectors are ordered according to
        the magnitude of their associated eigenvalues, sorted from
        largest to smallest. That is, eigenvector 0 corresponds to the
        largest eigenvalue. This function: void GetEigenvectors(int
        request, vtkDoubleArray* eigenvectors) does all of the work. The
        other functions are convenience functions that call this function
        with default arguments. These functions are not valid unless
        Update() has been called and the Derive option is turned on.
        """
        ...
    
    def GetEigenvectors(self, p_int, vtkDoubleArray):
        """
        V.GetEigenvectors(int, vtkDoubleArray)
        C++: void GetEigenvectors(int request,
            vtkDoubleArray *eigenvectors)
        V.GetEigenvectors(vtkDoubleArray)
        C++: void GetEigenvectors(vtkDoubleArray *eigenvectors)
        
        Get the eigenvectors. The eigenvectors are ordered according to
        the magnitude of their associated eigenvalues, sorted from
        largest to smallest. That is, eigenvector 0 corresponds to the
        largest eigenvalue. This function: void GetEigenvectors(int
        request, vtkDoubleArray* eigenvectors) does all of the work. The
        other functions are convenience functions that call this function
        with default arguments. These functions are not valid unless
        Update() has been called and the Derive option is turned on.
        """
        ...
    
    def GetFixedBasisEnergy(self):
        """
        V.GetFixedBasisEnergy() -> float
        C++: virtual double GetFixedBasisEnergy()
        
        The minimum energy the new basis should use, as a fraction. See
        SetBasisScheme() for more information. When FixedBasisEnergy >= 1
        (the default), the fixed basis energy scheme is equivalent to the
        full basis scheme.
        """
        ...
    
    def GetFixedBasisEnergyMaxValue(self):
        """
        V.GetFixedBasisEnergyMaxValue() -> float
        C++: virtual double GetFixedBasisEnergyMaxValue()
        
        The minimum energy the new basis should use, as a fraction. See
        SetBasisScheme() for more information. When FixedBasisEnergy >= 1
        (the default), the fixed basis energy scheme is equivalent to the
        full basis scheme.
        """
        ...
    
    def GetFixedBasisEnergyMinValue(self):
        """
        V.GetFixedBasisEnergyMinValue() -> float
        C++: virtual double GetFixedBasisEnergyMinValue()
        
        The minimum energy the new basis should use, as a fraction. See
        SetBasisScheme() for more information. When FixedBasisEnergy >= 1
        (the default), the fixed basis energy scheme is equivalent to the
        full basis scheme.
        """
        ...
    
    def GetFixedBasisSize(self):
        """
        V.GetFixedBasisSize() -> int
        C++: virtual int GetFixedBasisSize()
        
        The number of basis vectors to use. See SetBasisScheme() for more
        information. When FixedBasisSize <= 0 (the default), the fixed
        basis size scheme is equivalent to the full basis scheme.
        """
        ...
    
    def GetNormalizationScheme(self):
        """
        V.GetNormalizationScheme() -> int
        C++: virtual int GetNormalizationScheme()
        
        This determines how (or if) the covariance matrix cov is
        normalized before PCA.
        
        * When set to NONE, no normalization is performed. This is the
          default.
        
        * When set to TRIANGLE_SPECIFIED, each entry cov(i,j) is divided
          by V(i,j).
        * The list V of normalization factors must be set using the
          SetNormalization method
        * before the filter is executed.
        
        * When set to DIAGONAL_SPECIFIED, each entry cov(i,j) is divided
          by sqrt(V(i)*V(j)).
        * The list V of normalization factors must be set using the
          SetNormalization method
        * before the filter is executed.
        
        * When set to DIAGONAL_VARIANCE, each entry cov(i,j) is divided
          by sqrt(cov(i,i)*cov(j,j)).
        * Warning: Although this is accepted practice in some fields,
        * some people think you should not turn this option on unless
          there
        * is a good physically-based reason for doing so. Much better
          instead
        * to determine how component magnitudes should be compared using
        * physical reasoning and use DIAGONAL_SPECIFIED,
          TRIANGLE_SPECIFIED, or
        * perform some pre-processing to shift and scale input data
          columns
        * appropriately than to expect magical results from a shady
          normalization hack.
        """
        ...
    
    def GetNormalizationSchemeName(self, p_int):
        """
        V.GetNormalizationSchemeName(int) -> string
        C++: virtual const char *GetNormalizationSchemeName(int scheme)
        
        This determines how (or if) the covariance matrix cov is
        normalized before PCA.
        
        * When set to NONE, no normalization is performed. This is the
          default.
        
        * When set to TRIANGLE_SPECIFIED, each entry cov(i,j) is divided
          by V(i,j).
        * The list V of normalization factors must be set using the
          SetNormalization method
        * before the filter is executed.
        
        * When set to DIAGONAL_SPECIFIED, each entry cov(i,j) is divided
          by sqrt(V(i)*V(j)).
        * The list V of normalization factors must be set using the
          SetNormalization method
        * before the filter is executed.
        
        * When set to DIAGONAL_VARIANCE, each entry cov(i,j) is divided
          by sqrt(cov(i,i)*cov(j,j)).
        * Warning: Although this is accepted practice in some fields,
        * some people think you should not turn this option on unless
          there
        * is a good physically-based reason for doing so. Much better
          instead
        * to determine how component magnitudes should be compared using
        * physical reasoning and use DIAGONAL_SPECIFIED,
          TRIANGLE_SPECIFIED, or
        * perform some pre-processing to shift and scale input data
          columns
        * appropriately than to expect magical results from a shady
          normalization hack.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetSpecifiedNormalization(self):
        """
        V.GetSpecifiedNormalization() -> vtkTable
        C++: virtual vtkTable *GetSpecifiedNormalization()
        
        These methods allow you to set/get values used to normalize the
        covariance matrix before PCA. The normalization values apply to
        all requests, so you do not specify a single vector but a
        3-column table.
        
        * The first two columns contain the names of columns from input 0
        and the third column contains
        * the value to normalize the corresponding entry in the
          covariance matrix.
        * The table must always have 3 columns even when the
          NormalizationScheme is DIAGONAL_SPECIFIED.
        * When only diagonal entries are to be used, only table rows
          where the first two columns are
        * identical to one another will be employed.
        * If there are multiple rows specifying different values for the
          same pair of columns,
        * the entry nearest the bottom of the table takes precedence.
        
        * These functions are actually convenience methods that set/get
          the third input of the filter.
        * Because the table is the third input, you may use other filters
        to produce a table of
        * normalizations and have the pipeline take care of updates.
        
        * Any missing entries will be set to 1.0 and a warning issued.
        * An error will occur if the third input to the filter is not set
        and the
        * NormalizationScheme is DIAGONAL_SPECIFIED or
          TRIANGLE_SPECIFIED.
        
        * NOTE: SetSpecifiedNormalization( table ) is equivalent to
          SetInputData(3, table)
        * and therefore does not make a pipeline connection.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkPCAStatistics
        C++: vtkPCAStatistics *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkPCAStatistics
        C++: static vtkPCAStatistics *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetBasisScheme(self, p_int):
        """
        V.SetBasisScheme(int)
        C++: virtual void SetBasisScheme(int _arg)
        
        This variable controls the dimensionality of output tuples in
        Assess operation. Consider the case where you have requested a
        PCA on D columns.
        
        * When set to vtkPCAStatistics::FULL_BASIS, the entire set of
          basis vectors
        * is used to derive new coordinates for each tuple being
          assessed.
        * In this mode, you are guaranteed to have output tuples of the
          same dimension
        * as the input tuples. (That dimension is D, so there will be D
          additional
        * columns added to the table for the request.)
        
        * When set to vtkPCAStatistics::FIXED_BASIS_SIZE, only the first
          N basis vectors
        * are used to derive new coordinates for each tuple being
          assessed.
        * In this mode, you are guaranteed to have output tuples of
          dimension min(N,D).
        * You must set N prior to assessing data using the
          SetFixedBasisSize() method.
        * When N < D, this turns the PCA into a projection (instead of
          change of basis).
        
        * When set to vtkPCAStatistics::FIXED_BASIS_ENERGY, the number of
        basis vectors
        * used to derive new coordinates for each tuple will be the
          minimum number
        * of columns N that satisfy
        * \[
        * \frac{\sum_{i=1}^{N} \lambda_i}{\sum_{i=1}^{D} \lambda_i} < T
        * \]
        * You must set T prior to assessing data using the
          SetFixedBasisEnergy() method.
        * When T < 1, this turns the PCA into a projection (instead of
          change of basis).
        
        * By default BasisScheme is set to vtkPCAStatistics::FULL_BASIS.
        """
        ...
    
    def SetBasisSchemeByName(self, string):
        """
        V.SetBasisSchemeByName(string)
        C++: virtual void SetBasisSchemeByName(const char *schemeName)
        
        This variable controls the dimensionality of output tuples in
        Assess operation. Consider the case where you have requested a
        PCA on D columns.
        
        * When set to vtkPCAStatistics::FULL_BASIS, the entire set of
          basis vectors
        * is used to derive new coordinates for each tuple being
          assessed.
        * In this mode, you are guaranteed to have output tuples of the
          same dimension
        * as the input tuples. (That dimension is D, so there will be D
          additional
        * columns added to the table for the request.)
        
        * When set to vtkPCAStatistics::FIXED_BASIS_SIZE, only the first
          N basis vectors
        * are used to derive new coordinates for each tuple being
          assessed.
        * In this mode, you are guaranteed to have output tuples of
          dimension min(N,D).
        * You must set N prior to assessing data using the
          SetFixedBasisSize() method.
        * When N < D, this turns the PCA into a projection (instead of
          change of basis).
        
        * When set to vtkPCAStatistics::FIXED_BASIS_ENERGY, the number of
        basis vectors
        * used to derive new coordinates for each tuple will be the
          minimum number
        * of columns N that satisfy
        * \[
        * \frac{\sum_{i=1}^{N} \lambda_i}{\sum_{i=1}^{D} \lambda_i} < T
        * \]
        * You must set T prior to assessing data using the
          SetFixedBasisEnergy() method.
        * When T < 1, this turns the PCA into a projection (instead of
          change of basis).
        
        * By default BasisScheme is set to vtkPCAStatistics::FULL_BASIS.
        """
        ...
    
    def SetFixedBasisEnergy(self, p_float):
        """
        V.SetFixedBasisEnergy(float)
        C++: virtual void SetFixedBasisEnergy(double _arg)
        
        The minimum energy the new basis should use, as a fraction. See
        SetBasisScheme() for more information. When FixedBasisEnergy >= 1
        (the default), the fixed basis energy scheme is equivalent to the
        full basis scheme.
        """
        ...
    
    def SetFixedBasisSize(self, p_int):
        """
        V.SetFixedBasisSize(int)
        C++: virtual void SetFixedBasisSize(int _arg)
        
        The number of basis vectors to use. See SetBasisScheme() for more
        information. When FixedBasisSize <= 0 (the default), the fixed
        basis size scheme is equivalent to the full basis scheme.
        """
        ...
    
    def SetNormalizationScheme(self, p_int):
        """
        V.SetNormalizationScheme(int)
        C++: virtual void SetNormalizationScheme(int _arg)
        
        This determines how (or if) the covariance matrix cov is
        normalized before PCA.
        
        * When set to NONE, no normalization is performed. This is the
          default.
        
        * When set to TRIANGLE_SPECIFIED, each entry cov(i,j) is divided
          by V(i,j).
        * The list V of normalization factors must be set using the
          SetNormalization method
        * before the filter is executed.
        
        * When set to DIAGONAL_SPECIFIED, each entry cov(i,j) is divided
          by sqrt(V(i)*V(j)).
        * The list V of normalization factors must be set using the
          SetNormalization method
        * before the filter is executed.
        
        * When set to DIAGONAL_VARIANCE, each entry cov(i,j) is divided
          by sqrt(cov(i,i)*cov(j,j)).
        * Warning: Although this is accepted practice in some fields,
        * some people think you should not turn this option on unless
          there
        * is a good physically-based reason for doing so. Much better
          instead
        * to determine how component magnitudes should be compared using
        * physical reasoning and use DIAGONAL_SPECIFIED,
          TRIANGLE_SPECIFIED, or
        * perform some pre-processing to shift and scale input data
          columns
        * appropriately than to expect magical results from a shady
          normalization hack.
        """
        ...
    
    def SetNormalizationSchemeByName(self, string):
        """
        V.SetNormalizationSchemeByName(string)
        C++: virtual void SetNormalizationSchemeByName(const char *sname)
        
        This determines how (or if) the covariance matrix cov is
        normalized before PCA.
        
        * When set to NONE, no normalization is performed. This is the
          default.
        
        * When set to TRIANGLE_SPECIFIED, each entry cov(i,j) is divided
          by V(i,j).
        * The list V of normalization factors must be set using the
          SetNormalization method
        * before the filter is executed.
        
        * When set to DIAGONAL_SPECIFIED, each entry cov(i,j) is divided
          by sqrt(V(i)*V(j)).
        * The list V of normalization factors must be set using the
          SetNormalization method
        * before the filter is executed.
        
        * When set to DIAGONAL_VARIANCE, each entry cov(i,j) is divided
          by sqrt(cov(i,i)*cov(j,j)).
        * Warning: Although this is accepted practice in some fields,
        * some people think you should not turn this option on unless
          there
        * is a good physically-based reason for doing so. Much better
          instead
        * to determine how component magnitudes should be compared using
        * physical reasoning and use DIAGONAL_SPECIFIED,
          TRIANGLE_SPECIFIED, or
        * perform some pre-processing to shift and scale input data
          columns
        * appropriately than to expect magical results from a shady
          normalization hack.
        """
        ...
    
    def SetParameter(self, string, p_int, vtkVariant):
        """
        V.SetParameter(string, int, vtkVariant) -> bool
        C++: bool SetParameter(const char *parameter, int index,
            vtkVariant value) override;
        
        A convenience method (in particular for access from other
        applications) to set parameter values. Return true if setting of
        requested parameter name was executed, false otherwise.
        """
        ...
    
    def SetSpecifiedNormalization(self, vtkTable):
        """
        V.SetSpecifiedNormalization(vtkTable)
        C++: virtual void SetSpecifiedNormalization(vtkTable *)
        
        These methods allow you to set/get values used to normalize the
        covariance matrix before PCA. The normalization values apply to
        all requests, so you do not specify a single vector but a
        3-column table.
        
        * The first two columns contain the names of columns from input 0
        and the third column contains
        * the value to normalize the corresponding entry in the
          covariance matrix.
        * The table must always have 3 columns even when the
          NormalizationScheme is DIAGONAL_SPECIFIED.
        * When only diagonal entries are to be used, only table rows
          where the first two columns are
        * identical to one another will be employed.
        * If there are multiple rows specifying different values for the
          same pair of columns,
        * the entry nearest the bottom of the table takes precedence.
        
        * These functions are actually convenience methods that set/get
          the third input of the filter.
        * Because the table is the third input, you may use other filters
        to produce a table of
        * normalizations and have the pipeline take care of updates.
        
        * Any missing entries will be set to 1.0 and a warning issued.
        * An error will occur if the third input to the filter is not set
        and the
        * NormalizationScheme is DIAGONAL_SPECIFIED or
          TRIANGLE_SPECIFIED.
        
        * NOTE: SetSpecifiedNormalization( table ) is equivalent to
          SetInputData(3, table)
        * and therefore does not make a pipeline connection.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    DIAGONAL_SPECIFIED = ...
    DIAGONAL_VARIANCE = ...
    FIXED_BASIS_ENERGY = ...
    FIXED_BASIS_SIZE = ...
    FULL_BASIS = ...
    NONE = ...
    NormalizationType = ...
    NUM_BASIS_SCHEMES = ...
    NUM_NORMALIZATION_SCHEMES = ...
    ProjectionType = ...
    TRIANGLE_SPECIFIED = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkStatisticsAlgorithmPrivate(object):
    """
    vtkStatisticsAlgorithmPrivate - no description provided.
    
    vtkStatisticsAlgorithmPrivate()
    vtkStatisticsAlgorithmPrivate(const &vtkStatisticsAlgorithmPrivate)
    """
    def AddBufferToRequests(self):
        """
        V.AddBufferToRequests() -> int
        C++: int AddBufferToRequests()
        """
        ...
    
    def AddColumnPairToRequests(self, string, string_1):
        """
        V.AddColumnPairToRequests(string, string) -> int
        C++: int AddColumnPairToRequests(const char *cola,
            const char *colb)
        
        This function does not use the buffer like other column selection
        methods.
        """
        ...
    
    def AddColumnToRequests(self, string):
        """
        V.AddColumnToRequests(string) -> int
        C++: int AddColumnToRequests(const char *col)
        
        This function does not use the buffer like other column selection
        methods.
        """
        ...
    
    def GetColumnForRequest(self, p_int, p_int_1, string):
        """
        V.GetColumnForRequest(int, int, string) -> bool
        C++: bool GetColumnForRequest(vtkIdType r, vtkIdType c,
            vtkStdString &columnName)
        
        Provide the name of the c-th column of the r-th request in
        columnName. Returns false if the request or column does not exist
        and true otherwise.
        """
        ...
    
    def GetNumberOfColumnsForRequest(self, p_int):
        """
        V.GetNumberOfColumnsForRequest(int) -> int
        C++: vtkIdType GetNumberOfColumnsForRequest(vtkIdType r)
        
        Return the number of columns associated with request r.
        """
        ...
    
    def GetNumberOfRequests(self):
        """
        V.GetNumberOfRequests() -> int
        C++: vtkIdType GetNumberOfRequests()
        
        Return the number of currently-defined requests
        """
        ...
    
    def ResetBuffer(self):
        """
        V.ResetBuffer() -> int
        C++: int ResetBuffer()
        
        Empty current buffer
        """
        ...
    
    def ResetRequests(self):
        """
        V.ResetRequests()
        C++: void ResetRequests()
        
        Empty current set of requests
        """
        ...
    
    def SetBufferColumnStatus(self, string, p_int):
        """
        V.SetBufferColumnStatus(string, int) -> int
        C++: int SetBufferColumnStatus(const char *colName, int status)
        """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __hash__(self, *args, **kwargs) -> int:
        """ Return hash(self). """
        ...
    
    def __init__(self) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    


class vtkStrahlerMetric(__vtkmodules_vtkCommonExecutionModel.vtkTreeAlgorithm):
    """
    vtkStrahlerMetric - compute Strahler metric for a tree
    
    Superclass: vtkTreeAlgorithm
    
    The Strahler metric is a value assigned to each vertex of a tree that
    characterizes the structural complexity of the sub-tree rooted at
    that node.  The metric originated in the study of river systems, but
    has been applied to other tree- structured systes,  Details of the
    metric and the rationale for using it in infovis can be found in:
    
    Tree Visualization and Navigation Clues for Information
    Visualization, I. Herman, M. Delest, and G. Melancon, Computer
    Graphics Forum, Vol 17(2), Blackwell, 1998.
    
    The input tree is copied to the output, but with a new array added to
    the output vertex data.
    
    @par Thanks: Thanks to David Duke from the University of Leeds for
    providing this implementation.
    """
    def GetMaxStrahler(self):
        """
        V.GetMaxStrahler() -> float
        C++: virtual float GetMaxStrahler()
        
        Get the maximum strahler value for the tree.
        """
        ...
    
    def GetNormalize(self):
        """
        V.GetNormalize() -> int
        C++: virtual vtkTypeBool GetNormalize()
        
        Set/get setting of normalize flag.  If this is set, the Strahler
        values are scaled into the range [0..1]. Default is for
        normalization to be OFF.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkStrahlerMetric
        C++: vtkStrahlerMetric *NewInstance()
        """
        ...
    
    def NormalizeOff(self):
        """
        V.NormalizeOff()
        C++: virtual void NormalizeOff()
        
        Set/get setting of normalize flag.  If this is set, the Strahler
        values are scaled into the range [0..1]. Default is for
        normalization to be OFF.
        """
        ...
    
    def NormalizeOn(self):
        """
        V.NormalizeOn()
        C++: virtual void NormalizeOn()
        
        Set/get setting of normalize flag.  If this is set, the Strahler
        values are scaled into the range [0..1]. Default is for
        normalization to be OFF.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkStrahlerMetric
        C++: static vtkStrahlerMetric *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetMetricArrayName(self, string):
        """
        V.SetMetricArrayName(string)
        C++: virtual void SetMetricArrayName(const char *_arg)
        
        Set the name of the array in which the Strahler values will be
        stored within the output vertex data. Default is "Strahler"
        """
        ...
    
    def SetNormalize(self, p_int):
        """
        V.SetNormalize(int)
        C++: virtual void SetNormalize(vtkTypeBool _arg)
        
        Set/get setting of normalize flag.  If this is set, the Strahler
        values are scaled into the range [0..1]. Default is for
        normalization to be OFF.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkStreamingStatistics(__vtkmodules_vtkCommonExecutionModel.vtkTableAlgorithm):
    """
    vtkStreamingStatistics - A class for using the statistics filters in
    a streaming mode.
    
    Superclass: vtkTableAlgorithm
    
    A class for using the statistics filters in a streaming mode or
    perhaps an "online, incremental, push" mode.
    
    @par Thanks: Thanks to the Universe for unfolding in a way that
    allowed this class to be implemented, also Godzilla for not crushing
    my computer.
    """
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkStreamingStatistics
        C++: vtkStreamingStatistics *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkStreamingStatistics
        C++: static vtkStreamingStatistics *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetStatisticsAlgorithm(self, vtkStatisticsAlgorithm):
        """
        V.SetStatisticsAlgorithm(vtkStatisticsAlgorithm)
        C++: virtual void SetStatisticsAlgorithm(vtkStatisticsAlgorithm *)
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    InputPorts = ...
    INPUT_DATA = ...
    INPUT_MODEL = ...
    LEARN_PARAMETERS = ...
    OutputIndices = ...
    OUTPUT_DATA = ...
    OUTPUT_MODEL = ...
    OUTPUT_TEST = ...
    __dict__ = ...
    __vtkname__ = ...


__loader__ = ...
__spec__ = ...
