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

from .vtkRandomSequence import vtkRandomSequence

class vtkMinimalStandardRandomSequence(vtkRandomSequence):
    """
    vtkMinimalStandardRandomSequence - Park and Miller Sequence of pseudo
    random numbers
    
    Superclass: vtkRandomSequence
    
    vtkMinimalStandardRandomSequence is a sequence of statistically
    independent pseudo random numbers uniformly distributed between 0.0
    and 1.0.
    
    The sequence is generated by a prime modulus multiplicative linear
    congruential generator (PMMLCG) or "Lehmer generator" with multiplier
    16807 and prime modulus 2^(31)-1. The authors calls it "minimal standard random number
    generator"
    
    ref: "Random Number Generators: Good Ones are Hard to Find," by
    Stephen K. Park and Keith W. Miller in Communications of the ACM, 31,
    10 (Oct. 1988) pp. 1192-1201. Code is at page 1195, "Integer version
    2"
    
    Correctness test is described in first column, page 1195: A seed of 1
    at step 1 should give a seed of 1043618065 at step 10001.
    """
    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 GetRangeValue(self, p_float, p_float_1):
        """
        V.GetRangeValue(float, float) -> float
        C++: virtual double GetRangeValue(double rangeMin,
            double rangeMax)
        
        Convenient method to return a value in a specific range from the
        range [0,1. There is an initial implementation that can be
        overridden by a subclass. There is no pre-condition on the range:
        - it can be in increasing order: rangeMin<rangeMax
        - it can be empty: rangeMin=rangeMax
        - it can be in decreasing order: rangeMin>rangeMax
        \post result_in_range:
        (rangeMin<=rangeMax && result>=rangeMin && result<=rangeMax) ||
        (rangeMax<=rangeMin && result>=rangeMax && result<=rangeMin)
        """
        ...
    
    def GetSeed(self):
        """
        V.GetSeed() -> int
        C++: int GetSeed()
        
        Get the seed of the random sequence. Only useful for writing
        correctness test.
        """
        ...
    
    def GetValue(self):
        """
        V.GetValue() -> float
        C++: double GetValue() override;
        
        Current value
        \post unit_range: result>=0.0 && result<=1.0
        """
        ...
    
    def Initialize(self, p_int):
        """
        V.Initialize(int)
        C++: void Initialize(vtkTypeUInt32 seed) override;
        
        Satisfy general API of vtkRandomSequence superclass. Initialize
        the sequence with a seed.
        """
        ...
    
    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() -> vtkMinimalStandardRandomSequence
        C++: vtkMinimalStandardRandomSequence *NewInstance()
        
        Standard methods for instantiation, type information, and
        printing.
        """
        ...
    
    def Next(self):
        """
        V.Next()
        C++: void Next() override;
        
        Move to the next number in the random sequence.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkMinimalStandardRandomSequence
        C++: static vtkMinimalStandardRandomSequence *SafeDownCast(
            vtkObjectBase *o)
        
        Standard methods for instantiation, type information, and
        printing.
        """
        ...
    
    def SetSeed(self, p_int):
        """
        V.SetSeed(int)
        C++: void SetSeed(int value)
        
        Set the seed of the random sequence. The following pre-condition
        is stated page 1197, second column: valid_seed: value>=1 &&
        value<=2147483646 2147483646=(2^31)-2 This method does not have
        this criterium as a pre-condition (ie it will not fail if an
        incorrect seed value is passed) but the value is silently changed
        to fit in the valid range [1,2147483646]. 2147483646 is added to
        a null or negative value. 2147483647 is changed to be 1 (ie
        2147483646 is subtracted). Implementation note: it also performs
        3 calls to Next() to avoid the bad property that the first random
        number is proportional to the seed value.
        """
        ...
    
    def SetSeedOnly(self, p_int):
        """
        V.SetSeedOnly(int)
        C++: void SetSeedOnly(int value)
        
        Set the seed of the random sequence. There is no extra internal
        adjustment. Only useful for writing correctness test. The
        following pre-condition is stated page 1197, second column
        2147483646=(2^31)-2 This method does not have this criterium as a
        pre-condition (ie it will not fail if an incorrect seed value is
        passed) but the value is silently changed to fit in the valid
        range [1,2147483646]. 2147483646 is added to a null or negative
        value. 2147483647 is changed to be 1 (ie 2147483646 is
        subtracted).
        """
        ...
    
    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__ = ...


