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

from .vtkObject import vtkObject

class vtkRandomPool(vtkObject):
    """
    vtkRandomPool - convenience class to quickly generate a pool of
    random numbers
    
    Superclass: vtkObject
    
    vtkRandomPool generates random numbers, and can do so using
    multithreading.  It supports parallel applications where generating
    random numbers on the fly is difficult (i.e., non-deterministic).
    Also, it can be used to populate vtkDataArrays in an efficient
    manner. By default it uses an instance of vtkMersenneTwister to
    generate random sequences, but any subclass of vtkRandomSequence may
    be used. It also supports simple methods to generate, access, and
    pass random memory pools between objects.
    
    In threaded applications, these class may be conveniently used to
    pre-generate a sequence of random numbers, followed by the use of
    deterministic accessor methods to produce random sequences without
    problems etc. due to unpredictable work load and order of thread
    execution.
    
    @warning
    The class uses vtkMultiThreader if the size of the pool is larger
    than the specified chunk size. Also, vtkSMPTools may be used to scale
    the components in the method PopulateDataArray().
    """
    def GeneratePool(self):
        """
        V.GeneratePool() -> (float, ...)
        C++: const double *GeneratePool()
        
        These methods provide access to the raw random pool as a double
        array. The size of the array is Size*NumberOfComponents. Each x
        value ranges between (0<=x<=1). The class will generate the pool
        as necessary (a modified time for generation is maintained). Also
        a method is available for getting the value at the ith pool
        position and compNum component. Finally, note that the GetValue()
        method uses modulo reduction to ensure that the request remains
        inside of the pool. Two forms are provided, the first assumes
        NumberOfComponents=1; the second allows access to a particular
        component. The GetPool() and GetValue() methods should only be
        called after GeneratePool() has been invoked;
        """
        ...
    
    def GetChunkSize(self):
        """
        V.GetChunkSize() -> int
        C++: virtual vtkIdType GetChunkSize()
        
        Specify the work chunk size at which point multithreading kicks
        in. For small memory pools < ChunkSize, no threading is used.
        Larger pools are computed using vtkMultiThreader.
        """
        ...
    
    def GetChunkSizeMaxValue(self):
        """
        V.GetChunkSizeMaxValue() -> int
        C++: virtual vtkIdType GetChunkSizeMaxValue()
        
        Specify the work chunk size at which point multithreading kicks
        in. For small memory pools < ChunkSize, no threading is used.
        Larger pools are computed using vtkMultiThreader.
        """
        ...
    
    def GetChunkSizeMinValue(self):
        """
        V.GetChunkSizeMinValue() -> int
        C++: virtual vtkIdType GetChunkSizeMinValue()
        
        Specify the work chunk size at which point multithreading kicks
        in. For small memory pools < ChunkSize, no threading is used.
        Larger pools are computed using vtkMultiThreader.
        """
        ...
    
    def GetNumberOfComponents(self):
        """
        V.GetNumberOfComponents() -> int
        C++: virtual vtkIdType GetNumberOfComponents()
        
        Methods to set and get the number of components in the pool. This
        is a convenience capability and can be used to interface with
        vtkDataArrays. By default the number of components is =1.
        """
        ...
    
    def GetNumberOfComponentsMaxValue(self):
        """
        V.GetNumberOfComponentsMaxValue() -> int
        C++: virtual vtkIdType GetNumberOfComponentsMaxValue()
        
        Methods to set and get the number of components in the pool. This
        is a convenience capability and can be used to interface with
        vtkDataArrays. By default the number of components is =1.
        """
        ...
    
    def GetNumberOfComponentsMinValue(self):
        """
        V.GetNumberOfComponentsMinValue() -> int
        C++: virtual vtkIdType GetNumberOfComponentsMinValue()
        
        Methods to set and get the number of components in the pool. This
        is a convenience capability and can be used to interface with
        vtkDataArrays. By default the number of components is =1.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Standard methods for instantiation, type information, and
        printing.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Standard methods for instantiation, type information, and
        printing.
        """
        ...
    
    def GetPool(self):
        """
        V.GetPool() -> (float, ...)
        C++: const double *GetPool()
        
        These methods provide access to the raw random pool as a double
        array. The size of the array is Size*NumberOfComponents. Each x
        value ranges between (0<=x<=1). The class will generate the pool
        as necessary (a modified time for generation is maintained). Also
        a method is available for getting the value at the ith pool
        position and compNum component. Finally, note that the GetValue()
        method uses modulo reduction to ensure that the request remains
        inside of the pool. Two forms are provided, the first assumes
        NumberOfComponents=1; the second allows access to a particular
        component. The GetPool() and GetValue() methods should only be
        called after GeneratePool() has been invoked;
        """
        ...
    
    def GetSequence(self):
        """
        V.GetSequence() -> vtkRandomSequence
        C++: virtual vtkRandomSequence *GetSequence()
        
        Specify the random sequence generator used to produce the random
        pool. By default vtkMersenneTwister is used.
        """
        ...
    
    def GetSize(self):
        """
        V.GetSize() -> int
        C++: virtual vtkIdType GetSize()
        
        Methods to set and get the size of the pool. The size must be
        specified before invoking GeneratePool(). Note the number of
        components will affect the total size (allocated memory is
        Size*NumberOfComponents).
        """
        ...
    
    def GetSizeMaxValue(self):
        """
        V.GetSizeMaxValue() -> int
        C++: virtual vtkIdType GetSizeMaxValue()
        
        Methods to set and get the size of the pool. The size must be
        specified before invoking GeneratePool(). Note the number of
        components will affect the total size (allocated memory is
        Size*NumberOfComponents).
        """
        ...
    
    def GetSizeMinValue(self):
        """
        V.GetSizeMinValue() -> int
        C++: virtual vtkIdType GetSizeMinValue()
        
        Methods to set and get the size of the pool. The size must be
        specified before invoking GeneratePool(). Note the number of
        components will affect the total size (allocated memory is
        Size*NumberOfComponents).
        """
        ...
    
    def GetTotalSize(self):
        """
        V.GetTotalSize() -> int
        C++: vtkIdType GetTotalSize()
        
        This convenience method returns the total size of the memory
        pool, i.e., Size*NumberOfComponents.
        """
        ...
    
    def GetValue(self, p_int):
        """
        V.GetValue(int) -> float
        C++: double GetValue(vtkIdType i)
        V.GetValue(int, int) -> float
        C++: double GetValue(vtkIdType i, int compNum)
        
        These methods provide access to the raw random pool as a double
        array. The size of the array is Size*NumberOfComponents. Each x
        value ranges between (0<=x<=1). The class will generate the pool
        as necessary (a modified time for generation is maintained). Also
        a method is available for getting the value at the ith pool
        position and compNum component. Finally, note that the GetValue()
        method uses modulo reduction to ensure that the request remains
        inside of the pool. Two forms are provided, the first assumes
        NumberOfComponents=1; the second allows access to a particular
        component. The GetPool() and GetValue() methods should only be
        called after GeneratePool() has been invoked;
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Standard methods for instantiation, type information, and
        printing.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Standard methods for instantiation, type information, and
        printing.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkRandomPool
        C++: vtkRandomPool *NewInstance()
        
        Standard methods for instantiation, type information, and
        printing.
        """
        ...
    
    def PopulateDataArray(self, vtkDataArray, p_float, p_float_1):
        """
        V.PopulateDataArray(vtkDataArray, float, float)
        C++: void PopulateDataArray(vtkDataArray *da, double minRange,
            double maxRange)
        V.PopulateDataArray(vtkDataArray, int, float, float)
        C++: void PopulateDataArray(vtkDataArray *da, int compNumber,
            double minRange, double maxRange)
        
        Methods to populate data arrays of various types with values
        within a specified (min,max) range. Note that compNumber is used
        to specify the range for a particular component; otherwise all
        generated components are within the (min,max) range specified.
        (Thus it is possible to make multiple calls to generate random
        numbers for each component with different ranges.) Internally the
        type of the data array passed in is used to cast to the
        appropriate type. Also the size and number of components of the
        vtkDataArray controls the total number of random numbers
        generated; so the input data array should be pre-allocated with
        (SetNumberOfComponents, SetNumberOfTuples).
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkRandomPool
        C++: static vtkRandomPool *SafeDownCast(vtkObjectBase *o)
        
        Standard methods for instantiation, type information, and
        printing.
        """
        ...
    
    def SetChunkSize(self, p_int):
        """
        V.SetChunkSize(int)
        C++: virtual void SetChunkSize(vtkIdType _arg)
        
        Specify the work chunk size at which point multithreading kicks
        in. For small memory pools < ChunkSize, no threading is used.
        Larger pools are computed using vtkMultiThreader.
        """
        ...
    
    def SetNumberOfComponents(self, p_int):
        """
        V.SetNumberOfComponents(int)
        C++: virtual void SetNumberOfComponents(vtkIdType _arg)
        
        Methods to set and get the number of components in the pool. This
        is a convenience capability and can be used to interface with
        vtkDataArrays. By default the number of components is =1.
        """
        ...
    
    def SetSequence(self, vtkRandomSequence):
        """
        V.SetSequence(vtkRandomSequence)
        C++: virtual void SetSequence(vtkRandomSequence *seq)
        
        Specify the random sequence generator used to produce the random
        pool. By default vtkMersenneTwister is used.
        """
        ...
    
    def SetSize(self, p_int):
        """
        V.SetSize(int)
        C++: virtual void SetSize(vtkIdType _arg)
        
        Methods to set and get the size of the pool. The size must be
        specified before invoking GeneratePool(). Note the number of
        components will affect the total size (allocated memory is
        Size*NumberOfComponents).
        """
        ...
    
    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__ = ...


