# encoding: utf-8
# module vtkmodules.vtkCommonMath
# from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkCommonMath.cp311-win_amd64.pyd
# by generator 1.147
# no doc

# imports
import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore


# functions

def vtkQuaternion(*args, **kwargs): # real signature unknown
    """
    vtkQuaterniond - Double quaternion type.
    
    Superclass: vtkTuple[T,4]
    
    This class is uses vtkQuaternion with double type data. For further
    description, seethe templated class vtkQuaternion.
    @sa vtkQuaternionf vtkQuaternion
    
    
    Provided Types:
    
      vtkQuaternion[float64] => vtkQuaternion<double>
      vtkQuaternion[float32] => vtkQuaternion<float>
    """
    pass

def vtkTuple(*args, **kwargs): # real signature unknown
    """
    vtkTuple - templated base type for containers of constant size.
    
    This class is a templated data type for storing and manipulating
    tuples.
    
    
    Provided Types:
    
      vtkTuple[float64,4] => vtkTuple<double, 4>
      vtkTuple[float32,4] => vtkTuple<float, 4>
      vtkTuple[uint8,2] => vtkTuple<unsigned char, 2>
      vtkTuple[uint8,3] => vtkTuple<unsigned char, 3>
      vtkTuple[uint8,4] => vtkTuple<unsigned char, 4>
      vtkTuple[int32,2] => vtkTuple<int, 2>
      vtkTuple[int32,3] => vtkTuple<int, 3>
      vtkTuple[int32,4] => vtkTuple<int, 4>
      vtkTuple[float32,2] => vtkTuple<float, 2>
      vtkTuple[float32,3] => vtkTuple<float, 3>
      vtkTuple[float64,2] => vtkTuple<double, 2>
      vtkTuple[float64,3] => vtkTuple<double, 3>
    """
    pass

# classes

class vtkAmoebaMinimizer(__vtkmodules_vtkCommonCore.vtkObject):
    """
    vtkAmoebaMinimizer - nonlinear optimization with a simplex
    
    Superclass: vtkObject
    
    vtkAmoebaMinimizer will modify a set of parameters in order to find
    the minimum of a specified function.  The method used is commonly
    known as the amoeba method, it constructs an n-dimensional simplex in
    parameter space (i.e. a tetrahedron if the number or parameters is 3)
    and moves the vertices around parameter space until a local minimum
    is found.  The amoeba method is robust, reasonably efficient, but is
    not guaranteed to find the global minimum if several local minima
    exist.
    """
    def EvaluateFunction(self): # real signature unknown; restored from __doc__
        """
        EvaluateFunction(self) -> None
        C++: void EvaluateFunction()
        
        Evaluate the function.  This is usually called internally by the
        minimization code, but it is provided here as a public method.
        """
        pass

    def GetContractionRatio(self): # real signature unknown; restored from __doc__
        """
        GetContractionRatio(self) -> float
        C++: virtual double GetContractionRatio()
        """
        return 0.0

    def GetContractionRatioMaxValue(self): # real signature unknown; restored from __doc__
        """
        GetContractionRatioMaxValue(self) -> float
        C++: virtual double GetContractionRatioMaxValue()
        """
        return 0.0

    def GetContractionRatioMinValue(self): # real signature unknown; restored from __doc__
        """
        GetContractionRatioMinValue(self) -> float
        C++: virtual double GetContractionRatioMinValue()
        """
        return 0.0

    def GetExpansionRatio(self): # real signature unknown; restored from __doc__
        """
        GetExpansionRatio(self) -> float
        C++: virtual double GetExpansionRatio()
        """
        return 0.0

    def GetExpansionRatioMaxValue(self): # real signature unknown; restored from __doc__
        """
        GetExpansionRatioMaxValue(self) -> float
        C++: virtual double GetExpansionRatioMaxValue()
        """
        return 0.0

    def GetExpansionRatioMinValue(self): # real signature unknown; restored from __doc__
        """
        GetExpansionRatioMinValue(self) -> float
        C++: virtual double GetExpansionRatioMinValue()
        """
        return 0.0

    def GetFunctionEvaluations(self): # real signature unknown; restored from __doc__
        """
        GetFunctionEvaluations(self) -> int
        C++: virtual int GetFunctionEvaluations()
        
        Return the number of times that the function has been evaluated.
        """
        return 0

    def GetFunctionValue(self): # real signature unknown; restored from __doc__
        """
        GetFunctionValue(self) -> float
        C++: double GetFunctionValue()
        """
        return 0.0

    def GetIterations(self): # real signature unknown; restored from __doc__
        """
        GetIterations(self) -> int
        C++: virtual int GetIterations()
        
        Return the number of iterations that have been performed.  This
        is not necessarily the same as the number of function
        evaluations.
        """
        return 0

    def GetMaxIterations(self): # real signature unknown; restored from __doc__
        """
        GetMaxIterations(self) -> int
        C++: virtual int GetMaxIterations()
        """
        return 0

    def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBase(self, type:str) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given 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.
        """
        return 0

    def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBaseType(type:str) -> 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.
        """
        return 0

    def GetNumberOfParameters(self): # real signature unknown; restored from __doc__
        """
        GetNumberOfParameters(self) -> int
        C++: int GetNumberOfParameters()
        
        Get the number of parameters that have been set.
        """
        return 0

    def GetParameterName(self, i): # real signature unknown; restored from __doc__
        """
        GetParameterName(self, i:int) -> str
        C++: const char *GetParameterName(int i)
        
        For completeness, an unchecked method to get the name for
        particular parameter (the result will be nullptr if no name was
        set).
        """
        return ""

    def GetParameterScale(self, name): # real signature unknown; restored from __doc__
        """
        GetParameterScale(self, name:str) -> float
        C++: double GetParameterScale(const char *name)
        GetParameterScale(self, i:int) -> float
        C++: double GetParameterScale(int i)
        """
        return 0.0

    def GetParameterTolerance(self): # real signature unknown; restored from __doc__
        """
        GetParameterTolerance(self) -> float
        C++: virtual double GetParameterTolerance()
        """
        return 0.0

    def GetParameterValue(self, name): # real signature unknown; restored from __doc__
        """
        GetParameterValue(self, name:str) -> float
        C++: double GetParameterValue(const char *name)
        GetParameterValue(self, i:int) -> float
        C++: double GetParameterValue(int i)
        
        Get the value of a parameter at the current stage of the
        minimization. Call this method within the function that you are
        minimizing in order to get the current parameter values.  It is
        preferable to specify parameters by name rather than by index.
        """
        return 0.0

    def GetTolerance(self): # real signature unknown; restored from __doc__
        """
        GetTolerance(self) -> float
        C++: virtual double GetTolerance()
        """
        return 0.0

    def Initialize(self): # real signature unknown; restored from __doc__
        """
        Initialize(self) -> None
        C++: void Initialize()
        
        Initialize the minimizer.  This will reset the number of
        parameters to zero so that the minimizer can be reused.
        """
        pass

    def IsA(self, type): # real signature unknown; restored from __doc__
        """
        IsA(self, type:str) -> 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.
        """
        return 0

    def IsTypeOf(self, type): # real signature unknown; restored from __doc__
        """
        IsTypeOf(type:str) -> 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.
        """
        return 0

    def Iterate(self): # real signature unknown; restored from __doc__
        """
        Iterate(self) -> int
        C++: virtual int Iterate()
        
        Perform one iteration of minimization.  Returns zero if the
        tolerance stopping criterion has been met.
        """
        return 0

    def Minimize(self): # real signature unknown; restored from __doc__
        """
        Minimize(self) -> None
        C++: virtual void Minimize()
        
        Iterate until the minimum is found to within the specified
        tolerance, or until the MaxIterations has been reached.
        """
        pass

    def NewInstance(self): # real signature unknown; restored from __doc__
        """
        NewInstance(self) -> vtkAmoebaMinimizer
        C++: vtkAmoebaMinimizer *NewInstance()
        """
        return vtkAmoebaMinimizer

    def SafeDownCast(self, o): # real signature unknown; restored from __doc__
        """
        SafeDownCast(o:vtkObjectBase) -> vtkAmoebaMinimizer
        C++: static vtkAmoebaMinimizer *SafeDownCast(vtkObjectBase *o)
        """
        return vtkAmoebaMinimizer

    def SetContractionRatio(self, _arg): # real signature unknown; restored from __doc__
        """
        SetContractionRatio(self, _arg:float) -> None
        C++: virtual void SetContractionRatio(double _arg)
        
        Set the amoeba contraction ratio.  The default value of 0.5 gives
        fast convergence, but larger values such as 0.6 or 0.7 provide
        greater stability.
        """
        pass

    def SetExpansionRatio(self, _arg): # real signature unknown; restored from __doc__
        """
        SetExpansionRatio(self, _arg:float) -> None
        C++: virtual void SetExpansionRatio(double _arg)
        
        Set the amoeba expansion ratio.  The default value is 2.0, which
        provides rapid expansion.  Values between 1.1 and 2.0 are valid.
        """
        pass

    def SetFunction(self, f): # real signature unknown; restored from __doc__
        """
        SetFunction(self, f:Callback) -> None
        C++: void SetFunction(void (*f)(void *), void *arg)
        
        Specify the function to be minimized.  When this function is
        called, it must get the parameter values by calling
        GetParameterValue() for each parameter, and then must call
        SetFunctionValue() to tell the minimizer what the result of the
        function evaluation was.  The number of function evaluations used
        for the minimization can be retrieved using
        GetFunctionEvaluations().
        """
        pass

    def SetFunctionValue(self, _arg): # real signature unknown; restored from __doc__
        """
        SetFunctionValue(self, _arg:float) -> None
        C++: virtual void SetFunctionValue(double _arg)
        
        Get the function value resulting from the minimization.
        """
        pass

    def SetMaxIterations(self, _arg): # real signature unknown; restored from __doc__
        """
        SetMaxIterations(self, _arg:int) -> None
        C++: virtual void SetMaxIterations(int _arg)
        
        Specify the maximum number of iterations to try before giving up.
        """
        pass

    def SetParameterScale(self, name, scale): # real signature unknown; restored from __doc__
        """
        SetParameterScale(self, name:str, scale:float) -> None
        C++: void SetParameterScale(const char *name, double scale)
        SetParameterScale(self, i:int, scale:float) -> None
        C++: void SetParameterScale(int i, double scale)
        
        Set the scale to use when modifying a parameter, i.e. the initial
        amount by which the parameter will be modified during the search
        for the minimum.  It is preferable to identify scalars by name
        rather than by number.
        """
        pass

    def SetParameterTolerance(self, _arg): # real signature unknown; restored from __doc__
        """
        SetParameterTolerance(self, _arg:float) -> None
        C++: virtual void SetParameterTolerance(double _arg)
        
        Specify the parameter tolerance to aim for during the
        minimization.
        """
        pass

    def SetParameterValue(self, name, value): # real signature unknown; restored from __doc__
        """
        SetParameterValue(self, name:str, value:float) -> None
        C++: void SetParameterValue(const char *name, double value)
        SetParameterValue(self, i:int, value:float) -> None
        C++: void SetParameterValue(int i, double value)
        
        Set the initial value for the specified parameter.  Calling this
        function for any parameter will reset the Iterations and the
        FunctionEvaluations counts to zero.  You must also use
        SetParameterScale() to specify the step size by which the
        parameter will be modified during the minimization.  It is
        preferable to specify parameters by name, rather than by number.
        """
        pass

    def SetTolerance(self, _arg): # real signature unknown; restored from __doc__
        """
        SetTolerance(self, _arg:float) -> None
        C++: virtual void SetTolerance(double _arg)
        
        Specify the value tolerance to aim for during the minimization.
        """
        pass

    def __delattr__(self, *args, **kwargs): # real signature unknown
        """ Implement delattr(self, name). """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setattr__(self, *args, **kwargs): # real signature unknown
        """ Implement setattr(self, name, value). """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass

    __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Pointer to the C++ object."""


    __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkAmoebaMinimizer', 'IsTypeOf': <method 'IsTypeOf' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'IsA': <method 'IsA' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'SafeDownCast': <method 'SafeDownCast' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'NewInstance': <method 'NewInstance' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetNumberOfGenerationsFromBaseType': <method 'GetNumberOfGenerationsFromBaseType' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetNumberOfGenerationsFromBase': <method 'GetNumberOfGenerationsFromBase' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'SetFunction': <method 'SetFunction' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'SetParameterValue': <method 'SetParameterValue' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'SetParameterScale': <method 'SetParameterScale' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetParameterScale': <method 'GetParameterScale' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetParameterValue': <method 'GetParameterValue' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetParameterName': <method 'GetParameterName' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetNumberOfParameters': <method 'GetNumberOfParameters' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'Initialize': <method 'Initialize' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'Minimize': <method 'Minimize' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'Iterate': <method 'Iterate' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'SetFunctionValue': <method 'SetFunctionValue' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetFunctionValue': <method 'GetFunctionValue' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'SetContractionRatio': <method 'SetContractionRatio' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetContractionRatioMinValue': <method 'GetContractionRatioMinValue' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetContractionRatioMaxValue': <method 'GetContractionRatioMaxValue' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetContractionRatio': <method 'GetContractionRatio' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'SetExpansionRatio': <method 'SetExpansionRatio' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetExpansionRatioMinValue': <method 'GetExpansionRatioMinValue' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetExpansionRatioMaxValue': <method 'GetExpansionRatioMaxValue' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetExpansionRatio': <method 'GetExpansionRatio' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'SetTolerance': <method 'SetTolerance' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetTolerance': <method 'GetTolerance' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'SetParameterTolerance': <method 'SetParameterTolerance' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetParameterTolerance': <method 'GetParameterTolerance' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'SetMaxIterations': <method 'SetMaxIterations' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetMaxIterations': <method 'GetMaxIterations' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetIterations': <method 'GetIterations' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'GetFunctionEvaluations': <method 'GetFunctionEvaluations' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, 'EvaluateFunction': <method 'EvaluateFunction' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, '__new__': <built-in method __new__ of type object at 0x00007FF85F0559B0>, '__repr__': <slot wrapper '__repr__' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, '__str__': <slot wrapper '__str__' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, '__setattr__': <slot wrapper '__setattr__' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, '__delattr__': <slot wrapper '__delattr__' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, '__dict__': <attribute '__dict__' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, '__this__': <attribute '__this__' of 'vtkmodules.vtkCommonMath.vtkAmoebaMinimizer' objects>, '__doc__': 'vtkAmoebaMinimizer - nonlinear optimization with a simplex\\n\\nSuperclass: vtkObject\\n\\nvtkAmoebaMinimizer will modify a set of parameters in order to find\\nthe minimum of a specified function.  The method used is commonly\\nknown as the amoeba method, it constructs an n-dimensional simplex in\\nparameter space (i.e. a tetrahedron if the number or parameters is 3)\\nand moves the vertices around parameter space until a local minimum\\nis found.  The amoeba method is robust, reasonably efficient, but is\\nnot guaranteed to find the global minimum if several local minima\\nexist.\\n\\n'})"
    __vtkname__ = 'vtkAmoebaMinimizer'


class vtkFFT(__vtkmodules_vtkCommonCore.vtkObject):
    """
    vtkFFT - perform Discrete Fourier Transforms
    
    Superclass: vtkObject
    
    vtkFFT provides methods to perform Discrete Fourier Transforms (DFT).
    These include providing forward and reverse Fourier transforms. The
    current implementation uses the third-party library kissfft.
    
    The terminology tries to follow the Numpy terminology, that is :
    - Fft means the Fast Fourier Transform algorithm
    - Prefix `R` stands for Real (meaning optimized function for real
      inputs)
    - Prefix `I` stands for Inverse
    """
    def BartlettGenerator(self, x, size): # real signature unknown; restored from __doc__
        """
        BartlettGenerator(x:int, size:int) -> float
        C++: static double BartlettGenerator(const std::size_t x,
            const std::size_t size)
        
        Window generator functions. Implementation only needs to be valid
        for x E [0; size / 2] because kernels are symmetric by
        definitions. This point is very important for some kernels like
        Bartlett for example.
        
        @warning Hanning and Bartlett generators needs a size > 1 !
        
        Can be used with GenerateKernel1D and GenerateKernel2D for
        generating full kernels.
        """
        return 0.0

    def BlackmanGenerator(self, x, size): # real signature unknown; restored from __doc__
        """
        BlackmanGenerator(x:int, size:int) -> float
        C++: static double BlackmanGenerator(const std::size_t x,
            const std::size_t size)
        
        Window generator functions. Implementation only needs to be valid
        for x E [0; size / 2] because kernels are symmetric by
        definitions. This point is very important for some kernels like
        Bartlett for example.
        
        @warning Hanning and Bartlett generators needs a size > 1 !
        
        Can be used with GenerateKernel1D and GenerateKernel2D for
        generating full kernels.
        """
        return 0.0

    def FftFreq(self, windowLength, sampleSpacing): # real signature unknown; restored from __doc__
        """
        FftFreq(windowLength:int, sampleSpacing:float) -> (float, ...)
        C++: static std::vector<double> FftFreq(int windowLength,
            double sampleSpacing)
        
        Return the DFT sample frequencies. Output has windowLength size.
        """
        pass

    def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBase(self, type:str) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given 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.
        """
        return 0

    def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBaseType(type:str) -> 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.
        """
        return 0

    def HanningGenerator(self, x, size): # real signature unknown; restored from __doc__
        """
        HanningGenerator(x:int, size:int) -> float
        C++: static double HanningGenerator(const std::size_t x,
            const std::size_t size)
        
        Window generator functions. Implementation only needs to be valid
        for x E [0; size / 2] because kernels are symmetric by
        definitions. This point is very important for some kernels like
        Bartlett for example.
        
        @warning Hanning and Bartlett generators needs a size > 1 !
        
        Can be used with GenerateKernel1D and GenerateKernel2D for
        generating full kernels.
        """
        return 0.0

    def IsA(self, type): # real signature unknown; restored from __doc__
        """
        IsA(self, type:str) -> 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.
        """
        return 0

    def IsTypeOf(self, type): # real signature unknown; restored from __doc__
        """
        IsTypeOf(type:str) -> 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.
        """
        return 0

    def NewInstance(self): # real signature unknown; restored from __doc__
        """
        NewInstance(self) -> vtkFFT
        C++: vtkFFT *NewInstance()
        """
        return vtkFFT

    def RectangularGenerator(self, x, size): # real signature unknown; restored from __doc__
        """
        RectangularGenerator(x:int, size:int) -> float
        C++: static double RectangularGenerator(const std::size_t x,
            const std::size_t size)
        
        Window generator functions. Implementation only needs to be valid
        for x E [0; size / 2] because kernels are symmetric by
        definitions. This point is very important for some kernels like
        Bartlett for example.
        
        @warning Hanning and Bartlett generators needs a size > 1 !
        
        Can be used with GenerateKernel1D and GenerateKernel2D for
        generating full kernels.
        """
        return 0.0

    def RFftFreq(self, windowLength, sampleSpacing): # real signature unknown; restored from __doc__
        """
        RFftFreq(windowLength:int, sampleSpacing:float) -> (float, ...)
        C++: static std::vector<double> RFftFreq(int windowLength,
            double sampleSpacing)
        
        Return the DFT sample frequencies for the real version of the dft
        (see Rfft). Output has (windowLength / 2) + 1 size.
        """
        pass

    def SafeDownCast(self, o): # real signature unknown; restored from __doc__
        """
        SafeDownCast(o:vtkObjectBase) -> vtkFFT
        C++: static vtkFFT *SafeDownCast(vtkObjectBase *o)
        """
        return vtkFFT

    def SineGenerator(self, x, size): # real signature unknown; restored from __doc__
        """
        SineGenerator(x:int, size:int) -> float
        C++: static double SineGenerator(const std::size_t x,
            const std::size_t size)
        
        Window generator functions. Implementation only needs to be valid
        for x E [0; size / 2] because kernels are symmetric by
        definitions. This point is very important for some kernels like
        Bartlett for example.
        
        @warning Hanning and Bartlett generators needs a size > 1 !
        
        Can be used with GenerateKernel1D and GenerateKernel2D for
        generating full kernels.
        """
        return 0.0

    def __delattr__(self, *args, **kwargs): # real signature unknown
        """ Implement delattr(self, name). """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setattr__(self, *args, **kwargs): # real signature unknown
        """ Implement setattr(self, name, value). """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass

    __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Pointer to the C++ object."""


    __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkFFT', 'IsTypeOf': <method 'IsTypeOf' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, 'IsA': <method 'IsA' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, 'SafeDownCast': <method 'SafeDownCast' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, 'NewInstance': <method 'NewInstance' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, 'GetNumberOfGenerationsFromBaseType': <method 'GetNumberOfGenerationsFromBaseType' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, 'GetNumberOfGenerationsFromBase': <method 'GetNumberOfGenerationsFromBase' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, 'FftFreq': <method 'FftFreq' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, 'RFftFreq': <method 'RFftFreq' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, 'HanningGenerator': <method 'HanningGenerator' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, 'BartlettGenerator': <method 'BartlettGenerator' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, 'SineGenerator': <method 'SineGenerator' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, 'BlackmanGenerator': <method 'BlackmanGenerator' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, 'RectangularGenerator': <method 'RectangularGenerator' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, '__new__': <built-in method __new__ of type object at 0x00007FF85F055D20>, '__repr__': <slot wrapper '__repr__' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, '__str__': <slot wrapper '__str__' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, '__setattr__': <slot wrapper '__setattr__' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, '__delattr__': <slot wrapper '__delattr__' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, '__dict__': <attribute '__dict__' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, '__this__': <attribute '__this__' of 'vtkmodules.vtkCommonMath.vtkFFT' objects>, '__doc__': 'vtkFFT - perform Discrete Fourier Transforms\\n\\nSuperclass: vtkObject\\n\\nvtkFFT provides methods to perform Discrete Fourier Transforms (DFT).\\nThese include providing forward and reverse Fourier transforms. The\\ncurrent implementation uses the third-party library kissfft.\\n\\nThe terminology tries to follow the Numpy terminology, that is :\\n- Fft means the Fast Fourier Transform algorithm\\n- Prefix `R` stands for Real (meaning optimized function for real\\n  inputs)\\n- Prefix `I` stands for Inverse\\n\\n'})"
    __vtkname__ = 'vtkFFT'


class vtkFunctionSet(__vtkmodules_vtkCommonCore.vtkObject):
    """
    vtkFunctionSet - Abstract interface for sets of functions
    
    Superclass: vtkObject
    
    vtkFunctionSet specifies an abstract interface for set of functions
    of the form F_i = F_i(x_j) where F (with i=1..m) are the functions
    and x (with j=1..n) are the independent variables. The only supported
    operation is the function evaluation at x_j.
    
    @sa
    vtkImplicitDataSet vtkCompositeInterpolatedVelocityField
    vtkAMRInterpolatedVelocityField vtkInitialValueProblemSolver
    """
    def FunctionValues(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        FunctionValues(self, x:[float, ...], f:[float, ...]) -> int
        C++: virtual int FunctionValues(double *x, double *f)
        FunctionValues(self, x:[float, ...], f:[float, ...],
            userData:Pointer) -> int
        C++: virtual int FunctionValues(double *x, double *f,
            void *userData)
        
        Evaluate functions at x_j. x and f have to point to valid double
        arrays of appropriate sizes obtained with GetNumberOfFunctions()
        and GetNumberOfIndependentVariables. If you inherit this class,
        make sure to reimplement at least one of the two FunctionValues
        signatures.
        """
        pass

    def GetNumberOfFunctions(self): # real signature unknown; restored from __doc__
        """
        GetNumberOfFunctions(self) -> int
        C++: virtual int GetNumberOfFunctions()
        
        Return the number of functions. Note that this is constant for a
        given type of set of functions and can not be changed at run
        time.
        """
        return 0

    def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBase(self, type:str) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given 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.
        """
        return 0

    def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBaseType(type:str) -> 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.
        """
        return 0

    def GetNumberOfIndependentVariables(self): # real signature unknown; restored from __doc__
        """
        GetNumberOfIndependentVariables(self) -> int
        C++: virtual int GetNumberOfIndependentVariables()
        
        Return the number of independent variables. Note that this is
        constant for a given type of set of functions and can not be
        changed at run time.
        """
        return 0

    def IsA(self, type): # real signature unknown; restored from __doc__
        """
        IsA(self, type:str) -> 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.
        """
        return 0

    def IsTypeOf(self, type): # real signature unknown; restored from __doc__
        """
        IsTypeOf(type:str) -> 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.
        """
        return 0

    def NewInstance(self): # real signature unknown; restored from __doc__
        """
        NewInstance(self) -> vtkFunctionSet
        C++: vtkFunctionSet *NewInstance()
        """
        return vtkFunctionSet

    def SafeDownCast(self, o): # real signature unknown; restored from __doc__
        """
        SafeDownCast(o:vtkObjectBase) -> vtkFunctionSet
        C++: static vtkFunctionSet *SafeDownCast(vtkObjectBase *o)
        """
        return vtkFunctionSet

    def __delattr__(self, *args, **kwargs): # real signature unknown
        """ Implement delattr(self, name). """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setattr__(self, *args, **kwargs): # real signature unknown
        """ Implement setattr(self, name, value). """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass

    __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Pointer to the C++ object."""


    __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkFunctionSet', 'IsTypeOf': <method 'IsTypeOf' of 'vtkmodules.vtkCommonMath.vtkFunctionSet' objects>, 'IsA': <method 'IsA' of 'vtkmodules.vtkCommonMath.vtkFunctionSet' objects>, 'SafeDownCast': <method 'SafeDownCast' of 'vtkmodules.vtkCommonMath.vtkFunctionSet' objects>, 'NewInstance': <method 'NewInstance' of 'vtkmodules.vtkCommonMath.vtkFunctionSet' objects>, 'GetNumberOfGenerationsFromBaseType': <method 'GetNumberOfGenerationsFromBaseType' of 'vtkmodules.vtkCommonMath.vtkFunctionSet' objects>, 'GetNumberOfGenerationsFromBase': <method 'GetNumberOfGenerationsFromBase' of 'vtkmodules.vtkCommonMath.vtkFunctionSet' objects>, 'FunctionValues': <method 'FunctionValues' of 'vtkmodules.vtkCommonMath.vtkFunctionSet' objects>, 'GetNumberOfFunctions': <method 'GetNumberOfFunctions' of 'vtkmodules.vtkCommonMath.vtkFunctionSet' objects>, 'GetNumberOfIndependentVariables': <method 'GetNumberOfIndependentVariables' of 'vtkmodules.vtkCommonMath.vtkFunctionSet' objects>, '__new__': <built-in method __new__ of type object at 0x00007FF85F056010>, '__repr__': <slot wrapper '__repr__' of 'vtkmodules.vtkCommonMath.vtkFunctionSet' objects>, '__str__': <slot wrapper '__str__' of 'vtkmodules.vtkCommonMath.vtkFunctionSet' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'vtkmodules.vtkCommonMath.vtkFunctionSet' objects>, '__setattr__': <slot wrapper '__setattr__' of 'vtkmodules.vtkCommonMath.vtkFunctionSet' objects>, '__delattr__': <slot wrapper '__delattr__' of 'vtkmodules.vtkCommonMath.vtkFunctionSet' objects>, '__dict__': <attribute '__dict__' of 'vtkmodules.vtkCommonMath.vtkFunctionSet' objects>, '__this__': <attribute '__this__' of 'vtkmodules.vtkCommonMath.vtkFunctionSet' objects>, '__doc__': 'vtkFunctionSet - Abstract interface for sets of functions\\n\\nSuperclass: vtkObject\\n\\nvtkFunctionSet specifies an abstract interface for set of functions\\nof the form F_i = F_i(x_j) where F (with i=1..m) are the functions\\nand x (with j=1..n) are the independent variables. The only supported\\noperation is the function evaluation at x_j.\\n\\n@sa\\nvtkImplicitDataSet vtkCompositeInterpolatedVelocityField\\nvtkAMRInterpolatedVelocityField vtkInitialValueProblemSolver\\n\\n'})"
    __vtkname__ = 'vtkFunctionSet'


class vtkInitialValueProblemSolver(__vtkmodules_vtkCommonCore.vtkObject):
    """
    vtkInitialValueProblemSolver - Integrate a set of ordinary
    differential equations (initial value problem) in time.
    
    Superclass: vtkObject
    
    Given a vtkFunctionSet which returns dF_i(x_j, t)/dt given x_j and t,
    vtkInitialValueProblemSolver computes the value of F_i at t+deltat.
    
    @warning
    vtkInitialValueProblemSolver and it's subclasses are not thread-safe.
    You should create a new integrator for each thread.
    
    @sa
    vtkRungeKutta2 vtkRungeKutta4
    """
    def ComputeNextStep(self, xprev, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        ComputeNextStep(self, xprev:[float, ...], xnext:[float, ...],
            t:float, delT:float, maxError:float, error:float) -> int
        C++: virtual int ComputeNextStep(double *xprev, double *xnext,
            double t, double &delT, double maxError, double &error)
        ComputeNextStep(self, xprev:[float, ...], xnext:[float, ...],
            t:float, delT:float, maxError:float, error:float,
            userData:Pointer) -> int
        C++: virtual int ComputeNextStep(double *xprev, double *xnext,
            double t, double &delT, double maxError, double &error,
            void *userData)
        ComputeNextStep(self, xprev:[float, ...], dxprev:[float, ...],
            xnext:[float, ...], t:float, delT:float, maxError:float,
            error:float) -> int
        C++: virtual int ComputeNextStep(double *xprev, double *dxprev,
            double *xnext, double t, double &delT, double maxError,
            double &error)
        ComputeNextStep(self, xprev:[float, ...], dxprev:[float, ...],
            xnext:[float, ...], t:float, delT:float, maxError:float,
            error:float, userData:Pointer) -> int
        C++: virtual int ComputeNextStep(double *xprev, double *dxprev,
            double *xnext, double t, double &delT, double maxError,
            double &error, void *userData)
        ComputeNextStep(self, xprev:[float, ...], xnext:[float, ...],
            t:float, delT:float, delTActual:float, minStep:float,
            maxStep:float, maxError:float, error:float) -> int
        C++: virtual int ComputeNextStep(double *xprev, double *xnext,
            double t, double &delT, double &delTActual, double minStep,
            double maxStep, double maxError, double &error)
        ComputeNextStep(self, xprev:[float, ...], xnext:[float, ...],
            t:float, delT:float, delTActual:float, minStep:float,
            maxStep:float, maxError:float, error:float, userData:Pointer)
            -> int
        C++: virtual int ComputeNextStep(double *xprev, double *xnext,
            double t, double &delT, double &delTActual, double minStep,
            double maxStep, double maxError, double &error,
            void *userData)
        
        Given initial values, xprev , initial time, t and a requested
        time interval, delT ca ...
         [Truncated]
        """
        pass

    def GetFunctionSet(self): # real signature unknown; restored from __doc__
        """
        GetFunctionSet(self) -> vtkFunctionSet
        C++: virtual vtkFunctionSet *GetFunctionSet()
        """
        return vtkFunctionSet

    def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBase(self, type:str) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given 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.
        """
        return 0

    def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBaseType(type:str) -> 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.
        """
        return 0

    def IsA(self, type): # real signature unknown; restored from __doc__
        """
        IsA(self, type:str) -> 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.
        """
        return 0

    def IsAdaptive(self): # real signature unknown; restored from __doc__
        """
        IsAdaptive(self) -> int
        C++: virtual vtkTypeBool IsAdaptive()
        
        Returns 1 if the solver uses adaptive stepsize control, 0
        otherwise
        """
        return 0

    def IsTypeOf(self, type): # real signature unknown; restored from __doc__
        """
        IsTypeOf(type:str) -> 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.
        """
        return 0

    def NewInstance(self): # real signature unknown; restored from __doc__
        """
        NewInstance(self) -> vtkInitialValueProblemSolver
        C++: vtkInitialValueProblemSolver *NewInstance()
        """
        return vtkInitialValueProblemSolver

    def SafeDownCast(self, o): # real signature unknown; restored from __doc__
        """
        SafeDownCast(o:vtkObjectBase) -> vtkInitialValueProblemSolver
        C++: static vtkInitialValueProblemSolver *SafeDownCast(
            vtkObjectBase *o)
        """
        return vtkInitialValueProblemSolver

    def SetFunctionSet(self, fset): # real signature unknown; restored from __doc__
        """
        SetFunctionSet(self, fset:vtkFunctionSet) -> None
        C++: virtual void SetFunctionSet(vtkFunctionSet *fset)
        
        Set / get the dataset used for the implicit function evaluation.
        """
        pass

    def __delattr__(self, *args, **kwargs): # real signature unknown
        """ Implement delattr(self, name). """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setattr__(self, *args, **kwargs): # real signature unknown
        """ Implement setattr(self, name, value). """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass

    __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Pointer to the C++ object."""


    ErrorCodes = None # (!) real value is "<class 'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver.ErrorCodes'>"
    NOT_INITIALIZED = 2
    OUT_OF_DOMAIN = 1
    UNEXPECTED_VALUE = 3
    __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkInitialValueProblemSolver\', \'IsTypeOf\': <method \'IsTypeOf\' of \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver\' objects>, \'IsA\': <method \'IsA\' of \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver\' objects>, \'SafeDownCast\': <method \'SafeDownCast\' of \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver\' objects>, \'NewInstance\': <method \'NewInstance\' of \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver\' objects>, \'GetNumberOfGenerationsFromBaseType\': <method \'GetNumberOfGenerationsFromBaseType\' of \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver\' objects>, \'GetNumberOfGenerationsFromBase\': <method \'GetNumberOfGenerationsFromBase\' of \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver\' objects>, \'ComputeNextStep\': <method \'ComputeNextStep\' of \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver\' objects>, \'SetFunctionSet\': <method \'SetFunctionSet\' of \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver\' objects>, \'GetFunctionSet\': <method \'GetFunctionSet\' of \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver\' objects>, \'IsAdaptive\': <method \'IsAdaptive\' of \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver\' objects>, \'ErrorCodes\': <class \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver.ErrorCodes\'>, \'OUT_OF_DOMAIN\': 1, \'NOT_INITIALIZED\': 2, \'UNEXPECTED_VALUE\': 3, \'__new__\': <built-in method __new__ of type object at 0x00007FF85F056560>, \'__repr__\': <slot wrapper \'__repr__\' of \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver\' objects>, \'__str__\': <slot wrapper \'__str__\' of \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver\' objects>, \'__getattribute__\': <slot wrapper \'__getattribute__\' of \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver\' objects>, \'__setattr__\': <slot wrapper \'__setattr__\' of \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver\' objects>, \'__delattr__\': <slot wrapper \'__delattr__\' of \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver\' objects>, \'__dict__\': <attribute \'__dict__\' of \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver\' objects>, \'__this__\': <attribute \'__this__\' of \'vtkmodules.vtkCommonMath.vtkInitialValueProblemSolver\' objects>, \'__doc__\': "vtkInitialValueProblemSolver - Integrate a set of ordinary\\ndifferential equations (initial value problem) in time.\\n\\nSuperclass: vtkObject\\n\\nGiven a vtkFunctionSet which returns dF_i(x_j, t)/dt given x_j and t,\\nvtkInitialValueProblemSolver computes the value of F_i at t+deltat.\\n\\n@warning\\nvtkInitialValueProblemSolver and it\'s subclasses are not thread-safe.\\nYou should create a new integrator for each thread.\\n\\n@sa\\nvtkRungeKutta2 vtkRungeKutta4\\n\\n"})'
    __vtkname__ = 'vtkInitialValueProblemSolver'


class vtkMatrix3x3(__vtkmodules_vtkCommonCore.vtkObject):
    """
    vtkMatrix3x3 - represent and manipulate 3x3 transformation matrices
    
    Superclass: vtkObject
    
    vtkMatrix3x3 is a class to represent and manipulate 3x3 matrices.
    Specifically, it is designed to work on 3x3 transformation matrices
    found in 2D rendering using homogeneous coordinates [x y w].
    
    @sa
    vtkTransform2D
    """
    def Adjoint(self, in_, out): # real signature unknown; restored from __doc__
        """
        Adjoint(self, in_:vtkMatrix3x3, out:vtkMatrix3x3) -> None
        C++: void Adjoint(vtkMatrix3x3 *in, vtkMatrix3x3 *out)
        Adjoint(inElements:(float, float, float, float, float, float,
            float, float, float), outElements:[float, float, float, float,
             float, float, float, float, float]) -> None
        C++: static void Adjoint(const double inElements[9],
            double outElements[9])
        
        Compute adjoint of the matrix and put it into out.
        """
        pass

    def DeepCopy(self, source): # real signature unknown; restored from __doc__
        """
        DeepCopy(self, source:vtkMatrix3x3) -> None
        C++: void DeepCopy(vtkMatrix3x3 *source)
        DeepCopy(elements:[float, float, float, float, float, float,
            float, float, float], source:vtkMatrix3x3) -> None
        C++: static void DeepCopy(double elements[9],
            vtkMatrix3x3 *source)
        DeepCopy(elements:[float, float, float, float, float, float,
            float, float, float], newElements:(float, float, float, float,
             float, float, float, float, float)) -> None
        C++: static void DeepCopy(double elements[9],
            const double newElements[9])
        DeepCopy(self, elements:(float, float, float, float, float, float,
             float, float, float)) -> None
        C++: void DeepCopy(const double elements[9])
        
        Set the elements of the matrix to the same values as the elements
        of the source Matrix.
        """
        pass

    def Determinant(self): # real signature unknown; restored from __doc__
        """
        Determinant(self) -> float
        C++: double Determinant()
        Determinant(elements:(float, float, float, float, float, float,
            float, float, float)) -> float
        C++: static double Determinant(const double elements[9])
        
        Compute the determinant of the matrix and return it.
        """
        return 0.0

    def GetData(self): # real signature unknown; restored from __doc__
        """
        GetData(self) -> (float, float, float, float, float, float, float,
             float, float)
        C++: double *GetData()
        
        Return a pointer to the first element of the matrix (double[9]).
        """
        pass

    def GetElement(self, i, j): # real signature unknown; restored from __doc__
        """
        GetElement(self, i:int, j:int) -> float
        C++: double GetElement(int i, int j)
        
        Returns the element i,j from the matrix.
        """
        return 0.0

    def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBase(self, type:str) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given 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.
        """
        return 0

    def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBaseType(type:str) -> 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.
        """
        return 0

    def Identity(self): # real signature unknown; restored from __doc__
        """
        Identity(self) -> None
        C++: void Identity()
        Identity(elements:[float, float, float, float, float, float,
            float, float, float]) -> None
        C++: static void Identity(double elements[9])
        
        Set equal to Identity matrix
        """
        pass

    def Invert(self, in_, out): # real signature unknown; restored from __doc__
        """
        Invert(in_:vtkMatrix3x3, out:vtkMatrix3x3) -> None
        C++: static void Invert(vtkMatrix3x3 *in, vtkMatrix3x3 *out)
        Invert(self) -> None
        C++: void Invert()
        Invert(inElements:(float, float, float, float, float, float,
            float, float, float), outElements:[float, float, float, float,
             float, float, float, float, float]) -> None
        C++: static void Invert(const double inElements[9],
            double outElements[9])
        
        Matrix Inversion (adapted from Richard Carling in "Graphics
        Gems," Academic Press, 1990).
        """
        pass

    def IsA(self, type): # real signature unknown; restored from __doc__
        """
        IsA(self, type:str) -> 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.
        """
        return 0

    def IsIdentity(self): # real signature unknown; restored from __doc__
        """
        IsIdentity(self) -> bool
        C++: bool IsIdentity()
        """
        return False

    def IsTypeOf(self, type): # real signature unknown; restored from __doc__
        """
        IsTypeOf(type:str) -> 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.
        """
        return 0

    def Multiply3x3(self, a, b, c): # real signature unknown; restored from __doc__
        """
        Multiply3x3(a:vtkMatrix3x3, b:vtkMatrix3x3, c:vtkMatrix3x3)
            -> None
        C++: static void Multiply3x3(vtkMatrix3x3 *a, vtkMatrix3x3 *b,
            vtkMatrix3x3 *c)
        Multiply3x3(a:(float, float, float, float, float, float, float,
            float, float), b:(float, float, float, float, float, float,
            float, float, float), c:[float, float, float, float, float,
            float, float, float, float]) -> None
        C++: static void Multiply3x3(const double a[9], const double b[9],
             double c[9])
        
        Multiplies matrices a and b and stores the result in c (c=a*b).
        """
        pass

    def MultiplyPoint(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        MultiplyPoint(self, in_:(float, float, float), out:[float, float,
            float]) -> None
        C++: void MultiplyPoint(const double in[3], double out[3])
        MultiplyPoint(elements:(float, float, float, float, float, float,
            float, float, float), in_:(float, float, float), out:[float,
            float, float]) -> None
        C++: static void MultiplyPoint(const double elements[9],
            const double in[3], double out[3])
        """
        pass

    def NewInstance(self): # real signature unknown; restored from __doc__
        """
        NewInstance(self) -> vtkMatrix3x3
        C++: vtkMatrix3x3 *NewInstance()
        """
        return vtkMatrix3x3

    def SafeDownCast(self, o): # real signature unknown; restored from __doc__
        """
        SafeDownCast(o:vtkObjectBase) -> vtkMatrix3x3
        C++: static vtkMatrix3x3 *SafeDownCast(vtkObjectBase *o)
        """
        return vtkMatrix3x3

    def SetElement(self, i, j, value): # real signature unknown; restored from __doc__
        """
        SetElement(self, i:int, j:int, value:float) -> None
        C++: void SetElement(int i, int j, double value)
        
        Sets the element i,j in the matrix.
        """
        pass

    def Transpose(self, in_, out): # real signature unknown; restored from __doc__
        """
        Transpose(in_:vtkMatrix3x3, out:vtkMatrix3x3) -> None
        C++: static void Transpose(vtkMatrix3x3 *in, vtkMatrix3x3 *out)
        Transpose(self) -> None
        C++: void Transpose()
        Transpose(inElements:(float, float, float, float, float, float,
            float, float, float), outElements:[float, float, float, float,
             float, float, float, float, float]) -> None
        C++: static void Transpose(const double inElements[9],
            double outElements[9])
        
        Transpose the matrix and put it into out.
        """
        pass

    def Zero(self): # real signature unknown; restored from __doc__
        """
        Zero(self) -> None
        C++: void Zero()
        Zero(elements:[float, float, float, float, float, float, float,
            float, float]) -> None
        C++: static void Zero(double elements[9])
        
        Set all of the elements to zero.
        """
        pass

    def __delattr__(self, *args, **kwargs): # real signature unknown
        """ Implement delattr(self, name). """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setattr__(self, *args, **kwargs): # real signature unknown
        """ Implement setattr(self, name, value). """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass

    __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Pointer to the C++ object."""


    __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkMatrix3x3', 'IsTypeOf': <method 'IsTypeOf' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'IsA': <method 'IsA' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'SafeDownCast': <method 'SafeDownCast' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'NewInstance': <method 'NewInstance' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'GetNumberOfGenerationsFromBaseType': <method 'GetNumberOfGenerationsFromBaseType' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'GetNumberOfGenerationsFromBase': <method 'GetNumberOfGenerationsFromBase' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'DeepCopy': <method 'DeepCopy' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'Zero': <method 'Zero' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'Identity': <method 'Identity' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'Invert': <method 'Invert' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'Transpose': <method 'Transpose' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'MultiplyPoint': <method 'MultiplyPoint' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'Multiply3x3': <method 'Multiply3x3' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'Adjoint': <method 'Adjoint' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'Determinant': <method 'Determinant' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'SetElement': <method 'SetElement' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'GetElement': <method 'GetElement' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'IsIdentity': <method 'IsIdentity' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, 'GetData': <method 'GetData' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, '__new__': <built-in method __new__ of type object at 0x00007FF85F056BB0>, '__repr__': <slot wrapper '__repr__' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, '__str__': <slot wrapper '__str__' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, '__setattr__': <slot wrapper '__setattr__' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, '__delattr__': <slot wrapper '__delattr__' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, '__dict__': <attribute '__dict__' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, '__this__': <attribute '__this__' of 'vtkmodules.vtkCommonMath.vtkMatrix3x3' objects>, '__doc__': 'vtkMatrix3x3 - represent and manipulate 3x3 transformation matrices\\n\\nSuperclass: vtkObject\\n\\nvtkMatrix3x3 is a class to represent and manipulate 3x3 matrices.\\nSpecifically, it is designed to work on 3x3 transformation matrices\\nfound in 2D rendering using homogeneous coordinates [x y w].\\n\\n@sa\\nvtkTransform2D\\n\\n'})"
    __vtkname__ = 'vtkMatrix3x3'


class vtkMatrix4x4(__vtkmodules_vtkCommonCore.vtkObject):
    """
    vtkMatrix4x4 - represent and manipulate 4x4 transformation matrices
    
    Superclass: vtkObject
    
    vtkMatrix4x4 is a class to represent and manipulate 4x4 matrices.
    Specifically, it is designed to work on 4x4 transformation matrices
    found in 3D rendering using homogeneous coordinates [x y z w]. Many
    of the methods take an array of 16 doubles in row-major format. Note
    that OpenGL stores matrices in column-major format, so the matrix
    contents must be transposed when they are moved between OpenGL and
    VTK.
    @sa
    vtkTransform
    """
    def Adjoint(self, in_, out): # real signature unknown; restored from __doc__
        """
        Adjoint(self, in_:vtkMatrix4x4, out:vtkMatrix4x4) -> None
        C++: void Adjoint(const vtkMatrix4x4 *in, vtkMatrix4x4 *out)
        Adjoint(inElements:(float, float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float), outElements:[float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float, float]) -> None
        C++: static void Adjoint(const double inElements[16],
            double outElements[16])
        
        Compute adjoint of the matrix and put it into out.
        """
        pass

    def DeepCopy(self, source): # real signature unknown; restored from __doc__
        """
        DeepCopy(self, source:vtkMatrix4x4) -> None
        C++: void DeepCopy(const vtkMatrix4x4 *source)
        DeepCopy(destination:[float, float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float], source:vtkMatrix4x4) -> None
        C++: static void DeepCopy(double destination[16],
            const vtkMatrix4x4 *source)
        DeepCopy(destination:[float, float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float], source:(float, float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float)) -> None
        C++: static void DeepCopy(double destination[16],
            const double source[16])
        DeepCopy(self, elements:(float, float, float, float, float, float,
             float, float, float, float, float, float, float, float,
            float, float)) -> None
        C++: void DeepCopy(const double elements[16])
        
        Set the elements of the matrix to the same values as the elements
        of the given source matrix.
        """
        pass

    def Determinant(self): # real signature unknown; restored from __doc__
        """
        Determinant(self) -> float
        C++: double Determinant()
        Determinant(elements:(float, float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float)) -> float
        C++: static double Determinant(const double elements[16])
        
        Compute the determinant of the matrix and return it.
        """
        return 0.0

    def GetData(self): # real signature unknown; restored from __doc__
        """
        GetData(self) -> Pointer
        C++: double *GetData()
        
        Returns the raw double array holding the matrix.
        """
        pass

    def GetElement(self, i, j): # real signature unknown; restored from __doc__
        """
        GetElement(self, i:int, j:int) -> float
        C++: double GetElement(int i, int j)
        
        Returns the element i,j from the matrix.
        """
        return 0.0

    def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBase(self, type:str) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given 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.
        """
        return 0

    def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBaseType(type:str) -> 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.
        """
        return 0

    def Identity(self): # real signature unknown; restored from __doc__
        """
        Identity(self) -> None
        C++: void Identity()
        Identity(elements:[float, float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float]) -> None
        C++: static void Identity(double elements[16])
        
        Set equal to Identity matrix
        """
        pass

    def Invert(self, in_, out): # real signature unknown; restored from __doc__
        """
        Invert(in_:vtkMatrix4x4, out:vtkMatrix4x4) -> None
        C++: static void Invert(const vtkMatrix4x4 *in, vtkMatrix4x4 *out)
        Invert(self) -> None
        C++: void Invert()
        Invert(inElements:(float, float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float), outElements:[float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float, float]) -> None
        C++: static void Invert(const double inElements[16],
            double outElements[16])
        
        Matrix Inversion (adapted from Richard Carling in "Graphics
        Gems," Academic Press, 1990).
        """
        pass

    def IsA(self, type): # real signature unknown; restored from __doc__
        """
        IsA(self, type:str) -> 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.
        """
        return 0

    def IsIdentity(self): # real signature unknown; restored from __doc__
        """
        IsIdentity(self) -> bool
        C++: bool IsIdentity()
        
        Returns true if this matrix is equal to the identity matrix.
        """
        return False

    def IsTypeOf(self, type): # real signature unknown; restored from __doc__
        """
        IsTypeOf(type:str) -> 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.
        """
        return 0

    def MatrixFromRotation(self, angle, x, y, z, result): # real signature unknown; restored from __doc__
        """
        MatrixFromRotation(angle:float, x:float, y:float, z:float,
            result:vtkMatrix4x4) -> None
        C++: static void MatrixFromRotation(double angle, double x,
            double y, double z, vtkMatrix4x4 *result)
        MatrixFromRotation(angle:float, x:float, y:float, z:float,
            matrix:[float, float, float, float, float, float, float,
            float, float, float, float, float, float, float, float,
            float]) -> None
        C++: static void MatrixFromRotation(double angle, double x,
            double y, double z, double matrix[16])
        
        Construct a matrix from a rotation
        """
        pass

    def Multiply4x4(self, a, b, c): # real signature unknown; restored from __doc__
        """
        Multiply4x4(a:vtkMatrix4x4, b:vtkMatrix4x4, c:vtkMatrix4x4)
            -> None
        C++: static void Multiply4x4(const vtkMatrix4x4 *a,
            const vtkMatrix4x4 *b, vtkMatrix4x4 *c)
        Multiply4x4(a:(float, float, float, float, float, float, float,
            float, float, float, float, float, float, float, float, float)
            , b:(float, float, float, float, float, float, float, float,
            float, float, float, float, float, float, float, float),
            c:[float, float, float, float, float, float, float, float,
            float, float, float, float, float, float, float, float])
            -> None
        C++: static void Multiply4x4(const double a[16],
            const double b[16], double c[16])
        
        Multiplies matrices a and b and stores the result in c.
        """
        pass

    def MultiplyAndTranspose4x4(self, a, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        MultiplyAndTranspose4x4(a:(float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float, float), b:(float, float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float), c:[float, float, float, float, float, float, float,
            float, float, float, float, float, float, float, float,
            float]) -> None
        C++: static void MultiplyAndTranspose4x4(const double a[16],
            const double b[16], float c[16])
        """
        pass

    def MultiplyDoublePoint(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        MultiplyDoublePoint(self, in_:(float, float, float, float)) -> (
            float, float, float, float)
        C++: double *MultiplyDoublePoint(const double in[4])
        """
        pass

    def MultiplyFloatPoint(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        MultiplyFloatPoint(self, in_:(float, float, float, float)) -> (
            float, float, float, float)
        C++: float *MultiplyFloatPoint(const float in[4])
        """
        pass

    def MultiplyPoint(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        MultiplyPoint(self, in_:(float, float, float, float), out:[float,
            float, float, float]) -> None
        C++: void MultiplyPoint(const double in[4], double out[4])
        MultiplyPoint(elements:(float, float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float), in_:(float, float, float, float), out:[float, float,
            float, float]) -> None
        C++: static void MultiplyPoint(const double elements[16],
            const double in[4], double out[4])
        MultiplyPoint(self, in_:(float, float, float, float)) -> (float,
            float, float, float)
        C++: double *MultiplyPoint(const double in[4])
        """
        pass

    def NewInstance(self): # real signature unknown; restored from __doc__
        """
        NewInstance(self) -> vtkMatrix4x4
        C++: vtkMatrix4x4 *NewInstance()
        """
        return vtkMatrix4x4

    def PoseToMatrix(self, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        PoseToMatrix(pos:[float, float, float], ori:[float, float, float,
            float], mat:vtkMatrix4x4) -> None
        C++: static void PoseToMatrix(double pos[3], double ori[4],
            vtkMatrix4x4 *mat)
        
        Given an orientation and position this function will fill in a
        matrix representing the transformation from the pose to whatever
        space the pose was defined in. For example if the position and
        orientation are in world coordinates then this method would set
        the matrix to be PoseToWorld
        """
        pass

    def SafeDownCast(self, o): # real signature unknown; restored from __doc__
        """
        SafeDownCast(o:vtkObjectBase) -> vtkMatrix4x4
        C++: static vtkMatrix4x4 *SafeDownCast(vtkObjectBase *o)
        """
        return vtkMatrix4x4

    def SetElement(self, i, j, value): # real signature unknown; restored from __doc__
        """
        SetElement(self, i:int, j:int, value:float) -> None
        C++: void SetElement(int i, int j, double value)
        
        Sets the element i,j in the matrix.
        """
        pass

    def Transpose(self, in_, out): # real signature unknown; restored from __doc__
        """
        Transpose(in_:vtkMatrix4x4, out:vtkMatrix4x4) -> None
        C++: static void Transpose(const vtkMatrix4x4 *in,
            vtkMatrix4x4 *out)
        Transpose(self) -> None
        C++: void Transpose()
        Transpose(inElements:(float, float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float), outElements:[float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float, float]) -> None
        C++: static void Transpose(const double inElements[16],
            double outElements[16])
        
        Transpose the matrix and put it into out.
        """
        pass

    def Zero(self): # real signature unknown; restored from __doc__
        """
        Zero(self) -> None
        C++: void Zero()
        Zero(elements:[float, float, float, float, float, float, float,
            float, float, float, float, float, float, float, float,
            float]) -> None
        C++: static void Zero(double elements[16])
        
        Set all of the elements to zero.
        """
        pass

    def __delattr__(self, *args, **kwargs): # real signature unknown
        """ Implement delattr(self, name). """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setattr__(self, *args, **kwargs): # real signature unknown
        """ Implement setattr(self, name, value). """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass

    __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Pointer to the C++ object."""


    __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkMatrix4x4', 'IsTypeOf': <method 'IsTypeOf' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'IsA': <method 'IsA' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'SafeDownCast': <method 'SafeDownCast' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'NewInstance': <method 'NewInstance' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'GetNumberOfGenerationsFromBaseType': <method 'GetNumberOfGenerationsFromBaseType' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'GetNumberOfGenerationsFromBase': <method 'GetNumberOfGenerationsFromBase' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'DeepCopy': <method 'DeepCopy' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'Zero': <method 'Zero' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'Identity': <method 'Identity' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'IsIdentity': <method 'IsIdentity' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'Invert': <method 'Invert' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'Transpose': <method 'Transpose' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'MatrixFromRotation': <method 'MatrixFromRotation' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'PoseToMatrix': <method 'PoseToMatrix' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'MultiplyPoint': <method 'MultiplyPoint' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'MultiplyFloatPoint': <method 'MultiplyFloatPoint' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'MultiplyDoublePoint': <method 'MultiplyDoublePoint' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'Multiply4x4': <method 'Multiply4x4' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'MultiplyAndTranspose4x4': <method 'MultiplyAndTranspose4x4' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'Adjoint': <method 'Adjoint' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'Determinant': <method 'Determinant' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'SetElement': <method 'SetElement' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'GetElement': <method 'GetElement' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, 'GetData': <method 'GetData' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, '__new__': <built-in method __new__ of type object at 0x00007FF85F057360>, '__repr__': <slot wrapper '__repr__' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, '__str__': <slot wrapper '__str__' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, '__setattr__': <slot wrapper '__setattr__' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, '__delattr__': <slot wrapper '__delattr__' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, '__dict__': <attribute '__dict__' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, '__this__': <attribute '__this__' of 'vtkmodules.vtkCommonMath.vtkMatrix4x4' objects>, '__doc__': 'vtkMatrix4x4 - represent and manipulate 4x4 transformation matrices\\n\\nSuperclass: vtkObject\\n\\nvtkMatrix4x4 is a class to represent and manipulate 4x4 matrices.\\nSpecifically, it is designed to work on 4x4 transformation matrices\\nfound in 3D rendering using homogeneous coordinates [x y z w]. Many\\nof the methods take an array of 16 doubles in row-major format. Note\\nthat OpenGL stores matrices in column-major format, so the matrix\\ncontents must be transposed when they are moved between OpenGL and\\nVTK.\\n@sa\\nvtkTransform\\n\\n'})"
    __vtkname__ = 'vtkMatrix4x4'


class vtkPolynomialSolversUnivariate(__vtkmodules_vtkCommonCore.vtkObject):
    """
    vtkPolynomialSolversUnivariate - polynomial solvers
    
    Superclass: vtkObject
    
    vtkPolynomialSolversUnivariate provides solvers for univariate
    polynomial equations with real coefficients. The Tartaglia-Cardan and
    Ferrari solvers work on polynomials of fixed degree 3 and 4,
    respectively. The Lin-Bairstow and Sturm solvers work on polynomials
    of arbitrary degree. The Sturm solver is the most robust solver but
    only reports roots within an interval and does not report
    multiplicities. The Lin-Bairstow solver reports multiplicities.
    
    For difficult polynomials, you may wish to use FilterRoots to
    eliminate some of the roots reported by the Sturm solver. FilterRoots
    evaluates the derivatives near each root to eliminate cases where a
    local minimum or maximum is close to zero.
    
    @par Thanks: Thanks to Philippe Pebay, Korben Rusek, David Thompson,
    and Maurice Rojas for implementing these solvers.
    """
    def FerrariSolve(self, c, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        FerrariSolve(c:[float, ...], r:[float, ...], m:[int, ...],
            tol:float) -> int
        C++: static int FerrariSolve(double *c, double *r, int *m,
            double tol)
        
        Algebraically extracts REAL roots of the quartic polynomial with
        REAL coefficients X^4 + c[0] X^3 + c[1] X^2 + c[2] X + c[3] and
        stores them (when they exist) and their respective multiplicities
        in the r and m arrays, based on Ferrari's method. Some numerical
        noise can be filtered by the use of a tolerance tol instead of
        equality with 0 (one can use, e.g., VTK_DBL_EPSILON). Returns the
        number of roots. Warning: it is the user's responsibility to pass
        a non-negative tol.
        """
        pass

    def FilterRoots(self, P, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        FilterRoots(P:[float, ...], d:int, upperBnds:[float, ...],
            rootcount:int, diameter:float) -> int
        C++: static int FilterRoots(double *P, int d, double *upperBnds,
            int rootcount, double diameter)
        
        This uses the derivative sequence to filter possible roots of a
        polynomial. First it sorts the roots and removes any duplicates.
        If the number of sign changes of the derivative sequence at a
        root at upperBnds[i] == that at upperBnds[i]  - diameter then the
        i^th value is removed from upperBnds. It returns the new number
        of roots.
        """
        pass

    def GetDivisionTolerance(self): # real signature unknown; restored from __doc__
        """
        GetDivisionTolerance() -> float
        C++: static double GetDivisionTolerance()
        """
        return 0.0

    def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBase(self, type:str) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given 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.
        """
        return 0

    def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBaseType(type:str) -> 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.
        """
        return 0

    def HabichtBisectionSolve(self, P, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        HabichtBisectionSolve(P:[float, ...], d:int, a:[float, ...],
            upperBnds:[float, ...], tol:float) -> int
        C++: static int HabichtBisectionSolve(double *P, int d, double *a,
             double *upperBnds, double tol)
        HabichtBisectionSolve(P:[float, ...], d:int, a:[float, ...],
            upperBnds:[float, ...], tol:float, intervalType:int) -> int
        C++: static int HabichtBisectionSolve(double *P, int d, double *a,
             double *upperBnds, double tol, int intervalType)
        HabichtBisectionSolve(P:[float, ...], d:int, a:[float, ...],
            upperBnds:[float, ...], tol:float, intervalType:int,
            divideGCD:bool) -> int
        C++: static int HabichtBisectionSolve(double *P, int d, double *a,
             double *upperBnds, double tol, int intervalType,
            bool divideGCD)
        
        Finds all REAL roots (within tolerance tol) of the d -th degree
        polynomial\[ P[0] X^d + ... + P[d-1] X + P[d]\] in ] a[0] ; a[1]]
        using the Habicht sequence (polynomial coefficients are REAL) and
        returns the count nr. All roots are bracketed in the nr first ]
        upperBnds[i] - tol ; upperBnds[i]] intervals. Returns -1 if
        anything went wrong (such as: polynomial does not have degree d,
        the interval provided by the other is absurd, etc.).
        
        * intervalType specifies the search interval as follows:
        * 0 = 00 = ]a,b[
        * 1 = 10 = [a,b[
        * 2 = 01 = ]a,b]
        * 3 = 11 = [a,b]
        * This defaults to 0.
        
        * The last non-zero item in the Habicht sequence is the gcd of P
          and P'. The
        * parameter divideGCD specifies whether the program should
          attempt to divide
        * by the gcd and run again. It works better with polynomials
          known to have
        * high multiplicities. When divideGCD != 0 then it attempts to
          divide by the
        * GCD, if applicable. This defaults to 0.
        
        * Compared to the Sturm solver the Habicht solver is slower,
        * although both are O(d^2). The Habicht solver has the added
          benefit
        * that it has a built in mechanism to keep the leading
          coefficients of the
        * result from polynomial division bounded above and below in
          absolute value. ...
         [Truncated]
        """
        pass

    def IsA(self, type): # real signature unknown; restored from __doc__
        """
        IsA(self, type:str) -> 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.
        """
        return 0

    def IsTypeOf(self, type): # real signature unknown; restored from __doc__
        """
        IsTypeOf(type:str) -> 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.
        """
        return 0

    def LinBairstowSolve(self, c, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        LinBairstowSolve(c:[float, ...], d:int, r:[float, ...],
            tolerance:float) -> int
        C++: static int LinBairstowSolve(double *c, int d, double *r,
            double &tolerance)
        
        Seeks all REAL roots of the d -th degree polynomial c[0] X^d +
        ... + c[d-1] X + c[d] = 0 equation Lin-Bairstow's method (
        polynomial coefficients are REAL ) and stores the nr roots found
        ( multiple roots are multiply stored ) in r.tolerance is the
        user-defined solver tolerance; this variable may be relaxed by
        the iterative solver if needed. Returns nr. Warning: it is the
        user's responsibility to make sure the r array is large enough to
        contain the maximal number of expected roots.
        """
        pass

    def NewInstance(self): # real signature unknown; restored from __doc__
        """
        NewInstance(self) -> vtkPolynomialSolversUnivariate
        C++: vtkPolynomialSolversUnivariate *NewInstance()
        """
        return vtkPolynomialSolversUnivariate

    def SafeDownCast(self, o): # real signature unknown; restored from __doc__
        """
        SafeDownCast(o:vtkObjectBase) -> vtkPolynomialSolversUnivariate
        C++: static vtkPolynomialSolversUnivariate *SafeDownCast(
            vtkObjectBase *o)
        """
        return vtkPolynomialSolversUnivariate

    def SetDivisionTolerance(self, tol): # real signature unknown; restored from __doc__
        """
        SetDivisionTolerance(tol:float) -> None
        C++: static void SetDivisionTolerance(double tol)
        
        Set/get the tolerance used when performing polynomial Euclidean
        division to find polynomial roots. This tolerance is used to
        decide whether the coefficient(s) of a polynomial remainder are
        close enough to zero to be neglected.
        """
        pass

    def SolveCubic(self, c0, c1, c2, c3): # real signature unknown; restored from __doc__
        """
        SolveCubic(c0:float, c1:float, c2:float, c3:float) -> Pointer
        C++: static double *SolveCubic(double c0, double c1, double c2,
            double c3)
        SolveCubic(c0:float, c1:float, c2:float, c3:float, r1:[float,
            ...], r2:[float, ...], r3:[float, ...], num_roots:[int, ...])
            -> int
        C++: static int SolveCubic(double c0, double c1, double c2,
            double c3, double *r1, double *r2, double *r3, int *num_roots)
        
        Solves a cubic equation c0*t^3 + c1*t^2 + c2*t + c3 = 0 when c0,
        c1, c2, and c3 are REAL.  Solution is motivated by Numerical
        Recipes In C 2nd Ed.  Return array contains number of (real)
        roots (counting multiple roots as one) followed by roots
        themselves. The value in roots[4] is a integer giving further
        information about the roots (see return codes for int
        SolveCubic() ).
        """
        pass

    def SolveLinear(self, c0, c1): # real signature unknown; restored from __doc__
        """
        SolveLinear(c0:float, c1:float) -> Pointer
        C++: static double *SolveLinear(double c0, double c1)
        SolveLinear(c0:float, c1:float, r1:[float, ...], num_roots:[int,
            ...]) -> int
        C++: static int SolveLinear(double c0, double c1, double *r1,
            int *num_roots)
        
        Solves a linear equation c0*t  + c1 = 0 when c0 and c1 are REAL.
        Solution is motivated by Numerical Recipes In C 2nd Ed. Return
        array contains number of roots followed by roots themselves.
        """
        pass

    def SolveQuadratic(self, c0, c1, c2): # real signature unknown; restored from __doc__
        """
        SolveQuadratic(c0:float, c1:float, c2:float) -> Pointer
        C++: static double *SolveQuadratic(double c0, double c1,
            double c2)
        SolveQuadratic(c0:float, c1:float, c2:float, r1:[float, ...],
            r2:[float, ...], num_roots:[int, ...]) -> int
        C++: static int SolveQuadratic(double c0, double c1, double c2,
            double *r1, double *r2, int *num_roots)
        SolveQuadratic(c:[float, ...], r:[float, ...], m:[int, ...])
            -> int
        C++: static int SolveQuadratic(double *c, double *r, int *m)
        
        Solves a quadratic equation c0*t^2 + c1*t + c2 = 0 when c0, c1,
        and c2 are REAL.  Solution is motivated by Numerical Recipes In C
        2nd Ed. Return array contains number of (real) roots (counting
        multiple roots as one) followed by roots themselves. Note that
        roots[3] contains a return code further describing solution - see
        documentation for SolveCubic() for meaning of return codes.
        """
        pass

    def SturmBisectionSolve(self, P, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        SturmBisectionSolve(P:[float, ...], d:int, a:[float, ...],
            upperBnds:[float, ...], tol:float) -> int
        C++: static int SturmBisectionSolve(double *P, int d, double *a,
            double *upperBnds, double tol)
        SturmBisectionSolve(P:[float, ...], d:int, a:[float, ...],
            upperBnds:[float, ...], tol:float, intervalType:int) -> int
        C++: static int SturmBisectionSolve(double *P, int d, double *a,
            double *upperBnds, double tol, int intervalType)
        SturmBisectionSolve(P:[float, ...], d:int, a:[float, ...],
            upperBnds:[float, ...], tol:float, intervalType:int,
            divideGCD:bool) -> int
        C++: static int SturmBisectionSolve(double *P, int d, double *a,
            double *upperBnds, double tol, int intervalType,
            bool divideGCD)
        
        Finds all REAL roots (within tolerance tol) of the d -th degree
        polynomial P[0] X^d + ... + P[d-1] X + P[d] in ] a[0] ; a[1]]
        using Sturm's theorem ( polynomial coefficients are REAL ) and
        returns the count nr. All roots are bracketed in the nr first ]
        upperBnds[i] - tol ; upperBnds[i]] intervals. Returns -1 if
        anything went wrong (such as: polynomial does not have degree d,
        the interval provided by the other is absurd, etc.).
        
        * intervalType specifies the search interval as follows:
        * 0 = 00 = ]a,b[
        * 1 = 10 = [a,b[
        * 2 = 01 = ]a,b]
        * 3 = 11 = [a,b]
        * This defaults to 0.
        
        * The last non-zero item in the Sturm sequence is the gcd of P
          and P'. The
        * parameter divideGCD specifies whether the program should
          attempt to divide
        * by the gcd and run again. It works better with polynomials
          known to have
        * high multiplicities. When divideGCD != 0 then it attempts to
          divide by the
        * GCD, if applicable. This defaults to 0.
        
        * Constructing the Sturm sequence is O(d^2) in both time and
          space.
        
        * Warning: it is the user's responsibility to make sure the
          upperBnds
        * array is large enough to contain the maximal number of expected
        roots.
        * Note that nr is smaller or equal to the actual number of roots
          in
        * ] a[0] ; a[1]] since ro ...
         [Truncated]
        """
        pass

    def TartagliaCardanSolve(self, c, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        TartagliaCardanSolve(c:[float, ...], r:[float, ...], m:[int, ...],
             tol:float) -> int
        C++: static int TartagliaCardanSolve(double *c, double *r, int *m,
             double tol)
        
        Algebraically extracts REAL roots of the cubic polynomial with
        REAL coefficients X^3 + c[0] X^2 + c[1] X + c[2] and stores them
        (when they exist) and their respective multiplicities in the r
        and m arrays. Some numerical noise can be filtered by the use of
        a tolerance tol instead of equality with 0 (one can use, e.g.,
        VTK_DBL_EPSILON). The main differences with SolveCubic are that
        (1) the polynomial must have unit leading coefficient, (2)
        complex roots are discarded upfront, (3) non-simple roots are
        stored only once, along with their respective multiplicities, and
        (4) some numerical noise is filtered by the use of relative
        tolerance instead of equality with 0. Returns the number of
        roots. In memoriam Niccolo Tartaglia (1500 - 1559), unfairly
        forgotten.
        """
        pass

    def __delattr__(self, *args, **kwargs): # real signature unknown
        """ Implement delattr(self, name). """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setattr__(self, *args, **kwargs): # real signature unknown
        """ Implement setattr(self, name, value). """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass

    __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Pointer to the C++ object."""


    __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkPolynomialSolversUnivariate', 'IsTypeOf': <method 'IsTypeOf' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, 'IsA': <method 'IsA' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, 'SafeDownCast': <method 'SafeDownCast' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, 'NewInstance': <method 'NewInstance' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, 'GetNumberOfGenerationsFromBaseType': <method 'GetNumberOfGenerationsFromBaseType' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, 'GetNumberOfGenerationsFromBase': <method 'GetNumberOfGenerationsFromBase' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, 'HabichtBisectionSolve': <method 'HabichtBisectionSolve' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, 'SturmBisectionSolve': <method 'SturmBisectionSolve' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, 'FilterRoots': <method 'FilterRoots' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, 'LinBairstowSolve': <method 'LinBairstowSolve' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, 'FerrariSolve': <method 'FerrariSolve' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, 'TartagliaCardanSolve': <method 'TartagliaCardanSolve' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, 'SolveCubic': <method 'SolveCubic' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, 'SolveQuadratic': <method 'SolveQuadratic' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, 'SolveLinear': <method 'SolveLinear' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, 'SetDivisionTolerance': <method 'SetDivisionTolerance' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, 'GetDivisionTolerance': <method 'GetDivisionTolerance' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, '__new__': <built-in method __new__ of type object at 0x00007FF85F0577B0>, '__repr__': <slot wrapper '__repr__' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, '__str__': <slot wrapper '__str__' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, '__setattr__': <slot wrapper '__setattr__' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, '__delattr__': <slot wrapper '__delattr__' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, '__dict__': <attribute '__dict__' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, '__this__': <attribute '__this__' of 'vtkmodules.vtkCommonMath.vtkPolynomialSolversUnivariate' objects>, '__doc__': 'vtkPolynomialSolversUnivariate - polynomial solvers\\n\\nSuperclass: vtkObject\\n\\nvtkPolynomialSolversUnivariate provides solvers for univariate\\npolynomial equations with real coefficients. The Tartaglia-Cardan and\\nFerrari solvers work on polynomials of fixed degree 3 and 4,\\nrespectively. The Lin-Bairstow and Sturm solvers work on polynomials\\nof arbitrary degree. The Sturm solver is the most robust solver but\\nonly reports roots within an interval and does not report\\nmultiplicities. The Lin-Bairstow solver reports multiplicities.\\n\\nFor difficult polynomials, you may wish to use FilterRoots to\\neliminate some of the roots reported by the Sturm solver. FilterRoots\\nevaluates the derivatives near each root to eliminate cases where a\\nlocal minimum or maximum is close to zero.\\n\\n@par Thanks: Thanks to Philippe Pebay, Korben Rusek, David Thompson,\\nand Maurice Rojas for implementing these solvers.\\n\\n'})"
    __vtkname__ = 'vtkPolynomialSolversUnivariate'


class vtkTuple_IdLi4EE(object):
    """
    vtkTuple() -> vtkTuple
    C++: vtkTuple()
    vtkTuple(scalar:float) -> vtkTuple
    C++: explicit vtkTuple(const double &scalar)
    vtkTuple(init:(float, float, float, float)) -> vtkTuple
    C++: explicit vtkTuple(const double *init)
    vtkTuple(__a:vtkTuple_IdLi4EE) -> vtkTuple
    C++: vtkTuple(const &vtkTuple<double, 4>)
    
    vtkTuple<double, 4> - templated base type for containers of constant
    size.
    
    This class is a templated data type for storing and manipulating
    tuples.
    """
    def Compare(self, other, tol): # real signature unknown; restored from __doc__
        """
        Compare(self, other:vtkTuple_IdLi4EE, tol:float) -> bool
        C++: bool Compare(const vtkTuple<double, 4> &other,
            const double &tol)
        
        Equality operator with a tolerance to allow fuzzy comparisons.
        """
        return False

    def GetData(self): # real signature unknown; restored from __doc__
        """
        GetData(self) -> Pointer
        C++: double *GetData()
        
        Get a pointer to the underlying data of the tuple.
        """
        pass

    def GetSize(self): # real signature unknown; restored from __doc__
        """
        GetSize(self) -> int
        C++: int GetSize()
        
        Get the size of the tuple.
        """
        return 0

    def __delitem__(self, *args, **kwargs): # real signature unknown
        """ Delete self[key]. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, *args, **kwargs): # real signature unknown
        """ Return self[key]. """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setitem__(self, *args, **kwargs): # real signature unknown
        """ Set self[key] to value. """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass


class vtkQuaternion_IdE(vtkTuple_IdLi4EE):
    """
    vtkQuaternion() -> vtkQuaternion
    C++: vtkQuaternion()
    vtkQuaternion(scalar:float) -> vtkQuaternion
    C++: explicit vtkQuaternion(const double &scalar)
    vtkQuaternion(init:(float, float, float, float)) -> vtkQuaternion
    C++: explicit vtkQuaternion(const double *init)
    vtkQuaternion(w:float, x:float, y:float, z:float) -> vtkQuaternion
    C++: vtkQuaternion(const double &w, const double &x, const double &y,
        const double &z)
    vtkQuaternion(__a:vtkQuaternion_IdE) -> vtkQuaternion
    C++: vtkQuaternion(const &vtkQuaternion<double>)
    
    vtkQuaternion- templated base type for storage of quaternions.
    
    Superclass: vtkTuple[float64,4]
    
    This class is a templated data type for storing and manipulating
    quaternions. The quaternions have the form [w, x, y, z]. Given a
    rotation of angle theta and axis v, the corresponding quaternion is
    [w, x, y, z] = [cos(theta/2), v*sin(theta/2)]
    
    This class implements the Spherical Linear interpolation (SLERP) and
    the Spherical Spline Quaternion interpolation (SQUAD). It is advised
    to use the vtkQuaternionInterpolator when dealing with multiple
    quaternions and or interpolations.
    
    @sa
    vtkQuaternionInterpolator
    """
    def Conjugate(self): # real signature unknown; restored from __doc__
        """
        Conjugate(self) -> None
        C++: void Conjugate()
        
        Conjugate the quaternion in place.
        """
        pass

    def Conjugated(self): # real signature unknown; restored from __doc__
        """
        Conjugated(self) -> vtkQuaternion_IdE
        C++: vtkQuaternion<double> Conjugated()
        
        Return the conjugate form of this quaternion.
        """
        return vtkQuaternion_IdE

    def FromMatrix3x3(self, A, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        FromMatrix3x3(self, A:((float, float, float), (float, float,
            float), (float, float, float))) -> None
        C++: void FromMatrix3x3(const double A[3][3])
        
        Convert a 3x3 matrix into a quaternion.  This will provide the
        best possible answer even if the matrix is not a pure rotation
        matrix. The method used is that of B.K.P. Horn.
        @sa ToMatrix3x3()
        """
        pass

    def Get(self, quat, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        Get(self, quat:[float, float, float, float]) -> None
        C++: void Get(double quat[4])
        """
        pass

    def GetRotationAngleAndAxis(self, axis, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetRotationAngleAndAxis(self, axis:[float, float, float]) -> float
        C++: double GetRotationAngleAndAxis(double axis[3])
        
        Set/Get the angle (in radians) and the axis corresponding to the
        axis-angle rotation of this quaternion.
        """
        pass

    def GetW(self): # real signature unknown; restored from __doc__
        """
        GetW(self) -> float
        C++: const double &GetW()
        """
        return 0.0

    def GetX(self): # real signature unknown; restored from __doc__
        """
        GetX(self) -> float
        C++: const double &GetX()
        """
        return 0.0

    def GetY(self): # real signature unknown; restored from __doc__
        """
        GetY(self) -> float
        C++: const double &GetY()
        """
        return 0.0

    def GetZ(self): # real signature unknown; restored from __doc__
        """
        GetZ(self) -> float
        C++: const double &GetZ()
        """
        return 0.0

    def Identity(self): # real signature unknown; restored from __doc__
        """
        Identity() -> vtkQuaternion_IdE
        C++: static vtkQuaternion<double> Identity()
        
        Return the identity quaternion. Note that the default constructor
        also creates an identity quaternion.
        """
        return vtkQuaternion_IdE

    def InnerPoint(self, q1, q2): # real signature unknown; restored from __doc__
        """
        InnerPoint(self, q1:vtkQuaternion_IdE, q2:vtkQuaternion_IdE)
            -> vtkQuaternion_IdE
        C++: vtkQuaternion<double> InnerPoint(
            const vtkQuaternion<double> &q1,
            const vtkQuaternion<double> &q2)
        
        Interpolates between quaternions, using spherical quadrangle
        interpolation.
        @sa vtkQuaternionInterpolator
        """
        return vtkQuaternion_IdE

    def Inverse(self): # real signature unknown; restored from __doc__
        """
        Inverse(self) -> vtkQuaternion_IdE
        C++: vtkQuaternion<double> Inverse()
        
        Return the inverted form of this quaternion.
        """
        return vtkQuaternion_IdE

    def Invert(self): # real signature unknown; restored from __doc__
        """
        Invert(self) -> None
        C++: void Invert()
        
        Invert the quaternion in place. This is equivalent to conjugate
        the quaternion and then divide it by its squared norm.
        """
        pass

    def Norm(self): # real signature unknown; restored from __doc__
        """
        Norm(self) -> float
        C++: double Norm()
        
        Get the norm of the quaternion, i.e. its length.
        """
        return 0.0

    def Normalize(self): # real signature unknown; restored from __doc__
        """
        Normalize(self) -> float
        C++: double Normalize()
        
        Normalize the quaternion in place. Return the norm of the
        quaternion.
        """
        return 0.0

    def Normalized(self): # real signature unknown; restored from __doc__
        """
        Normalized(self) -> vtkQuaternion_IdE
        C++: vtkQuaternion<double> Normalized()
        
        Return the normalized form of this quaternion.
        """
        return vtkQuaternion_IdE

    def NormalizedWithAngleInDegrees(self): # real signature unknown; restored from __doc__
        """
        NormalizedWithAngleInDegrees(self) -> vtkQuaternion_IdE
        C++: vtkQuaternion<double> NormalizedWithAngleInDegrees()
        
        Returns a quaternion normalized and transformed so its angle is
        in degrees and its axis normalized.
        """
        return vtkQuaternion_IdE

    def NormalizeWithAngleInDegrees(self): # real signature unknown; restored from __doc__
        """
        NormalizeWithAngleInDegrees(self) -> None
        C++: void NormalizeWithAngleInDegrees()
        
        Normalize a quaternion in place and transform it to so its angle
        is in degrees and its axis normalized.
        """
        pass

    def Set(self, w, x, y, z): # real signature unknown; restored from __doc__
        """
        Set(self, w:float, x:float, y:float, z:float) -> None
        C++: void Set(const double &w, const double &x, const double &y,
            const double &z)
        Set(self, quat:[float, float, float, float]) -> None
        C++: void Set(double quat[4])
        
        Set/Get the w, x, y and z components of the quaternion.
        """
        pass

    def SetRotationAngleAndAxis(self, angle, axis, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        SetRotationAngleAndAxis(self, angle:float, axis:[float, float,
            float]) -> None
        C++: void SetRotationAngleAndAxis(double angle, double axis[3])
        SetRotationAngleAndAxis(self, angle:float, x:float, y:float,
            z:float) -> None
        C++: void SetRotationAngleAndAxis(const double &angle,
            const double &x, const double &y, const double &z)
        """
        pass

    def SetW(self, w): # real signature unknown; restored from __doc__
        """
        SetW(self, w:float) -> None
        C++: void SetW(const double &w)
        
        Set/Get the w component of the quaternion, i.e. element 0.
        """
        pass

    def SetX(self, x): # real signature unknown; restored from __doc__
        """
        SetX(self, x:float) -> None
        C++: void SetX(const double &x)
        
        Set/Get the x component of the quaternion, i.e. element 1.
        """
        pass

    def SetY(self, y): # real signature unknown; restored from __doc__
        """
        SetY(self, y:float) -> None
        C++: void SetY(const double &y)
        
        Set/Get the y component of the quaternion, i.e. element 2.
        """
        pass

    def SetZ(self, z): # real signature unknown; restored from __doc__
        """
        SetZ(self, z:float) -> None
        C++: void SetZ(const double &z)
        
        Set/Get the y component of the quaternion, i.e. element 3.
        """
        pass

    def Slerp(self, t, q): # real signature unknown; restored from __doc__
        """
        Slerp(self, t:float, q:vtkQuaternion_IdE) -> vtkQuaternion_IdE
        C++: vtkQuaternion<double> Slerp(double t,
            const vtkQuaternion<double> &q)
        
        Interpolate quaternions using spherical linear interpolation
        between this quaternion and q1 to produce the output. The
        parametric coordinate t belongs to [0,1] and lies between
        (this,q1).
        @sa vtkQuaternionInterpolator
        """
        return vtkQuaternion_IdE

    def SquaredNorm(self): # real signature unknown; restored from __doc__
        """
        SquaredNorm(self) -> float
        C++: double SquaredNorm()
        
        Get the squared norm of the quaternion.
        """
        return 0.0

    def ToIdentity(self): # real signature unknown; restored from __doc__
        """
        ToIdentity(self) -> None
        C++: void ToIdentity()
        
        Set the quaternion to identity in place.
        """
        pass

    def ToMatrix3x3(self, A, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        ToMatrix3x3(self, A:[[float, float, float], [float, float, float],
             [float, float, float]]) -> None
        C++: void ToMatrix3x3(double A[3][3])
        
        Convert a quaternion to a 3x3 rotation matrix. The quaternion
        does not have to be normalized beforehand.
        @sa FromMatrix3x3()
        """
        pass

    def ToUnitExp(self): # real signature unknown; restored from __doc__
        """
        ToUnitExp(self) -> None
        C++: void ToUnitExp()
        
        Convert this quaternion to a unit exponential quaternion. The
        unit exponential quaternion is defined by: [w, x, y, z] = 
        [cos(theta), v*sin(theta)].
        """
        pass

    def ToUnitLog(self): # real signature unknown; restored from __doc__
        """
        ToUnitLog(self) -> None
        C++: void ToUnitLog()
        
        Convert this quaternion to a unit log quaternion. The unit log
        quaternion is defined by: [w, x, y, z] =  [0.0, v*theta].
        """
        pass

    def UnitExp(self): # real signature unknown; restored from __doc__
        """
        UnitExp(self) -> vtkQuaternion_IdE
        C++: vtkQuaternion<double> UnitExp()
        
        Return the unit exponential version of this quaternion. The unit
        exponential quaternion is defined by: [w, x, y, z] = 
        [cos(theta), v*sin(theta)].
        """
        return vtkQuaternion_IdE

    def UnitLog(self): # real signature unknown; restored from __doc__
        """
        UnitLog(self) -> vtkQuaternion_IdE
        C++: vtkQuaternion<double> UnitLog()
        
        Return the unit log version of this quaternion. The unit log
        quaternion is defined by: [w, x, y, z] =  [0.0, v*theta].
        """
        return vtkQuaternion_IdE

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass


class vtkQuaterniond(vtkQuaternion_IdE):
    """
    vtkQuaterniond() -> vtkQuaterniond
    C++: vtkQuaterniond()
    vtkQuaterniond(w:float, x:float, y:float, z:float) -> vtkQuaterniond
    C++: explicit vtkQuaterniond(double w, double x, double y, double z)
    vtkQuaterniond(scalar:float) -> vtkQuaterniond
    C++: explicit vtkQuaterniond(double scalar)
    vtkQuaterniond(init:(float, float, float, float)) -> vtkQuaterniond
    C++: explicit vtkQuaterniond(const double *init)
    vtkQuaterniond(__a:vtkQuaterniond) -> vtkQuaterniond
    C++: vtkQuaterniond(const &vtkQuaterniond)
    
    vtkQuaterniond - no description provided.
    
    Superclass: vtkQuaternion[float64]
    """
    def Conjugated(self): # real signature unknown; restored from __doc__
        """
        Conjugated(self) -> vtkQuaterniond
        C++: vtkQuaterniond Conjugated()
        
        Return the conjugate form of this quaternion.
        """
        return vtkQuaterniond

    def Identity(self): # real signature unknown; restored from __doc__
        """
        Identity(self) -> vtkQuaterniond
        C++: vtkQuaterniond Identity()
        
        Return the identity quaternion. Note that the default constructor
        also creates an identity quaternion.
        """
        return vtkQuaterniond

    def InnerPoint(self, q1, q2): # real signature unknown; restored from __doc__
        """
        InnerPoint(self, q1:vtkQuaterniond, q2:vtkQuaterniond)
            -> vtkQuaterniond
        C++: vtkQuaterniond InnerPoint(const vtkQuaterniond &q1,
            const vtkQuaterniond &q2)
        """
        return vtkQuaterniond

    def Inverse(self): # real signature unknown; restored from __doc__
        """
        Inverse(self) -> vtkQuaterniond
        C++: vtkQuaterniond Inverse()
        
        Return the inverted form of this quaternion.
        """
        return vtkQuaterniond

    def Normalized(self): # real signature unknown; restored from __doc__
        """
        Normalized(self) -> vtkQuaterniond
        C++: vtkQuaterniond Normalized()
        
        Return the normalized form of this quaternion.
        """
        return vtkQuaterniond

    def NormalizedWithAngleInDegrees(self): # real signature unknown; restored from __doc__
        """
        NormalizedWithAngleInDegrees(self) -> vtkQuaterniond
        C++: vtkQuaterniond NormalizedWithAngleInDegrees()
        
        Returns a quaternion normalized and transformed so its angle is
        in degrees and its axis normalized.
        """
        return vtkQuaterniond

    def Slerp(self, t, q): # real signature unknown; restored from __doc__
        """
        Slerp(self, t:float, q:vtkQuaterniond) -> vtkQuaterniond
        C++: vtkQuaterniond Slerp(double t, const vtkQuaterniond &q)
        """
        return vtkQuaterniond

    def UnitExp(self): # real signature unknown; restored from __doc__
        """
        UnitExp(self) -> vtkQuaterniond
        C++: vtkQuaterniond UnitExp()
        
        Return the unit exponential version of this quaternion. The unit
        exponential quaternion is defined by: [w, x, y, z] = 
        [cos(theta), v*sin(theta)].
        """
        return vtkQuaterniond

    def UnitLog(self): # real signature unknown; restored from __doc__
        """
        UnitLog(self) -> vtkQuaterniond
        C++: vtkQuaterniond UnitLog()
        
        Return the unit log version of this quaternion. The unit log
        quaternion is defined by: [w, x, y, z] =  [0.0, v*theta].
        """
        return vtkQuaterniond

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self): # real signature unknown; restored from __doc__
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass


class vtkTuple_IfLi4EE(object):
    """
    vtkTuple() -> vtkTuple
    C++: vtkTuple()
    vtkTuple(scalar:float) -> vtkTuple
    C++: explicit vtkTuple(const float &scalar)
    vtkTuple(init:(float, float, float, float)) -> vtkTuple
    C++: explicit vtkTuple(const float *init)
    vtkTuple(__a:vtkTuple_IfLi4EE) -> vtkTuple
    C++: vtkTuple(const &vtkTuple<float, 4>)
    
    vtkTuple<float, 4> - templated base type for containers of constant
    size.
    
    This class is a templated data type for storing and manipulating
    tuples.
    """
    def Compare(self, other, tol): # real signature unknown; restored from __doc__
        """
        Compare(self, other:vtkTuple_IfLi4EE, tol:float) -> bool
        C++: bool Compare(const vtkTuple<float, 4> &other,
            const float &tol)
        
        Equality operator with a tolerance to allow fuzzy comparisons.
        """
        return False

    def GetData(self): # real signature unknown; restored from __doc__
        """
        GetData(self) -> Pointer
        C++: float *GetData()
        
        Get a pointer to the underlying data of the tuple.
        """
        pass

    def GetSize(self): # real signature unknown; restored from __doc__
        """
        GetSize(self) -> int
        C++: int GetSize()
        
        Get the size of the tuple.
        """
        return 0

    def __delitem__(self, *args, **kwargs): # real signature unknown
        """ Delete self[key]. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, *args, **kwargs): # real signature unknown
        """ Return self[key]. """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setitem__(self, *args, **kwargs): # real signature unknown
        """ Set self[key] to value. """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass


class vtkQuaternion_IfE(vtkTuple_IfLi4EE):
    """
    vtkQuaternion() -> vtkQuaternion
    C++: vtkQuaternion()
    vtkQuaternion(scalar:float) -> vtkQuaternion
    C++: explicit vtkQuaternion(const float &scalar)
    vtkQuaternion(init:(float, float, float, float)) -> vtkQuaternion
    C++: explicit vtkQuaternion(const float *init)
    vtkQuaternion(w:float, x:float, y:float, z:float) -> vtkQuaternion
    C++: vtkQuaternion(const float &w, const float &x, const float &y,
        const float &z)
    vtkQuaternion(__a:vtkQuaternion_IfE) -> vtkQuaternion
    C++: vtkQuaternion(const &vtkQuaternion<float>)
    
    vtkQuaternion- templated base type for storage of quaternions.
    
    Superclass: vtkTuple[float32,4]
    
    This class is a templated data type for storing and manipulating
    quaternions. The quaternions have the form [w, x, y, z]. Given a
    rotation of angle theta and axis v, the corresponding quaternion is
    [w, x, y, z] = [cos(theta/2), v*sin(theta/2)]
    
    This class implements the Spherical Linear interpolation (SLERP) and
    the Spherical Spline Quaternion interpolation (SQUAD). It is advised
    to use the vtkQuaternionInterpolator when dealing with multiple
    quaternions and or interpolations.
    
    @sa
    vtkQuaternionInterpolator
    """
    def Conjugate(self): # real signature unknown; restored from __doc__
        """
        Conjugate(self) -> None
        C++: void Conjugate()
        
        Conjugate the quaternion in place.
        """
        pass

    def Conjugated(self): # real signature unknown; restored from __doc__
        """
        Conjugated(self) -> vtkQuaternion_IfE
        C++: vtkQuaternion<float> Conjugated()
        
        Return the conjugate form of this quaternion.
        """
        return vtkQuaternion_IfE

    def FromMatrix3x3(self, A, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        FromMatrix3x3(self, A:((float, float, float), (float, float,
            float), (float, float, float))) -> None
        C++: void FromMatrix3x3(const float A[3][3])
        
        Convert a 3x3 matrix into a quaternion.  This will provide the
        best possible answer even if the matrix is not a pure rotation
        matrix. The method used is that of B.K.P. Horn.
        @sa ToMatrix3x3()
        """
        pass

    def Get(self, quat, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        Get(self, quat:[float, float, float, float]) -> None
        C++: void Get(float quat[4])
        """
        pass

    def GetRotationAngleAndAxis(self, axis, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetRotationAngleAndAxis(self, axis:[float, float, float]) -> float
        C++: float GetRotationAngleAndAxis(float axis[3])
        
        Set/Get the angle (in radians) and the axis corresponding to the
        axis-angle rotation of this quaternion.
        """
        pass

    def GetW(self): # real signature unknown; restored from __doc__
        """
        GetW(self) -> float
        C++: const float &GetW()
        """
        return 0.0

    def GetX(self): # real signature unknown; restored from __doc__
        """
        GetX(self) -> float
        C++: const float &GetX()
        """
        return 0.0

    def GetY(self): # real signature unknown; restored from __doc__
        """
        GetY(self) -> float
        C++: const float &GetY()
        """
        return 0.0

    def GetZ(self): # real signature unknown; restored from __doc__
        """
        GetZ(self) -> float
        C++: const float &GetZ()
        """
        return 0.0

    def Identity(self): # real signature unknown; restored from __doc__
        """
        Identity() -> vtkQuaternion_IfE
        C++: static vtkQuaternion<float> Identity()
        
        Return the identity quaternion. Note that the default constructor
        also creates an identity quaternion.
        """
        return vtkQuaternion_IfE

    def InnerPoint(self, q1, q2): # real signature unknown; restored from __doc__
        """
        InnerPoint(self, q1:vtkQuaternion_IfE, q2:vtkQuaternion_IfE)
            -> vtkQuaternion_IfE
        C++: vtkQuaternion<float> InnerPoint(
            const vtkQuaternion<float> &q1,
            const vtkQuaternion<float> &q2)
        
        Interpolates between quaternions, using spherical quadrangle
        interpolation.
        @sa vtkQuaternionInterpolator
        """
        return vtkQuaternion_IfE

    def Inverse(self): # real signature unknown; restored from __doc__
        """
        Inverse(self) -> vtkQuaternion_IfE
        C++: vtkQuaternion<float> Inverse()
        
        Return the inverted form of this quaternion.
        """
        return vtkQuaternion_IfE

    def Invert(self): # real signature unknown; restored from __doc__
        """
        Invert(self) -> None
        C++: void Invert()
        
        Invert the quaternion in place. This is equivalent to conjugate
        the quaternion and then divide it by its squared norm.
        """
        pass

    def Norm(self): # real signature unknown; restored from __doc__
        """
        Norm(self) -> float
        C++: float Norm()
        
        Get the norm of the quaternion, i.e. its length.
        """
        return 0.0

    def Normalize(self): # real signature unknown; restored from __doc__
        """
        Normalize(self) -> float
        C++: float Normalize()
        
        Normalize the quaternion in place. Return the norm of the
        quaternion.
        """
        return 0.0

    def Normalized(self): # real signature unknown; restored from __doc__
        """
        Normalized(self) -> vtkQuaternion_IfE
        C++: vtkQuaternion<float> Normalized()
        
        Return the normalized form of this quaternion.
        """
        return vtkQuaternion_IfE

    def NormalizedWithAngleInDegrees(self): # real signature unknown; restored from __doc__
        """
        NormalizedWithAngleInDegrees(self) -> vtkQuaternion_IfE
        C++: vtkQuaternion<float> NormalizedWithAngleInDegrees()
        
        Returns a quaternion normalized and transformed so its angle is
        in degrees and its axis normalized.
        """
        return vtkQuaternion_IfE

    def NormalizeWithAngleInDegrees(self): # real signature unknown; restored from __doc__
        """
        NormalizeWithAngleInDegrees(self) -> None
        C++: void NormalizeWithAngleInDegrees()
        
        Normalize a quaternion in place and transform it to so its angle
        is in degrees and its axis normalized.
        """
        pass

    def Set(self, w, x, y, z): # real signature unknown; restored from __doc__
        """
        Set(self, w:float, x:float, y:float, z:float) -> None
        C++: void Set(const float &w, const float &x, const float &y,
            const float &z)
        Set(self, quat:[float, float, float, float]) -> None
        C++: void Set(float quat[4])
        
        Set/Get the w, x, y and z components of the quaternion.
        """
        pass

    def SetRotationAngleAndAxis(self, angle, axis, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        SetRotationAngleAndAxis(self, angle:float, axis:[float, float,
            float]) -> None
        C++: void SetRotationAngleAndAxis(float angle, float axis[3])
        SetRotationAngleAndAxis(self, angle:float, x:float, y:float,
            z:float) -> None
        C++: void SetRotationAngleAndAxis(const float &angle,
            const float &x, const float &y, const float &z)
        """
        pass

    def SetW(self, w): # real signature unknown; restored from __doc__
        """
        SetW(self, w:float) -> None
        C++: void SetW(const float &w)
        
        Set/Get the w component of the quaternion, i.e. element 0.
        """
        pass

    def SetX(self, x): # real signature unknown; restored from __doc__
        """
        SetX(self, x:float) -> None
        C++: void SetX(const float &x)
        
        Set/Get the x component of the quaternion, i.e. element 1.
        """
        pass

    def SetY(self, y): # real signature unknown; restored from __doc__
        """
        SetY(self, y:float) -> None
        C++: void SetY(const float &y)
        
        Set/Get the y component of the quaternion, i.e. element 2.
        """
        pass

    def SetZ(self, z): # real signature unknown; restored from __doc__
        """
        SetZ(self, z:float) -> None
        C++: void SetZ(const float &z)
        
        Set/Get the y component of the quaternion, i.e. element 3.
        """
        pass

    def Slerp(self, t, q): # real signature unknown; restored from __doc__
        """
        Slerp(self, t:float, q:vtkQuaternion_IfE) -> vtkQuaternion_IfE
        C++: vtkQuaternion<float> Slerp(float t,
            const vtkQuaternion<float> &q)
        
        Interpolate quaternions using spherical linear interpolation
        between this quaternion and q1 to produce the output. The
        parametric coordinate t belongs to [0,1] and lies between
        (this,q1).
        @sa vtkQuaternionInterpolator
        """
        return vtkQuaternion_IfE

    def SquaredNorm(self): # real signature unknown; restored from __doc__
        """
        SquaredNorm(self) -> float
        C++: float SquaredNorm()
        
        Get the squared norm of the quaternion.
        """
        return 0.0

    def ToIdentity(self): # real signature unknown; restored from __doc__
        """
        ToIdentity(self) -> None
        C++: void ToIdentity()
        
        Set the quaternion to identity in place.
        """
        pass

    def ToMatrix3x3(self, A, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        ToMatrix3x3(self, A:[[float, float, float], [float, float, float],
             [float, float, float]]) -> None
        C++: void ToMatrix3x3(float A[3][3])
        
        Convert a quaternion to a 3x3 rotation matrix. The quaternion
        does not have to be normalized beforehand.
        @sa FromMatrix3x3()
        """
        pass

    def ToUnitExp(self): # real signature unknown; restored from __doc__
        """
        ToUnitExp(self) -> None
        C++: void ToUnitExp()
        
        Convert this quaternion to a unit exponential quaternion. The
        unit exponential quaternion is defined by: [w, x, y, z] = 
        [cos(theta), v*sin(theta)].
        """
        pass

    def ToUnitLog(self): # real signature unknown; restored from __doc__
        """
        ToUnitLog(self) -> None
        C++: void ToUnitLog()
        
        Convert this quaternion to a unit log quaternion. The unit log
        quaternion is defined by: [w, x, y, z] =  [0.0, v*theta].
        """
        pass

    def UnitExp(self): # real signature unknown; restored from __doc__
        """
        UnitExp(self) -> vtkQuaternion_IfE
        C++: vtkQuaternion<float> UnitExp()
        
        Return the unit exponential version of this quaternion. The unit
        exponential quaternion is defined by: [w, x, y, z] = 
        [cos(theta), v*sin(theta)].
        """
        return vtkQuaternion_IfE

    def UnitLog(self): # real signature unknown; restored from __doc__
        """
        UnitLog(self) -> vtkQuaternion_IfE
        C++: vtkQuaternion<float> UnitLog()
        
        Return the unit log version of this quaternion. The unit log
        quaternion is defined by: [w, x, y, z] =  [0.0, v*theta].
        """
        return vtkQuaternion_IfE

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass


class vtkQuaternionf(vtkQuaternion_IfE):
    """
    vtkQuaternionf() -> vtkQuaternionf
    C++: vtkQuaternionf()
    vtkQuaternionf(w:float, x:float, y:float, z:float) -> vtkQuaternionf
    C++: explicit vtkQuaternionf(float w, float x, float y, float z)
    vtkQuaternionf(scalar:float) -> vtkQuaternionf
    C++: explicit vtkQuaternionf(float scalar)
    vtkQuaternionf(init:(float, float, float, float)) -> vtkQuaternionf
    C++: explicit vtkQuaternionf(const float *init)
    vtkQuaternionf(__a:vtkQuaternionf) -> vtkQuaternionf
    C++: vtkQuaternionf(const &vtkQuaternionf)
    
    vtkQuaternionf - no description provided.
    
    Superclass: vtkQuaternion[float32]
    """
    def Conjugated(self): # real signature unknown; restored from __doc__
        """
        Conjugated(self) -> vtkQuaternionf
        C++: vtkQuaternionf Conjugated()
        
        Return the conjugate form of this quaternion.
        """
        return vtkQuaternionf

    def Identity(self): # real signature unknown; restored from __doc__
        """
        Identity(self) -> vtkQuaternionf
        C++: vtkQuaternionf Identity()
        
        Return the identity quaternion. Note that the default constructor
        also creates an identity quaternion.
        """
        return vtkQuaternionf

    def InnerPoint(self, q1, q2): # real signature unknown; restored from __doc__
        """
        InnerPoint(self, q1:vtkQuaternionf, q2:vtkQuaternionf)
            -> vtkQuaternionf
        C++: vtkQuaternionf InnerPoint(const vtkQuaternionf &q1,
            const vtkQuaternionf &q2)
        """
        return vtkQuaternionf

    def Inverse(self): # real signature unknown; restored from __doc__
        """
        Inverse(self) -> vtkQuaternionf
        C++: vtkQuaternionf Inverse()
        
        Return the inverted form of this quaternion.
        """
        return vtkQuaternionf

    def Normalized(self): # real signature unknown; restored from __doc__
        """
        Normalized(self) -> vtkQuaternionf
        C++: vtkQuaternionf Normalized()
        
        Return the normalized form of this quaternion.
        """
        return vtkQuaternionf

    def NormalizedWithAngleInDegrees(self): # real signature unknown; restored from __doc__
        """
        NormalizedWithAngleInDegrees(self) -> vtkQuaternionf
        C++: vtkQuaternionf NormalizedWithAngleInDegrees()
        
        Returns a quaternion normalized and transformed so its angle is
        in degrees and its axis normalized.
        """
        return vtkQuaternionf

    def Slerp(self, t, q): # real signature unknown; restored from __doc__
        """
        Slerp(self, t:float, q:vtkQuaternionf) -> vtkQuaternionf
        C++: vtkQuaternionf Slerp(float t, const vtkQuaternionf &q)
        """
        return vtkQuaternionf

    def UnitExp(self): # real signature unknown; restored from __doc__
        """
        UnitExp(self) -> vtkQuaternionf
        C++: vtkQuaternionf UnitExp()
        
        Return the unit exponential version of this quaternion. The unit
        exponential quaternion is defined by: [w, x, y, z] = 
        [cos(theta), v*sin(theta)].
        """
        return vtkQuaternionf

    def UnitLog(self): # real signature unknown; restored from __doc__
        """
        UnitLog(self) -> vtkQuaternionf
        C++: vtkQuaternionf UnitLog()
        
        Return the unit log version of this quaternion. The unit log
        quaternion is defined by: [w, x, y, z] =  [0.0, v*theta].
        """
        return vtkQuaternionf

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self): # real signature unknown; restored from __doc__
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass


class vtkQuaternionInterpolator(__vtkmodules_vtkCommonCore.vtkObject):
    """
    vtkQuaternionInterpolator - interpolate a quaternion
    
    Superclass: vtkObject
    
    This class is used to interpolate a series of quaternions
    representing the rotations of a 3D object.  The interpolation may be
    linear in form (using spherical linear interpolation SLERP), or via
    spline interpolation (using SQUAD). In either case the interpolation
    is specialized to quaternions since the interpolation occurs on the
    surface of the unit quaternion sphere.
    
    To use this class, specify at least two pairs of (t,q[4]) with the
    AddQuaternion() method.  Next interpolate the tuples with the
    InterpolateQuaternion(t,q[4]) method, where "t" must be in the range
    of (t_min,t_max) parameter values specified by the AddQuaternion()
    method (t is clamped otherwise), and q[4] is filled in by the method.
    
    There are several important background references. Ken Shoemake
    described the practical application of quaternions for the
    interpolation of rotation (K. Shoemake, "Animating rotation with quaternion
    curves", Computer Graphics (Siggraph '85) 19(3):245--254, 1985).
    Another fine reference (available on-line) is E. B. Dam, M. Koch, and
    M. Lillholm, Technical Report DIKU-TR-98/5, Dept. of Computer
    Science, University of Copenhagen, Denmark.
    
    @warning
    Note that for two or less quaternions, Slerp (linear) interpolation
    is performed even if spline interpolation is requested. Also, the
    tangents to the first and last segments of spline interpolation are
    (arbitrarily) defined by repeating the first and last quaternions.
    
    @warning
    There are several methods particular to quaternions (norms, products,
    etc.) implemented interior to this class. These may be moved to a
    separate quaternion class at some point.
    
    @sa
    vtkQuaternion
    """
    def AddQuaternion(self, t, q): # real signature unknown; restored from __doc__
        """
        AddQuaternion(self, t:float, q:vtkQuaterniond) -> None
        C++: void AddQuaternion(double t, const vtkQuaterniond &q)
        AddQuaternion(self, t:float, q:[float, float, float, float])
            -> None
        C++: void AddQuaternion(double t, double q[4])
        
        Add another quaternion to the list of quaternions to be
        interpolated. Note that using the same time t value more than
        once replaces the previous quaternion at t. At least one
        quaternions must be added to define an interpolation functions.
        """
        pass

    def GetInterpolationType(self): # real signature unknown; restored from __doc__
        """
        GetInterpolationType(self) -> int
        C++: virtual int GetInterpolationType()
        """
        return 0

    def GetInterpolationTypeMaxValue(self): # real signature unknown; restored from __doc__
        """
        GetInterpolationTypeMaxValue(self) -> int
        C++: virtual int GetInterpolationTypeMaxValue()
        """
        return 0

    def GetInterpolationTypeMinValue(self): # real signature unknown; restored from __doc__
        """
        GetInterpolationTypeMinValue(self) -> int
        C++: virtual int GetInterpolationTypeMinValue()
        """
        return 0

    def GetMaximumT(self): # real signature unknown; restored from __doc__
        """
        GetMaximumT(self) -> float
        C++: double GetMaximumT()
        """
        return 0.0

    def GetMinimumT(self): # real signature unknown; restored from __doc__
        """
        GetMinimumT(self) -> float
        C++: double GetMinimumT()
        
        Obtain some information about the interpolation range. The
        numbers returned (corresponding to parameter t, usually thought
        of as time) are undefined if the list of transforms is empty.
        This is a convenience method for interpolation.
        """
        return 0.0

    def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBase(self, type:str) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given 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.
        """
        return 0

    def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBaseType(type:str) -> 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.
        """
        return 0

    def GetNumberOfQuaternions(self): # real signature unknown; restored from __doc__
        """
        GetNumberOfQuaternions(self) -> int
        C++: int GetNumberOfQuaternions()
        
        Return the number of quaternions in the list of quaternions to be
        interpolated.
        """
        return 0

    def GetSearchMethod(self): # real signature unknown; restored from __doc__
        """
        GetSearchMethod(self) -> int
        C++: int GetSearchMethod()
        
        Set / Get the search type method. 0 is a binary search method
        O(log(N)) 1 is a linear search method O(N). Linear search method
        is kept because it can be faster than the dichotomous search
        method in specific cases
        """
        return 0

    def Initialize(self): # real signature unknown; restored from __doc__
        """
        Initialize(self) -> None
        C++: void Initialize()
        
        Reset the class so that it contains no data; i.e., the array of
        (t,q[4]) information is discarded.
        """
        pass

    def InterpolateQuaternion(self, t, q): # real signature unknown; restored from __doc__
        """
        InterpolateQuaternion(self, t:float, q:vtkQuaterniond) -> None
        C++: void InterpolateQuaternion(double t, vtkQuaterniond &q)
        InterpolateQuaternion(self, t:float, q:[float, float, float,
            float]) -> None
        C++: void InterpolateQuaternion(double t, double q[4])
        
        Interpolate the list of quaternions and determine a new
        quaternion (i.e., fill in the quaternion provided). If t is
        outside the range of (min,max) values, then t is clamped to lie
        within the range.
        """
        pass

    def IsA(self, type): # real signature unknown; restored from __doc__
        """
        IsA(self, type:str) -> 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.
        """
        return 0

    def IsTypeOf(self, type): # real signature unknown; restored from __doc__
        """
        IsTypeOf(type:str) -> 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.
        """
        return 0

    def NewInstance(self): # real signature unknown; restored from __doc__
        """
        NewInstance(self) -> vtkQuaternionInterpolator
        C++: vtkQuaternionInterpolator *NewInstance()
        """
        return vtkQuaternionInterpolator

    def RemoveQuaternion(self, t): # real signature unknown; restored from __doc__
        """
        RemoveQuaternion(self, t:float) -> None
        C++: void RemoveQuaternion(double t)
        
        Delete the quaternion at a particular parameter t. If there is no
        quaternion tuple defined at t, then the method does nothing.
        """
        pass

    def SafeDownCast(self, o): # real signature unknown; restored from __doc__
        """
        SafeDownCast(o:vtkObjectBase) -> vtkQuaternionInterpolator
        C++: static vtkQuaternionInterpolator *SafeDownCast(
            vtkObjectBase *o)
        """
        return vtkQuaternionInterpolator

    def SetInterpolationType(self, _arg): # real signature unknown; restored from __doc__
        """
        SetInterpolationType(self, _arg:int) -> None
        C++: virtual void SetInterpolationType(int _arg)
        
        Specify which type of function to use for interpolation. By
        default (SetInterpolationFunctionToSpline()), cubic spline
        interpolation using a modified Kochanek basis is employed.
        Otherwise, if SetInterpolationFunctionToLinear() is invoked,
        linear spherical interpolation is used between each pair of
        quaternions.
        """
        pass

    def SetInterpolationTypeToLinear(self): # real signature unknown; restored from __doc__
        """
        SetInterpolationTypeToLinear(self) -> None
        C++: void SetInterpolationTypeToLinear()
        """
        pass

    def SetInterpolationTypeToSpline(self): # real signature unknown; restored from __doc__
        """
        SetInterpolationTypeToSpline(self) -> None
        C++: void SetInterpolationTypeToSpline()
        """
        pass

    def SetSearchMethod(self, type): # real signature unknown; restored from __doc__
        """
        SetSearchMethod(self, type:int) -> None
        C++: void SetSearchMethod(int type)
        """
        pass

    def __delattr__(self, *args, **kwargs): # real signature unknown
        """ Implement delattr(self, name). """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setattr__(self, *args, **kwargs): # real signature unknown
        """ Implement setattr(self, name, value). """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass

    __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Pointer to the C++ object."""


    BinarySearch = 0
    INTERPOLATION_TYPE_LINEAR = 0
    INTERPOLATION_TYPE_SPLINE = 1
    LinearSearch = 1
    MaxEnum = 2
    vtkQuaternionInterpolationSearchMethod = None # (!) real value is "<class 'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator.vtkQuaternionInterpolationSearchMethod'>"
    __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkQuaternionInterpolator\', \'IsTypeOf\': <method \'IsTypeOf\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'IsA\': <method \'IsA\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'SafeDownCast\': <method \'SafeDownCast\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'NewInstance\': <method \'NewInstance\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'GetNumberOfGenerationsFromBaseType\': <method \'GetNumberOfGenerationsFromBaseType\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'GetNumberOfGenerationsFromBase\': <method \'GetNumberOfGenerationsFromBase\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'GetNumberOfQuaternions\': <method \'GetNumberOfQuaternions\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'GetMinimumT\': <method \'GetMinimumT\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'GetMaximumT\': <method \'GetMaximumT\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'Initialize\': <method \'Initialize\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'AddQuaternion\': <method \'AddQuaternion\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'RemoveQuaternion\': <method \'RemoveQuaternion\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'InterpolateQuaternion\': <method \'InterpolateQuaternion\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'GetSearchMethod\': <method \'GetSearchMethod\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'SetSearchMethod\': <method \'SetSearchMethod\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'SetInterpolationType\': <method \'SetInterpolationType\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'GetInterpolationTypeMinValue\': <method \'GetInterpolationTypeMinValue\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'GetInterpolationTypeMaxValue\': <method \'GetInterpolationTypeMaxValue\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'GetInterpolationType\': <method \'GetInterpolationType\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'SetInterpolationTypeToLinear\': <method \'SetInterpolationTypeToLinear\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'SetInterpolationTypeToSpline\': <method \'SetInterpolationTypeToSpline\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'vtkQuaternionInterpolationSearchMethod\': <class \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator.vtkQuaternionInterpolationSearchMethod\'>, \'BinarySearch\': 0, \'LinearSearch\': 1, \'MaxEnum\': 2, \'INTERPOLATION_TYPE_LINEAR\': 0, \'INTERPOLATION_TYPE_SPLINE\': 1, \'__new__\': <built-in method __new__ of type object at 0x00007FF85F057E80>, \'__repr__\': <slot wrapper \'__repr__\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'__str__\': <slot wrapper \'__str__\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'__getattribute__\': <slot wrapper \'__getattribute__\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'__setattr__\': <slot wrapper \'__setattr__\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'__delattr__\': <slot wrapper \'__delattr__\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'__dict__\': <attribute \'__dict__\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'__this__\': <attribute \'__this__\' of \'vtkmodules.vtkCommonMath.vtkQuaternionInterpolator\' objects>, \'__doc__\': \'vtkQuaternionInterpolator - interpolate a quaternion\\n\\nSuperclass: vtkObject\\n\\nThis class is used to interpolate a series of quaternions\\nrepresenting the rotations of a 3D object.  The interpolation may be\\nlinear in form (using spherical linear interpolation SLERP), or via\\nspline interpolation (using SQUAD). In either case the interpolation\\nis specialized to quaternions since the interpolation occurs on the\\nsurface of the unit quaternion sphere.\\n\\nTo use this class, specify at least two pairs of (t,q[4]) with the\\nAddQuaternion() method.  Next interpolate the tuples with the\\nInterpolateQuaternion(t,q[4]) method, where "t" must be in the range\\nof (t_min,t_max) parameter values specified by the AddQuaternion()\\nmethod (t is clamped otherwise), and q[4] is filled in by the method.\\n\\nThere are several important background references. Ken Shoemake\\ndescribed the practical application of quaternions for the\\ninterpolation of rotation (K. Shoemake, "Animating rotation with quaternion\\ncurves", Computer Graphics (Siggraph \\\'85) 19(3):245--254, 1985).\\nAnother fine reference (available on-line) is E. B. Dam, M. Koch, and\\nM. Lillholm, Technical Report DIKU-TR-98/5, Dept. of Computer\\nScience, University of Copenhagen, Denmark.\\n\\n@warning\\nNote that for two or less quaternions, Slerp (linear) interpolation\\nis performed even if spline interpolation is requested. Also, the\\ntangents to the first and last segments of spline interpolation are\\n(arbitrarily) defined by repeating the first and last quaternions.\\n\\n@warning\\nThere are several methods particular to quaternions (norms, products,\\netc.) implemented interior to this class. These may be moved to a\\nseparate quaternion class at some point.\\n\\n@sa\\nvtkQuaternion\\n\\n\'})'
    __vtkname__ = 'vtkQuaternionInterpolator'


class vtkRungeKutta2(vtkInitialValueProblemSolver):
    """
    vtkRungeKutta2 - Integrate an initial value problem using 2nd order
    Runge-Kutta method.
    
    Superclass: vtkInitialValueProblemSolver
    
    This is a concrete sub-class of vtkInitialValueProblemSolver. It uses
    a 2nd order Runge-Kutta method to obtain the values of a set of
    functions at the next time step.
    
    @sa
    vtkInitialValueProblemSolver vtkRungeKutta4 vtkRungeKutta45
    vtkFunctionSet
    """
    def ComputeNextStep(self, xprev, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        ComputeNextStep(self, xprev:[float, ...], xnext:[float, ...],
            t:float, delT:float, maxError:float, error:float,
            userData:Pointer) -> int
        C++: int ComputeNextStep(double *xprev, double *xnext, double t,
            double &delT, double maxError, double &error, void *userData)
            override;
        ComputeNextStep(self, xprev:[float, ...], dxprev:[float, ...],
            xnext:[float, ...], t:float, delT:float, maxError:float,
            error:float, userData:Pointer) -> int
        C++: int ComputeNextStep(double *xprev, double *dxprev,
            double *xnext, double t, double &delT, double maxError,
            double &error, void *userData) override;
        ComputeNextStep(self, xprev:[float, ...], xnext:[float, ...],
            t:float, delT:float, delTActual:float, minStep:float,
            maxStep:float, maxError:float, error:float, userData:Pointer)
            -> int
        C++: int ComputeNextStep(double *xprev, double *xnext, double t,
            double &delT, double &delTActual, double minStep,
            double maxStep, double maxError, double &error,
            void *userData) override;
        ComputeNextStep(self, xprev:[float, ...], dxprev:[float, ...],
            xnext:[float, ...], t:float, delT:float, delTActual:float,
            minStep:float, maxStep:float, maxError:float, error:float,
            userData:Pointer) -> int
        C++: int ComputeNextStep(double *xprev, double *dxprev,
            double *xnext, double t, double &delT, double &delTActual,
            double minStep, double maxStep, double maxError,
            double &error, void *userData) override;
        ComputeNextStep(self, xprev:[float, ...], xnext:[float, ...],
            t:float, delT:float, maxError:float, error:float) -> int
        C++: virtual int ComputeNextStep(double *xprev, double *xnext,
            double t, double &delT, double maxError, double &error)
        
        Given initial values, xprev , initial time, t and a requested
        time interval, delT calculate values of x at t+delT (xnext).
        delTActual is always equal to delT. Since this class can not
        provide an estimate for the error error is set to 0. maxStep,
        minStep and maxError are unused. This metho ...
         [Truncated]
        """
        pass

    def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBase(self, type:str) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given 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.
        """
        return 0

    def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBaseType(type:str) -> 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.
        """
        return 0

    def IsA(self, type): # real signature unknown; restored from __doc__
        """
        IsA(self, type:str) -> 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.
        """
        return 0

    def IsTypeOf(self, type): # real signature unknown; restored from __doc__
        """
        IsTypeOf(type:str) -> 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.
        """
        return 0

    def NewInstance(self): # real signature unknown; restored from __doc__
        """
        NewInstance(self) -> vtkRungeKutta2
        C++: vtkRungeKutta2 *NewInstance()
        """
        return vtkRungeKutta2

    def SafeDownCast(self, o): # real signature unknown; restored from __doc__
        """
        SafeDownCast(o:vtkObjectBase) -> vtkRungeKutta2
        C++: static vtkRungeKutta2 *SafeDownCast(vtkObjectBase *o)
        """
        return vtkRungeKutta2

    def __delattr__(self, *args, **kwargs): # real signature unknown
        """ Implement delattr(self, name). """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setattr__(self, *args, **kwargs): # real signature unknown
        """ Implement setattr(self, name, value). """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass

    __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Pointer to the C++ object."""


    __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkRungeKutta2', 'IsTypeOf': <method 'IsTypeOf' of 'vtkmodules.vtkCommonMath.vtkRungeKutta2' objects>, 'IsA': <method 'IsA' of 'vtkmodules.vtkCommonMath.vtkRungeKutta2' objects>, 'SafeDownCast': <method 'SafeDownCast' of 'vtkmodules.vtkCommonMath.vtkRungeKutta2' objects>, 'NewInstance': <method 'NewInstance' of 'vtkmodules.vtkCommonMath.vtkRungeKutta2' objects>, 'GetNumberOfGenerationsFromBaseType': <method 'GetNumberOfGenerationsFromBaseType' of 'vtkmodules.vtkCommonMath.vtkRungeKutta2' objects>, 'GetNumberOfGenerationsFromBase': <method 'GetNumberOfGenerationsFromBase' of 'vtkmodules.vtkCommonMath.vtkRungeKutta2' objects>, 'ComputeNextStep': <method 'ComputeNextStep' of 'vtkmodules.vtkCommonMath.vtkRungeKutta2' objects>, '__new__': <built-in method __new__ of type object at 0x00007FF85F0581D0>, '__repr__': <slot wrapper '__repr__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta2' objects>, '__str__': <slot wrapper '__str__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta2' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta2' objects>, '__setattr__': <slot wrapper '__setattr__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta2' objects>, '__delattr__': <slot wrapper '__delattr__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta2' objects>, '__dict__': <attribute '__dict__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta2' objects>, '__this__': <attribute '__this__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta2' objects>, '__doc__': 'vtkRungeKutta2 - Integrate an initial value problem using 2nd order\\nRunge-Kutta method.\\n\\nSuperclass: vtkInitialValueProblemSolver\\n\\nThis is a concrete sub-class of vtkInitialValueProblemSolver. It uses\\na 2nd order Runge-Kutta method to obtain the values of a set of\\nfunctions at the next time step.\\n\\n@sa\\nvtkInitialValueProblemSolver vtkRungeKutta4 vtkRungeKutta45\\nvtkFunctionSet\\n\\n'})"
    __vtkname__ = 'vtkRungeKutta2'


class vtkRungeKutta4(vtkInitialValueProblemSolver):
    """
    vtkRungeKutta4 - Integrate an initial value problem using 4th order
    Runge-Kutta method.
    
    Superclass: vtkInitialValueProblemSolver
    
    This is a concrete sub-class of vtkInitialValueProblemSolver. It uses
    a 4th order Runge-Kutta method to obtain the values of a set of
    functions at the next time step.
    
    @sa
    vtkInitialValueProblemSolver vtkRungeKutta45 vtkRungeKutta2
    vtkFunctionSet
    """
    def ComputeNextStep(self, xprev, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        ComputeNextStep(self, xprev:[float, ...], xnext:[float, ...],
            t:float, delT:float, maxError:float, error:float,
            userData:Pointer) -> int
        C++: int ComputeNextStep(double *xprev, double *xnext, double t,
            double &delT, double maxError, double &error, void *userData)
            override;
        ComputeNextStep(self, xprev:[float, ...], dxprev:[float, ...],
            xnext:[float, ...], t:float, delT:float, maxError:float,
            error:float, userData:Pointer) -> int
        C++: int ComputeNextStep(double *xprev, double *dxprev,
            double *xnext, double t, double &delT, double maxError,
            double &error, void *userData) override;
        ComputeNextStep(self, xprev:[float, ...], xnext:[float, ...],
            t:float, delT:float, delTActual:float, minStep:float,
            maxStep:float, maxError:float, error:float, userData:Pointer)
            -> int
        C++: int ComputeNextStep(double *xprev, double *xnext, double t,
            double &delT, double &delTActual, double minStep,
            double maxStep, double maxError, double &error,
            void *userData) override;
        ComputeNextStep(self, xprev:[float, ...], dxprev:[float, ...],
            xnext:[float, ...], t:float, delT:float, delTActual:float,
            minStep:float, maxStep:float, maxError:float, error:float,
            userData:Pointer) -> int
        C++: int ComputeNextStep(double *xprev, double *dxprev,
            double *xnext, double t, double &delT, double &delTActual,
            double minStep, double maxStep, double maxError,
            double &error, void *userData) override;
        ComputeNextStep(self, xprev:[float, ...], xnext:[float, ...],
            t:float, delT:float, maxError:float, error:float) -> int
        C++: virtual int ComputeNextStep(double *xprev, double *xnext,
            double t, double &delT, double maxError, double &error)
        
        Given initial values, xprev , initial time, t and a requested
        time interval, delT calculate values of x at t+delT (xnext).
        delTActual is always equal to delT. Since this class can not
        provide an estimate for the error error is set to 0. maxStep,
        minStep and maxError are unused. This metho ...
         [Truncated]
        """
        pass

    def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBase(self, type:str) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given 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.
        """
        return 0

    def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBaseType(type:str) -> 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.
        """
        return 0

    def IsA(self, type): # real signature unknown; restored from __doc__
        """
        IsA(self, type:str) -> 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.
        """
        return 0

    def IsTypeOf(self, type): # real signature unknown; restored from __doc__
        """
        IsTypeOf(type:str) -> 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.
        """
        return 0

    def NewInstance(self): # real signature unknown; restored from __doc__
        """
        NewInstance(self) -> vtkRungeKutta4
        C++: vtkRungeKutta4 *NewInstance()
        """
        return vtkRungeKutta4

    def SafeDownCast(self, o): # real signature unknown; restored from __doc__
        """
        SafeDownCast(o:vtkObjectBase) -> vtkRungeKutta4
        C++: static vtkRungeKutta4 *SafeDownCast(vtkObjectBase *o)
        """
        return vtkRungeKutta4

    def __delattr__(self, *args, **kwargs): # real signature unknown
        """ Implement delattr(self, name). """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setattr__(self, *args, **kwargs): # real signature unknown
        """ Implement setattr(self, name, value). """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass

    __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Pointer to the C++ object."""


    __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkRungeKutta4', 'IsTypeOf': <method 'IsTypeOf' of 'vtkmodules.vtkCommonMath.vtkRungeKutta4' objects>, 'IsA': <method 'IsA' of 'vtkmodules.vtkCommonMath.vtkRungeKutta4' objects>, 'SafeDownCast': <method 'SafeDownCast' of 'vtkmodules.vtkCommonMath.vtkRungeKutta4' objects>, 'NewInstance': <method 'NewInstance' of 'vtkmodules.vtkCommonMath.vtkRungeKutta4' objects>, 'GetNumberOfGenerationsFromBaseType': <method 'GetNumberOfGenerationsFromBaseType' of 'vtkmodules.vtkCommonMath.vtkRungeKutta4' objects>, 'GetNumberOfGenerationsFromBase': <method 'GetNumberOfGenerationsFromBase' of 'vtkmodules.vtkCommonMath.vtkRungeKutta4' objects>, 'ComputeNextStep': <method 'ComputeNextStep' of 'vtkmodules.vtkCommonMath.vtkRungeKutta4' objects>, '__new__': <built-in method __new__ of type object at 0x00007FF85F058520>, '__repr__': <slot wrapper '__repr__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta4' objects>, '__str__': <slot wrapper '__str__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta4' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta4' objects>, '__setattr__': <slot wrapper '__setattr__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta4' objects>, '__delattr__': <slot wrapper '__delattr__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta4' objects>, '__dict__': <attribute '__dict__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta4' objects>, '__this__': <attribute '__this__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta4' objects>, '__doc__': 'vtkRungeKutta4 - Integrate an initial value problem using 4th order\\nRunge-Kutta method.\\n\\nSuperclass: vtkInitialValueProblemSolver\\n\\nThis is a concrete sub-class of vtkInitialValueProblemSolver. It uses\\na 4th order Runge-Kutta method to obtain the values of a set of\\nfunctions at the next time step.\\n\\n@sa\\nvtkInitialValueProblemSolver vtkRungeKutta45 vtkRungeKutta2\\nvtkFunctionSet\\n\\n'})"
    __vtkname__ = 'vtkRungeKutta4'


class vtkRungeKutta45(vtkInitialValueProblemSolver):
    """
    vtkRungeKutta45 - Integrate an initial value problem using 5th order
    Runge-Kutta method with adaptive stepsize control.
    
    Superclass: vtkInitialValueProblemSolver
    
    This is a concrete sub-class of vtkInitialValueProblemSolver. It uses
    a 5th order Runge-Kutta method with stepsize control to obtain the
    values of a set of functions at the next time step. The stepsize is
    adjusted by calculating an estimated error using an embedded 4th
    order Runge-Kutta formula: Press, W. H. et al., 1992, Numerical
    Recipes in Fortran, Second Edition, Cambridge University Press Cash,
    J.R. and Karp, A.H. 1990, ACM Transactions on Mathematical Software,
    vol 16, pp 201-222
    
    @sa
    vtkInitialValueProblemSolver vtkRungeKutta4 vtkRungeKutta2
    vtkFunctionSet
    """
    def ComputeNextStep(self, xprev, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        ComputeNextStep(self, xprev:[float, ...], xnext:[float, ...],
            t:float, delT:float, maxError:float, error:float,
            userData:Pointer) -> int
        C++: int ComputeNextStep(double *xprev, double *xnext, double t,
            double &delT, double maxError, double &error, void *userData)
            override;
        ComputeNextStep(self, xprev:[float, ...], dxprev:[float, ...],
            xnext:[float, ...], t:float, delT:float, maxError:float,
            error:float, userData:Pointer) -> int
        C++: int ComputeNextStep(double *xprev, double *dxprev,
            double *xnext, double t, double &delT, double maxError,
            double &error, void *userData) override;
        ComputeNextStep(self, xprev:[float, ...], xnext:[float, ...],
            t:float, delT:float, delTActual:float, minStep:float,
            maxStep:float, maxError:float, error:float, userData:Pointer)
            -> int
        C++: int ComputeNextStep(double *xprev, double *xnext, double t,
            double &delT, double &delTActual, double minStep,
            double maxStep, double maxError, double &error,
            void *userData) override;
        ComputeNextStep(self, xprev:[float, ...], dxprev:[float, ...],
            xnext:[float, ...], t:float, delT:float, delTActual:float,
            minStep:float, maxStep:float, maxError:float, estErr:float,
            userData:Pointer) -> int
        C++: int ComputeNextStep(double *xprev, double *dxprev,
            double *xnext, double t, double &delT, double &delTActual,
            double minStep, double maxStep, double maxError,
            double &estErr, void *userData) override;
        ComputeNextStep(self, xprev:[float, ...], xnext:[float, ...],
            t:float, delT:float, maxError:float, error:float) -> int
        C++: virtual int ComputeNextStep(double *xprev, double *xnext,
            double t, double &delT, double maxError, double &error)
        
        Given initial values, xprev , initial time, t and a requested
        time interval, delT calculate values of x at t+delTActual
        (xnext). Possibly delTActual != delT. This may occur because this
        solver supports adaptive stepsize control. It tries to change to
        stepsize such that the (estimated) e ...
         [Truncated]
        """
        pass

    def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBase(self, type:str) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given 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.
        """
        return 0

    def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBaseType(type:str) -> 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.
        """
        return 0

    def IsA(self, type): # real signature unknown; restored from __doc__
        """
        IsA(self, type:str) -> 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.
        """
        return 0

    def IsTypeOf(self, type): # real signature unknown; restored from __doc__
        """
        IsTypeOf(type:str) -> 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.
        """
        return 0

    def NewInstance(self): # real signature unknown; restored from __doc__
        """
        NewInstance(self) -> vtkRungeKutta45
        C++: vtkRungeKutta45 *NewInstance()
        """
        return vtkRungeKutta45

    def SafeDownCast(self, o): # real signature unknown; restored from __doc__
        """
        SafeDownCast(o:vtkObjectBase) -> vtkRungeKutta45
        C++: static vtkRungeKutta45 *SafeDownCast(vtkObjectBase *o)
        """
        return vtkRungeKutta45

    def __delattr__(self, *args, **kwargs): # real signature unknown
        """ Implement delattr(self, name). """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setattr__(self, *args, **kwargs): # real signature unknown
        """ Implement setattr(self, name, value). """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass

    __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Pointer to the C++ object."""


    __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkRungeKutta45', 'IsTypeOf': <method 'IsTypeOf' of 'vtkmodules.vtkCommonMath.vtkRungeKutta45' objects>, 'IsA': <method 'IsA' of 'vtkmodules.vtkCommonMath.vtkRungeKutta45' objects>, 'SafeDownCast': <method 'SafeDownCast' of 'vtkmodules.vtkCommonMath.vtkRungeKutta45' objects>, 'NewInstance': <method 'NewInstance' of 'vtkmodules.vtkCommonMath.vtkRungeKutta45' objects>, 'GetNumberOfGenerationsFromBaseType': <method 'GetNumberOfGenerationsFromBaseType' of 'vtkmodules.vtkCommonMath.vtkRungeKutta45' objects>, 'GetNumberOfGenerationsFromBase': <method 'GetNumberOfGenerationsFromBase' of 'vtkmodules.vtkCommonMath.vtkRungeKutta45' objects>, 'ComputeNextStep': <method 'ComputeNextStep' of 'vtkmodules.vtkCommonMath.vtkRungeKutta45' objects>, '__new__': <built-in method __new__ of type object at 0x00007FF85F058870>, '__repr__': <slot wrapper '__repr__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta45' objects>, '__str__': <slot wrapper '__str__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta45' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta45' objects>, '__setattr__': <slot wrapper '__setattr__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta45' objects>, '__delattr__': <slot wrapper '__delattr__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta45' objects>, '__dict__': <attribute '__dict__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta45' objects>, '__this__': <attribute '__this__' of 'vtkmodules.vtkCommonMath.vtkRungeKutta45' objects>, '__doc__': 'vtkRungeKutta45 - Integrate an initial value problem using 5th order\\nRunge-Kutta method with adaptive stepsize control.\\n\\nSuperclass: vtkInitialValueProblemSolver\\n\\nThis is a concrete sub-class of vtkInitialValueProblemSolver. It uses\\na 5th order Runge-Kutta method with stepsize control to obtain the\\nvalues of a set of functions at the next time step. The stepsize is\\nadjusted by calculating an estimated error using an embedded 4th\\norder Runge-Kutta formula: Press, W. H. et al., 1992, Numerical\\nRecipes in Fortran, Second Edition, Cambridge University Press Cash,\\nJ.R. and Karp, A.H. 1990, ACM Transactions on Mathematical Software,\\nvol 16, pp 201-222\\n\\n@sa\\nvtkInitialValueProblemSolver vtkRungeKutta4 vtkRungeKutta2\\nvtkFunctionSet\\n\\n'})"
    __vtkname__ = 'vtkRungeKutta45'


class vtkTuple_IdLi2EE(object):
    """
    vtkTuple() -> vtkTuple
    C++: vtkTuple()
    vtkTuple(scalar:float) -> vtkTuple
    C++: explicit vtkTuple(const double &scalar)
    vtkTuple(init:(float, float)) -> vtkTuple
    C++: explicit vtkTuple(const double *init)
    vtkTuple(__a:vtkTuple_IdLi2EE) -> vtkTuple
    C++: vtkTuple(const &vtkTuple<double, 2>)
    
    vtkTuple<double, 2> - templated base type for containers of constant
    size.
    
    This class is a templated data type for storing and manipulating
    tuples.
    """
    def Compare(self, other, tol): # real signature unknown; restored from __doc__
        """
        Compare(self, other:vtkTuple_IdLi2EE, tol:float) -> bool
        C++: bool Compare(const vtkTuple<double, 2> &other,
            const double &tol)
        
        Equality operator with a tolerance to allow fuzzy comparisons.
        """
        return False

    def GetData(self): # real signature unknown; restored from __doc__
        """
        GetData(self) -> Pointer
        C++: double *GetData()
        
        Get a pointer to the underlying data of the tuple.
        """
        pass

    def GetSize(self): # real signature unknown; restored from __doc__
        """
        GetSize(self) -> int
        C++: int GetSize()
        
        Get the size of the tuple.
        """
        return 0

    def __delitem__(self, *args, **kwargs): # real signature unknown
        """ Delete self[key]. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, *args, **kwargs): # real signature unknown
        """ Return self[key]. """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setitem__(self, *args, **kwargs): # real signature unknown
        """ Set self[key] to value. """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass


class vtkTuple_IdLi3EE(object):
    """
    vtkTuple() -> vtkTuple
    C++: vtkTuple()
    vtkTuple(scalar:float) -> vtkTuple
    C++: explicit vtkTuple(const double &scalar)
    vtkTuple(init:(float, float, float)) -> vtkTuple
    C++: explicit vtkTuple(const double *init)
    vtkTuple(__a:vtkTuple_IdLi3EE) -> vtkTuple
    C++: vtkTuple(const &vtkTuple<double, 3>)
    
    vtkTuple<double, 3> - templated base type for containers of constant
    size.
    
    This class is a templated data type for storing and manipulating
    tuples.
    """
    def Compare(self, other, tol): # real signature unknown; restored from __doc__
        """
        Compare(self, other:vtkTuple_IdLi3EE, tol:float) -> bool
        C++: bool Compare(const vtkTuple<double, 3> &other,
            const double &tol)
        
        Equality operator with a tolerance to allow fuzzy comparisons.
        """
        return False

    def GetData(self): # real signature unknown; restored from __doc__
        """
        GetData(self) -> Pointer
        C++: double *GetData()
        
        Get a pointer to the underlying data of the tuple.
        """
        pass

    def GetSize(self): # real signature unknown; restored from __doc__
        """
        GetSize(self) -> int
        C++: int GetSize()
        
        Get the size of the tuple.
        """
        return 0

    def __delitem__(self, *args, **kwargs): # real signature unknown
        """ Delete self[key]. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, *args, **kwargs): # real signature unknown
        """ Return self[key]. """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setitem__(self, *args, **kwargs): # real signature unknown
        """ Set self[key] to value. """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass


class vtkTuple_IfLi2EE(object):
    """
    vtkTuple() -> vtkTuple
    C++: vtkTuple()
    vtkTuple(scalar:float) -> vtkTuple
    C++: explicit vtkTuple(const float &scalar)
    vtkTuple(init:(float, float)) -> vtkTuple
    C++: explicit vtkTuple(const float *init)
    vtkTuple(__a:vtkTuple_IfLi2EE) -> vtkTuple
    C++: vtkTuple(const &vtkTuple<float, 2>)
    
    vtkTuple<float, 2> - templated base type for containers of constant
    size.
    
    This class is a templated data type for storing and manipulating
    tuples.
    """
    def Compare(self, other, tol): # real signature unknown; restored from __doc__
        """
        Compare(self, other:vtkTuple_IfLi2EE, tol:float) -> bool
        C++: bool Compare(const vtkTuple<float, 2> &other,
            const float &tol)
        
        Equality operator with a tolerance to allow fuzzy comparisons.
        """
        return False

    def GetData(self): # real signature unknown; restored from __doc__
        """
        GetData(self) -> Pointer
        C++: float *GetData()
        
        Get a pointer to the underlying data of the tuple.
        """
        pass

    def GetSize(self): # real signature unknown; restored from __doc__
        """
        GetSize(self) -> int
        C++: int GetSize()
        
        Get the size of the tuple.
        """
        return 0

    def __delitem__(self, *args, **kwargs): # real signature unknown
        """ Delete self[key]. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, *args, **kwargs): # real signature unknown
        """ Return self[key]. """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setitem__(self, *args, **kwargs): # real signature unknown
        """ Set self[key] to value. """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass


class vtkTuple_IfLi3EE(object):
    """
    vtkTuple() -> vtkTuple
    C++: vtkTuple()
    vtkTuple(scalar:float) -> vtkTuple
    C++: explicit vtkTuple(const float &scalar)
    vtkTuple(init:(float, float, float)) -> vtkTuple
    C++: explicit vtkTuple(const float *init)
    vtkTuple(__a:vtkTuple_IfLi3EE) -> vtkTuple
    C++: vtkTuple(const &vtkTuple<float, 3>)
    
    vtkTuple<float, 3> - templated base type for containers of constant
    size.
    
    This class is a templated data type for storing and manipulating
    tuples.
    """
    def Compare(self, other, tol): # real signature unknown; restored from __doc__
        """
        Compare(self, other:vtkTuple_IfLi3EE, tol:float) -> bool
        C++: bool Compare(const vtkTuple<float, 3> &other,
            const float &tol)
        
        Equality operator with a tolerance to allow fuzzy comparisons.
        """
        return False

    def GetData(self): # real signature unknown; restored from __doc__
        """
        GetData(self) -> Pointer
        C++: float *GetData()
        
        Get a pointer to the underlying data of the tuple.
        """
        pass

    def GetSize(self): # real signature unknown; restored from __doc__
        """
        GetSize(self) -> int
        C++: int GetSize()
        
        Get the size of the tuple.
        """
        return 0

    def __delitem__(self, *args, **kwargs): # real signature unknown
        """ Delete self[key]. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, *args, **kwargs): # real signature unknown
        """ Return self[key]. """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setitem__(self, *args, **kwargs): # real signature unknown
        """ Set self[key] to value. """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass


class vtkTuple_IhLi2EE(object):
    """
    vtkTuple() -> vtkTuple
    C++: vtkTuple()
    vtkTuple(scalar:int) -> vtkTuple
    C++: explicit vtkTuple(const unsigned char &scalar)
    vtkTuple(init:(int, int)) -> vtkTuple
    C++: explicit vtkTuple(const unsigned char *init)
    vtkTuple(__a:vtkTuple_IhLi2EE) -> vtkTuple
    C++: vtkTuple(const &vtkTuple<unsigned char, 2>)
    
    vtkTuple<unsigned char, 2> - templated base type for containers of
    constant size.
    
    This class is a templated data type for storing and manipulating
    tuples.
    """
    def Compare(self, other, tol): # real signature unknown; restored from __doc__
        """
        Compare(self, other:vtkTuple_IhLi2EE, tol:int) -> bool
        C++: bool Compare(const vtkTuple<unsigned char, 2> &other,
            const unsigned char &tol)
        
        Equality operator with a tolerance to allow fuzzy comparisons.
        """
        return False

    def GetData(self): # real signature unknown; restored from __doc__
        """
        GetData(self) -> Pointer
        C++: unsigned char *GetData()
        
        Get a pointer to the underlying data of the tuple.
        """
        pass

    def GetSize(self): # real signature unknown; restored from __doc__
        """
        GetSize(self) -> int
        C++: int GetSize()
        
        Get the size of the tuple.
        """
        return 0

    def __delitem__(self, *args, **kwargs): # real signature unknown
        """ Delete self[key]. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, *args, **kwargs): # real signature unknown
        """ Return self[key]. """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setitem__(self, *args, **kwargs): # real signature unknown
        """ Set self[key] to value. """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass


class vtkTuple_IhLi3EE(object):
    """
    vtkTuple() -> vtkTuple
    C++: vtkTuple()
    vtkTuple(scalar:int) -> vtkTuple
    C++: explicit vtkTuple(const unsigned char &scalar)
    vtkTuple(init:(int, int, int)) -> vtkTuple
    C++: explicit vtkTuple(const unsigned char *init)
    vtkTuple(__a:vtkTuple_IhLi3EE) -> vtkTuple
    C++: vtkTuple(const &vtkTuple<unsigned char, 3>)
    
    vtkTuple<unsigned char, 3> - templated base type for containers of
    constant size.
    
    This class is a templated data type for storing and manipulating
    tuples.
    """
    def Compare(self, other, tol): # real signature unknown; restored from __doc__
        """
        Compare(self, other:vtkTuple_IhLi3EE, tol:int) -> bool
        C++: bool Compare(const vtkTuple<unsigned char, 3> &other,
            const unsigned char &tol)
        
        Equality operator with a tolerance to allow fuzzy comparisons.
        """
        return False

    def GetData(self): # real signature unknown; restored from __doc__
        """
        GetData(self) -> Pointer
        C++: unsigned char *GetData()
        
        Get a pointer to the underlying data of the tuple.
        """
        pass

    def GetSize(self): # real signature unknown; restored from __doc__
        """
        GetSize(self) -> int
        C++: int GetSize()
        
        Get the size of the tuple.
        """
        return 0

    def __delitem__(self, *args, **kwargs): # real signature unknown
        """ Delete self[key]. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, *args, **kwargs): # real signature unknown
        """ Return self[key]. """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setitem__(self, *args, **kwargs): # real signature unknown
        """ Set self[key] to value. """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass


class vtkTuple_IhLi4EE(object):
    """
    vtkTuple() -> vtkTuple
    C++: vtkTuple()
    vtkTuple(scalar:int) -> vtkTuple
    C++: explicit vtkTuple(const unsigned char &scalar)
    vtkTuple(init:(int, int, int, int)) -> vtkTuple
    C++: explicit vtkTuple(const unsigned char *init)
    vtkTuple(__a:vtkTuple_IhLi4EE) -> vtkTuple
    C++: vtkTuple(const &vtkTuple<unsigned char, 4>)
    
    vtkTuple<unsigned char, 4> - templated base type for containers of
    constant size.
    
    This class is a templated data type for storing and manipulating
    tuples.
    """
    def Compare(self, other, tol): # real signature unknown; restored from __doc__
        """
        Compare(self, other:vtkTuple_IhLi4EE, tol:int) -> bool
        C++: bool Compare(const vtkTuple<unsigned char, 4> &other,
            const unsigned char &tol)
        
        Equality operator with a tolerance to allow fuzzy comparisons.
        """
        return False

    def GetData(self): # real signature unknown; restored from __doc__
        """
        GetData(self) -> Pointer
        C++: unsigned char *GetData()
        
        Get a pointer to the underlying data of the tuple.
        """
        pass

    def GetSize(self): # real signature unknown; restored from __doc__
        """
        GetSize(self) -> int
        C++: int GetSize()
        
        Get the size of the tuple.
        """
        return 0

    def __delitem__(self, *args, **kwargs): # real signature unknown
        """ Delete self[key]. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, *args, **kwargs): # real signature unknown
        """ Return self[key]. """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setitem__(self, *args, **kwargs): # real signature unknown
        """ Set self[key] to value. """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass


class vtkTuple_IiLi2EE(object):
    """
    vtkTuple() -> vtkTuple
    C++: vtkTuple()
    vtkTuple(scalar:int) -> vtkTuple
    C++: explicit vtkTuple(const int &scalar)
    vtkTuple(init:(int, int)) -> vtkTuple
    C++: explicit vtkTuple(const int *init)
    vtkTuple(__a:vtkTuple_IiLi2EE) -> vtkTuple
    C++: vtkTuple(const &vtkTuple<int, 2>)
    
    vtkTuple<int, 2> - templated base type for containers of constant
    size.
    
    This class is a templated data type for storing and manipulating
    tuples.
    """
    def Compare(self, other, tol): # real signature unknown; restored from __doc__
        """
        Compare(self, other:vtkTuple_IiLi2EE, tol:int) -> bool
        C++: bool Compare(const vtkTuple<int, 2> &other, const int &tol)
        
        Equality operator with a tolerance to allow fuzzy comparisons.
        """
        return False

    def GetData(self): # real signature unknown; restored from __doc__
        """
        GetData(self) -> Pointer
        C++: int *GetData()
        
        Get a pointer to the underlying data of the tuple.
        """
        pass

    def GetSize(self): # real signature unknown; restored from __doc__
        """
        GetSize(self) -> int
        C++: int GetSize()
        
        Get the size of the tuple.
        """
        return 0

    def __delitem__(self, *args, **kwargs): # real signature unknown
        """ Delete self[key]. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, *args, **kwargs): # real signature unknown
        """ Return self[key]. """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setitem__(self, *args, **kwargs): # real signature unknown
        """ Set self[key] to value. """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass


class vtkTuple_IiLi3EE(object):
    """
    vtkTuple() -> vtkTuple
    C++: vtkTuple()
    vtkTuple(scalar:int) -> vtkTuple
    C++: explicit vtkTuple(const int &scalar)
    vtkTuple(init:(int, int, int)) -> vtkTuple
    C++: explicit vtkTuple(const int *init)
    vtkTuple(__a:vtkTuple_IiLi3EE) -> vtkTuple
    C++: vtkTuple(const &vtkTuple<int, 3>)
    
    vtkTuple<int, 3> - templated base type for containers of constant
    size.
    
    This class is a templated data type for storing and manipulating
    tuples.
    """
    def Compare(self, other, tol): # real signature unknown; restored from __doc__
        """
        Compare(self, other:vtkTuple_IiLi3EE, tol:int) -> bool
        C++: bool Compare(const vtkTuple<int, 3> &other, const int &tol)
        
        Equality operator with a tolerance to allow fuzzy comparisons.
        """
        return False

    def GetData(self): # real signature unknown; restored from __doc__
        """
        GetData(self) -> Pointer
        C++: int *GetData()
        
        Get a pointer to the underlying data of the tuple.
        """
        pass

    def GetSize(self): # real signature unknown; restored from __doc__
        """
        GetSize(self) -> int
        C++: int GetSize()
        
        Get the size of the tuple.
        """
        return 0

    def __delitem__(self, *args, **kwargs): # real signature unknown
        """ Delete self[key]. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, *args, **kwargs): # real signature unknown
        """ Return self[key]. """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setitem__(self, *args, **kwargs): # real signature unknown
        """ Set self[key] to value. """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass


class vtkTuple_IiLi4EE(object):
    """
    vtkTuple() -> vtkTuple
    C++: vtkTuple()
    vtkTuple(scalar:int) -> vtkTuple
    C++: explicit vtkTuple(const int &scalar)
    vtkTuple(init:(int, int, int, int)) -> vtkTuple
    C++: explicit vtkTuple(const int *init)
    vtkTuple(__a:vtkTuple_IiLi4EE) -> vtkTuple
    C++: vtkTuple(const &vtkTuple<int, 4>)
    
    vtkTuple<int, 4> - templated base type for containers of constant
    size.
    
    This class is a templated data type for storing and manipulating
    tuples.
    """
    def Compare(self, other, tol): # real signature unknown; restored from __doc__
        """
        Compare(self, other:vtkTuple_IiLi4EE, tol:int) -> bool
        C++: bool Compare(const vtkTuple<int, 4> &other, const int &tol)
        
        Equality operator with a tolerance to allow fuzzy comparisons.
        """
        return False

    def GetData(self): # real signature unknown; restored from __doc__
        """
        GetData(self) -> Pointer
        C++: int *GetData()
        
        Get a pointer to the underlying data of the tuple.
        """
        pass

    def GetSize(self): # real signature unknown; restored from __doc__
        """
        GetSize(self) -> int
        C++: int GetSize()
        
        Get the size of the tuple.
        """
        return 0

    def __delitem__(self, *args, **kwargs): # real signature unknown
        """ Delete self[key]. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, *args, **kwargs): # real signature unknown
        """ Return self[key]. """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setitem__(self, *args, **kwargs): # real signature unknown
        """ Set self[key] to value. """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass


# variables with complex values

__loader__ = None # (!) real value is '<_frozen_importlib_external.ExtensionFileLoader object at 0x00000208736DBC50>'

__spec__ = None # (!) real value is "ModuleSpec(name='vtkmodules.vtkCommonMath', loader=<_frozen_importlib_external.ExtensionFileLoader object at 0x00000208736DBC50>, origin='C:\\\\Users\\\\xukai\\\\Downloads\\\\??2\\\\venv\\\\Lib\\\\site-packages\\\\vtkmodules\\\\vtkCommonMath.cp311-win_amd64.pyd')"