python-pytrilinos 10.4.0.dfsg-1ubuntu2 / usr / share / pyshared / PyTrilinos / ML.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.4
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.


"""

PyTrilinos.ML is the python interface to the Trilinos multi-level
preconditioner package ML/MLAPI:

    http://trilinos.sandia.gov/packages/ml

The purpose of ML is to provide multilevel preconditioners to
Trilinos.

ML provides the following user-level classes:

    * BaseObject                - Base class for MLAPI objects
    * CompObject                - FLOP counting base class
    * TimeObject                - Timing base class
    * MultiLevelPreconditioner  - Black-box multilevel preconditioner
    * EpetraBaseOperator        - Base class for interface to Epetra
    * BaseOperator              - Base class for all MLAPI operators
    * Space                     - Defines number of elements and their distribution
    * MultiVector               - MLAPI multivector class
    * Operator                  - MLAPI operator class
    * InverseOperator           - MLAPI inverse operator class
    * PyMatrix                  - Python interface to MLAPI operators

For examples of usage, please consult the following scripts in the
example subdirectory of the PyTrilinos package:

    * exMLAPI.py
    * exMLAPI_Simple.py
    * exMLAPI_AztecOO.py
    * exMLAPI_Iterate.py
    * exMLAPI_PyMatrix.py
    * exMLAPI_Smoother.py

"""


from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_ML', [dirname(__file__)])
        except ImportError:
            import _ML
            return _ML
        if fp is not None:
            try:
                _mod = imp.load_module('_ML', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _ML = swig_import_helper()
    del swig_import_helper
else:
    import _ML
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


import Teuchos
import Epetra
HAVE_INTTYPES_H = _ML.HAVE_INTTYPES_H
HAVE_STDINT_H = _ML.HAVE_STDINT_H

def GetML_Comm(*args):
  """
    GetML_Comm() -> ML_Comm

    ML_Comm*
    MLAPI::GetML_Comm()

    Returns a pointer to the ML_Comm object defined on MPI_COMM_WORLD. 
    """
  return _ML.GetML_Comm(*args)

def GetEpetra_Comm(*args):
  """
    GetEpetra_Comm() -> Comm

    Epetra_Comm&
    MLAPI::GetEpetra_Comm()

    Returns a reference to the Epetra_Comm object defined on
    MPI_COMM_WORLD. 
    """
  return _ML.GetEpetra_Comm(*args)

def Barrier(*args):
  """
    Barrier()

    void MLAPI::Barrier()

    Calls Mpi_Barrier() if MPI is enabled. 
    """
  return _ML.Barrier(*args)

def GetMyPID(*args):
  """
    GetMyPID() -> int

    int MLAPI::GetMyPID()

    Returns the ID of the calling process. 
    """
  return _ML.GetMyPID(*args)

def GetNumProcs(*args):
  """
    GetNumProcs() -> int

    int MLAPI::GetNumProcs()

    Returns the total number of processes in the computation. 
    """
  return _ML.GetNumProcs(*args)

def GetPrintLevel(*args):
  """
    GetPrintLevel() -> int

    int
    MLAPI::GetPrintLevel()

    Retutns the level of output (always 0 if MyPID() != 0). 
    """
  return _ML.GetPrintLevel(*args)

def SetPrintLevel(*args):
  """
    SetPrintLevel(int Level)

    void
    MLAPI::SetPrintLevel(int Level)

    Sets the level of output (from 0 to 10, 0 being verbose). 
    """
  return _ML.SetPrintLevel(*args)

def Init(*args):
  """
    Init()

    void MLAPI::Init()

    Initialize the MLAPI workspace. 
    """
  return _ML.Init(*args)

def Finalize(*args):
  """
    Finalize()

    void MLAPI::Finalize()

    Destroys the MLAPI workspace. 
    """
  return _ML.Finalize(*args)

def GetMatrixType(*args):
  """
    GetMatrixType() -> int

    int
    MLAPI::GetMatrixType() 
    """
  return _ML.GetMatrixType(*args)
class BaseObject(_object):
    """
    Basic class for MLAPI objects.

    BaseObject is the basic class for all MLAPI objects. Currently, it
    contains the label of the object and method Print().

    Marzio Sala, SNL 9214

    C++ includes: MLAPI_BaseObject.h 
    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BaseObject, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BaseObject, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _ML.delete_BaseObject
    __del__ = lambda self : None;
    def SetLabel(self, *args):
        """
        SetLabel(self, string Label)

        void
        MLAPI::BaseObject::SetLabel(const string &Label)

        Sets the Label of this object to Label. 
        """
        return _ML.BaseObject_SetLabel(self, *args)

    def GetLabel(self, *args):
        """
        GetLabel(self) -> string

        const string&
        MLAPI::BaseObject::GetLabel() const

        Returns the Label of this object. 
        """
        return _ML.BaseObject_GetLabel(self, *args)

    def Print(self, *args):
        """
        Print(self, file=None)

        Print a description of the object to the given file object.  If no
        file object is provided, output is to stdout.
        """
        return _ML.BaseObject_Print(self, *args)

    def __str__(self, *args):
        """
        __str__(self) -> str

        Return the description of the object as a string.
        """
        return _ML.BaseObject___str__(self, *args)

BaseObject_swigregister = _ML.BaseObject_swigregister
BaseObject_swigregister(BaseObject)

def GetString(*args):
  """
    GetString(int x) -> string
    GetString(double x) -> string

    string
    MLAPI::GetString(const double &x) 
    """
  return _ML.GetString(*args)


def __lshift__(*args):
  """__lshift__( os, BaseObject obj)"""
  return _ML.__lshift__(*args)
class Space(BaseObject):
    """
    Specifies the number and distribution among processes of elements.

    Marzio Sala, SNL 9214

    C++ includes: MLAPI_Space.h 
    """
    __swig_setmethods__ = {}
    for _s in [BaseObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Space, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Space, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> Space
        __init__(self, int NumGlobalElements, int NumMyElements = -1) -> Space
        __init__(self, Map Map) -> Space
        __init__(self, int numGlobalElements, sequence myGlobalElements) -> Space
        __init__(self, Space RHS) -> Space

        MLAPI::Space::Space(const
        Space &RHS)

        Copy constructor. 
        """
        this = _ML.new_Space(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ML.delete_Space
    __del__ = lambda self : None;
    def Reshape(self, *args):
        """
        Reshape(self)
        Reshape(self, int NumGlobalElements, int NumMyElements = -1)
        Reshape(self, int NumGlobalElements, int NumMyElements)

        void
        MLAPI::Space::Reshape(const int NumGlobalElements, const int
        NumMyElements, const int *MyGlobalElements)

        Reset the dimension of the space by specifying the local number of
        elements and their global numbering (starting from 0). 
        """
        return _ML.Space_Reshape(self, *args)

    def __eq__(self, *args):
        """__eq__(self, Space RHS) -> bool"""
        return _ML.Space___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, Space RHS) -> bool"""
        return _ML.Space___ne__(self, *args)

    def __call__(self, *args):
        """__call__(self, int i) -> int"""
        return _ML.Space___call__(self, *args)

    def GetNumMyElements(self, *args):
        """
        GetNumMyElements(self) -> int

        int
        MLAPI::Space::GetNumMyElements() const

        Returns the local number of elements on the calling process. 
        """
        return _ML.Space_GetNumMyElements(self, *args)

    def GetNumGlobalElements(self, *args):
        """
        GetNumGlobalElements(self) -> int

        int
        MLAPI::Space::GetNumGlobalElements() const

        Returns the global number of elements. 
        """
        return _ML.Space_GetNumGlobalElements(self, *args)

    def GetOffset(self, *args):
        """
        GetOffset(self) -> int

        int
        MLAPI::Space::GetOffset() const

        Returns the global ID of the first element on the calling process (for
        linear distributions only). 
        """
        return _ML.Space_GetOffset(self, *args)

    def IsLinear(self, *args):
        """
        IsLinear(self) -> bool

        bool
        MLAPI::Space::IsLinear() const

        Returns true if the decomposition among processors is linear. 
        """
        return _ML.Space_IsLinear(self, *args)

    def GetMyGlobalElements(self, *args):
        """
        GetMyGlobalElements(self) -> Epetra.SerialDenseVector

        Return an Epetra.SerialDenseVector of global indexes representing the
        elements on this processor.  If the Space is distributed linearly,
        this method returns None.
        """
        return _ML.Space_GetMyGlobalElements(self, *args)

Space_swigregister = _ML.Space_swigregister
Space_swigregister(Space)

def Space_GetMyGlobalElements(*args):
    """
    GetMyGlobalElements(self) -> Epetra.SerialDenseVector

    Return an Epetra.SerialDenseVector of global indexes representing the
    elements on this processor.
    """
    result = _ML.Space_GetMyGlobalElements(*args)
    if result is None:
        offset = args[0].GetOffset()
        data   = range(offset, offset+args[0].GetNumMyElements())
        result = Epetra.IntSerialDenseVector(data)
    return result
Space.GetMyGlobalElements = Space_GetMyGlobalElements

class CompObject(_object):
    """
    Class to count flops.

    Marzio Sala, SNL 9214

    C++ includes: MLAPI_CompObject.h 
    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompObject, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CompObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> CompObject

        MLAPI::CompObject::CompObject()

        Constructor, set counter to 0.0. 
        """
        this = _ML.new_CompObject(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ML.delete_CompObject
    __del__ = lambda self : None;
    def GetFlops(self, *args):
        """
        GetFlops(self) -> double

        double
        MLAPI::CompObject::GetFlops() const

        Returns the internal counter of flops. 
        """
        return _ML.CompObject_GetFlops(self, *args)

    def SetFlops(self, *args):
        """
        SetFlops(self, double Flops)

        void
        MLAPI::CompObject::SetFlops(double Flops) const

        Sets internal counter to Flops. 
        """
        return _ML.CompObject_SetFlops(self, *args)

    def UpdateFlops(self, *args):
        """
        UpdateFlops(self, double Flops)

        void
        MLAPI::CompObject::UpdateFlops(double Flops) const

        Updates internal counter by summing Flops. 
        """
        return _ML.CompObject_UpdateFlops(self, *args)

CompObject_swigregister = _ML.CompObject_swigregister
CompObject_swigregister(CompObject)

class TimeObject(_object):
    """
    Class to track time spent in an object.

    Marzio Sala, SNL 9214

    C++ includes: MLAPI_TimeObject.h 
    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TimeObject, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TimeObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> TimeObject

        MLAPI::TimeObject::TimeObject()

        Constructor, set counter to 0.0. 
        """
        this = _ML.new_TimeObject(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ML.delete_TimeObject
    __del__ = lambda self : None;
    def ResetTimer(self, *args):
        """
        ResetTimer(self)

        void
        MLAPI::TimeObject::ResetTimer() const

        Resets the internal timer. 
        """
        return _ML.TimeObject_ResetTimer(self, *args)

    def UpdateTime(self, *args):
        """
        UpdateTime(self)
        UpdateTime(self, double t)

        void
        MLAPI::TimeObject::UpdateTime(double t) const

        Updates the internal timer with input value t. 
        """
        return _ML.TimeObject_UpdateTime(self, *args)

    def GetTime(self, *args):
        """
        GetTime(self) -> double

        double
        MLAPI::TimeObject::GetTime() const

        Returns the internally stored counter. 
        """
        return _ML.TimeObject_GetTime(self, *args)

TimeObject_swigregister = _ML.TimeObject_swigregister
TimeObject_swigregister(TimeObject)

class BaseOperator(BaseObject):
    """
    Base class for all MLAPI objects.

    Marzio Sala, SNL 9214.

    C++ includes: MLAPI_BaseOperator.h 
    """
    __swig_setmethods__ = {}
    for _s in [BaseObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BaseOperator, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BaseOperator, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _ML.delete_BaseOperator
    __del__ = lambda self : None;
    def Apply(self, *args):
        """
        Apply(self, MultiVector LHS, MultiVector RHS) -> int

        virtual int
        MLAPI::BaseOperator::Apply(const MultiVector &LHS, MultiVector &RHS)
        const =0

        Applies the operator to X, using Y as starting solution. Returns the
        solution in Y. 
        """
        return _ML.BaseOperator_Apply(self, *args)

    def GetOperatorDomainSpace(self, *args):
        """
        GetOperatorDomainSpace(self) -> Space

        virtual const Space MLAPI::BaseOperator::GetOperatorDomainSpace()
        const =0

        Returns a copy of the domain space of this object. 
        """
        return _ML.BaseOperator_GetOperatorDomainSpace(self, *args)

    def GetOperatorRangeSpace(self, *args):
        """
        GetOperatorRangeSpace(self) -> Space

        virtual const Space MLAPI::BaseOperator::GetOperatorRangeSpace() const
        =0

        Returns a copy of the range space of this object. 
        """
        return _ML.BaseOperator_GetOperatorRangeSpace(self, *args)

    def __init__(self, *args): 
        """__init__(self) -> BaseOperator"""
        if self.__class__ == BaseOperator:
            _self = None
        else:
            _self = self
        this = _ML.new_BaseOperator(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _ML.disown_BaseOperator(self)
        return weakref_proxy(self)
BaseOperator_swigregister = _ML.BaseOperator_swigregister
BaseOperator_swigregister(BaseOperator)

class DoubleVector(_object):
    """Proxy of C++ MLAPI::DoubleVector class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, int size) -> DoubleVector
        __init__(self, double ptr) -> DoubleVector

        MLAPI::DoubleVector::DoubleVector(double *ptr) 
        """
        this = _ML.new_DoubleVector(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ML.delete_DoubleVector
    __del__ = lambda self : None;
    def Values(self, *args):
        """
        Values(self) -> double
        Values(self) -> double

        const double*
        MLAPI::DoubleVector::Values() const 
        """
        return _ML.DoubleVector_Values(self, *args)

DoubleVector_swigregister = _ML.DoubleVector_swigregister
DoubleVector_swigregister(DoubleVector)

class MultiVector(BaseObject,CompObject,TimeObject):
    """
    Basic class for distributed double-precision vectors.

    Marzio Sala, SNL 9214.

    C++ includes: MLAPI_MultiVector.h 
    """
    __swig_setmethods__ = {}
    for _s in [BaseObject,CompObject,TimeObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiVector, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseObject,CompObject,TimeObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiVector, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _ML.delete_MultiVector
    __del__ = lambda self : None;
    def Reshape(self, *args):
        """
        Reshape(self)
        Reshape(self, Space S, int NumVectors = 1, bool SetToZero = True)

        void
        MLAPI::MultiVector::Reshape(const Space &S, const int NumVectors=1,
        const bool SetToZero=true)

        Sets the space of this vector. 
        """
        return _ML.MultiVector_Reshape(self, *args)

    def Append(self, *args):
        """
        Append(self, int NumVectors = 1, bool SetToZero = True)
        Append(self, MultiVector rhs)

        void
        MLAPI::MultiVector::Append(MultiVector rhs)

        Appends a new vector. 
        """
        return _ML.MultiVector_Append(self, *args)

    def Delete(self, *args):
        """
        Delete(self, int v)

        Deletes the v-th vector within the MultiVector.

        void
        MLAPI::MultiVector::Delete(const int v)

        Deletes the last vector. 
        """
        return _ML.MultiVector_Delete(self, *args)

    def GetVectorSpace(self, *args):
        """
        GetVectorSpace(self) -> Space
        GetVectorSpace(self) -> Space

        Space&
        MLAPI::MultiVector::GetVectorSpace()

        Returns the Space on which this vector is defined (non-const). 
        """
        return _ML.MultiVector_GetVectorSpace(self, *args)

    def GetNumVectors(self, *args):
        """
        GetNumVectors(self) -> int

        int
        MLAPI::MultiVector::GetNumVectors() const

        Returns the number of vectors. 
        """
        return _ML.MultiVector_GetNumVectors(self, *args)

    def GetMyLength(self, *args):
        """
        GetMyLength(self) -> int

        int
        MLAPI::MultiVector::GetMyLength() const

        Returns the local length of each vector. 
        """
        return _ML.MultiVector_GetMyLength(self, *args)

    def GetGlobalLength(self, *args):
        """
        GetGlobalLength(self) -> int

        int
        MLAPI::MultiVector::GetGlobalLength() const

        Returns the global length of each vector. 
        """
        return _ML.MultiVector_GetGlobalLength(self, *args)

    def GetValues(self, *args):
        """
        GetValues(self, int v) -> numpy.ndarray

        Returns a 1D numpy array representing the v-th vector in the
        MultiVector.

        const double*
        MLAPI::MultiVector::GetValues(const int v) const

        Returns a pointer to the double array (const version). 
        """
        return _ML.MultiVector_GetValues(self, *args)

    def Update(self, *args):
        """
        Update(self, double alpha, int v = -1)
        Update(self, MultiVector rhs)
        Update(self, double alpha, MultiVector rhs)
        Update(self, double alpha, MultiVector x, double beta, MultiVector y)
        Update(self, double alpha, MultiVector rhs, double beta)

        void
        MLAPI::MultiVector::Update(double alpha, const MultiVector &rhs,
        double beta)

        Sets this = alpha * rhs + beta * this. 
        """
        return _ML.MultiVector_Update(self, *args)

    def DotProduct(self, *args):
        """
        DotProduct(self, MultiVector rhs, int v = -1) -> double

        double
        MLAPI::MultiVector::DotProduct(const MultiVector &rhs, int v=-1) const

        Computes the dot product between this vector and rhs. 
        """
        return _ML.MultiVector_DotProduct(self, *args)

    def Norm2(self, *args):
        """
        Norm2(self, int v = -1) -> double

        double
        MLAPI::MultiVector::Norm2(int v=-1) const

        Computes the 2-norm of this vector. 
        """
        return _ML.MultiVector_Norm2(self, *args)

    def NormInf(self, *args):
        """
        NormInf(self, int v = -1) -> double

        double
        MLAPI::MultiVector::NormInf(int v=-1) const

        Computes the infinite norm of this vector. 
        """
        return _ML.MultiVector_NormInf(self, *args)

    def NormOne(self, *args):
        """
        NormOne(self, int v = -1) -> double

        double
        MLAPI::MultiVector::NormOne(int v=-1) const

        Computes the one norm of this vector. 
        """
        return _ML.MultiVector_NormOne(self, *args)

    def Reciprocal(self, *args):
        """
        Reciprocal(self, int v = -1)

        void
        MLAPI::MultiVector::Reciprocal(int v=-1)

        Replaces each element of the vector with its reciprocal. 
        """
        return _ML.MultiVector_Reciprocal(self, *args)

    def Scale(self, *args):
        """
        Scale(self, double Factor, int v = -1)

        void
        MLAPI::MultiVector::Scale(const double Factor, int v=-1)

        Scales each element by the specified factor. 
        """
        return _ML.MultiVector_Scale(self, *args)

    def Random(self, *args):
        """
        Random(self, int v = -1)

        void
        MLAPI::MultiVector::Random(int v=-1)

        Populates the vector with random elements. 
        """
        return _ML.MultiVector_Random(self, *args)

    def Sort(self, *args):
        """
        Sort(self, int v = -1, bool IsIncreasing = False)

        void
        MLAPI::MultiVector::Sort(int v=-1, const bool IsIncreasing=false)

        Sorts the component of the vector. 
        """
        return _ML.MultiVector_Sort(self, *args)

    def IsAlias(self, *args):
        """
        IsAlias(self, MultiVector rhs) -> bool

        bool
        MLAPI::MultiVector::IsAlias(const MultiVector &rhs) const 
        """
        return _ML.MultiVector_IsAlias(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> MultiVector
        __init__(self, Space VectorSpace, int NumVectors = 1, bool SetToZero = True) -> MultiVector
        __init__(self, MultiVector rhs) -> MultiVector
        __init__(self, Space vectorSpace, PyObject pyValues) -> MultiVector

        MLAPI::MultiVector::MultiVector(const MultiVector &rhs)

        Copy constructor. 
        """
        this = _ML.new_MultiVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def __add__(self, *args):
        """
        __add__(self, MultiVector rhs) -> MultiVector

        Element-wise addition operator.
        """
        return _ML.MultiVector___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(self, MultiVector rhs) -> MultiVector

        Element-wise subtraction operator.
        """
        return _ML.MultiVector___sub__(self, *args)

    def __mul__(self, *args):
        """
        __mul__(self, MultiVector rhs) -> float

          Dot-product multiplication operator.

        __mul__(self, double rhs) -> MultiVector
        __mul__(self, int rhs) -> MultiVector

          Scalar multiplication operators.
        """
        return _ML.MultiVector___mul__(self, *args)

    def __rmul__(self, *args):
        """
        __rmul__(self, double lhs) -> MultiVector
        __rmul__(self, int lhs) -> MultiVector

        Scalar 'reverse' multiplication operators.
        """
        return _ML.MultiVector___rmul__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PyObject index, int v, PyObject value)

        Argument index can be an integer or slice index into a vector.
        Argument v must be an integer specifying the desired vector within the
        MultiVector.  The value argument must have a shape that matches the
        shape of the index.
        """
        return _ML.MultiVector___setitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PyObject index, int v) -> PyObject

        Argument index can be an integer or slice index into a vector.
        Argument v must be an integer specifying the desired vector within the
        MultiVector.  The returned PyObject will be either a scalar or an
        array with the same shape as the index.
        """
        return _ML.MultiVector___getitem__(self, *args)

    def __call__(self, *args):
        """
        __call__(self, int i, int v=0) -> float

        Returns the i-th element of the v-th vector.
        """
        return _ML.MultiVector___call__(self, *args)

MultiVector_swigregister = _ML.MultiVector_swigregister
MultiVector_swigregister(MultiVector)


def Extract(*args):
  """
    Extract(MultiVector y, int v) -> MultiVector

    MultiVector
    MLAPI::Extract(const MultiVector &y, const int v)

    Extracts a component from a vector. 
    """
  return _ML.Extract(*args)

def Redistribute(*args):
  """
    Redistribute(MultiVector y, int NumEquations) -> MultiVector

    MultiVector
    MLAPI::Redistribute(const MultiVector &y, const int NumEquations)

    Redistributes the entry of a vector as a multivector. 
    """
  return _ML.Redistribute(*args)
class Operator(BaseOperator,CompObject,TimeObject):
    """
    Operator: basic class to define operators within MLAPI.

    Marzio Sala, SNL 9214

    C++ includes: MLAPI_Operator.h 
    """
    __swig_setmethods__ = {}
    for _s in [BaseOperator,CompObject,TimeObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Operator, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseOperator,CompObject,TimeObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Operator, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> Operator
        __init__(self, Space DomainSpace, Space RangeSpace, ML_Operator Op, 
            bool Ownership = True, Teuchos::RefCountPtr<(ML_Operator_Box)> AuxOp = Teuchos::null) -> Operator
        __init__(self, Space DomainSpace, Space RangeSpace, RowMatrix Matrix, 
            bool Ownership = True, Teuchos::RefCountPtr<(ML_Operator_Box)> AuxOp = Teuchos::null) -> Operator
        __init__(self, Operator RHS) -> Operator

        MLAPI::Operator::Operator(const Operator &RHS)

        Copy constructor. 
        """
        this = _ML.new_Operator(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ML.delete_Operator
    __del__ = lambda self : None;
    def Reshape(self, *args):
        """
        Reshape(self)
        Reshape(self, Space DomainSpace, Space RangeSpace, ML_Operator Op, 
            bool Ownership = True, Teuchos::RefCountPtr<(ML_Operator_Box)> AuxOp = Teuchos::null)
        Reshape(self, Space DomainSpace, Space RangeSpace, RowMatrix Matrix, 
            bool Ownership = True, Teuchos::RefCountPtr<(ML_Operator_Box)> AuxOp = Teuchos::null)

        void
        MLAPI::Operator::Reshape(const Space &DomainSpace, const Space
        &RangeSpace, Epetra_RowMatrix *Matrix, bool Ownership=true,
        Teuchos::RefCountPtr< ML_Operator_Box > AuxOp=Teuchos::null)

        Reshape with given already FillComplete()'d object. 
        """
        return _ML.Operator_Reshape(self, *args)

    def GetOperatorDomainSpace(self, *args):
        """
        GetOperatorDomainSpace(self) -> Space

        const
        Space MLAPI::Operator::GetOperatorDomainSpace() const

        Returns a reference to the internally stored domain space. 
        """
        return _ML.Operator_GetOperatorDomainSpace(self, *args)

    def GetOperatorRangeSpace(self, *args):
        """
        GetOperatorRangeSpace(self) -> Space

        const
        Space MLAPI::Operator::GetOperatorRangeSpace() const

        Returns a reference to the internally stored range space. 
        """
        return _ML.Operator_GetOperatorRangeSpace(self, *args)

    def GetDomainSpace(self, *args):
        """
        GetDomainSpace(self) -> Space

        const Space
        MLAPI::Operator::GetDomainSpace() const

        Returns a reference to the internally stored domain space. 
        """
        return _ML.Operator_GetDomainSpace(self, *args)

    def GetRangeSpace(self, *args):
        """
        GetRangeSpace(self) -> Space

        const Space
        MLAPI::Operator::GetRangeSpace() const

        Returns a reference to the internally stored range space. 
        """
        return _ML.Operator_GetRangeSpace(self, *args)

    def GetColumnSpace(self, *args):
        """
        GetColumnSpace(self) -> Space

        const Space
        MLAPI::Operator::GetColumnSpace() const

        Returns a reference to the internally stored column space. 
        """
        return _ML.Operator_GetColumnSpace(self, *args)

    def GetNumGlobalRows(self, *args):
        """
        GetNumGlobalRows(self) -> int

        int
        MLAPI::Operator::GetNumGlobalRows() const

        Returns the number of global rows. 
        """
        return _ML.Operator_GetNumGlobalRows(self, *args)

    def GetNumMyRows(self, *args):
        """
        GetNumMyRows(self) -> int

        int
        MLAPI::Operator::GetNumMyRows() const

        Returns the number of local rows. 
        """
        return _ML.Operator_GetNumMyRows(self, *args)

    def GetNumGlobalCols(self, *args):
        """
        GetNumGlobalCols(self) -> int

        int
        MLAPI::Operator::GetNumGlobalCols() const

        Returns the number of global columns. 
        """
        return _ML.Operator_GetNumGlobalCols(self, *args)

    def GetNumMyCols(self, *args):
        """
        GetNumMyCols(self) -> int

        int
        MLAPI::Operator::GetNumMyCols() const

        Returns the number of local columns. 
        """
        return _ML.Operator_GetNumMyCols(self, *args)

    def GetNumGlobalNonzeros(self, *args):
        """
        GetNumGlobalNonzeros(self) -> int

        int
        MLAPI::Operator::GetNumGlobalNonzeros() const

        Returns the global number of nonzeros. 
        """
        return _ML.Operator_GetNumGlobalNonzeros(self, *args)

    def GetNumMyNonzeros(self, *args):
        """
        GetNumMyNonzeros(self) -> int

        int
        MLAPI::Operator::GetNumMyNonzeros() const

        Returns the local number of nonzeros. 
        """
        return _ML.Operator_GetNumMyNonzeros(self, *args)

    def GetRowMatrix(self, *args):
        """
        GetRowMatrix(self) -> RowMatrix

        const
        Epetra_RowMatrix* MLAPI::Operator::GetRowMatrix() const

        Returns the RefCountPtr of OperatorBox_. 
        """
        return _ML.Operator_GetRowMatrix(self, *args)

    def GetML_Operator(self, *args):
        """
        GetML_Operator(self) -> ML_Operator

        ML_Operator*
        MLAPI::Operator::GetML_Operator() const

        Returns the RefCountPtr of OperatorBox_. 
        """
        return _ML.Operator_GetML_Operator(self, *args)

    def GetRCPOperatorBox(self, *args):
        """
        GetRCPOperatorBox(self) -> Teuchos::RefCountPtr<(ML_Operator_Box)>

        const
        Teuchos::RefCountPtr<ML_Operator_Box>&
        MLAPI::Operator::GetRCPOperatorBox() const

        Returns the RefCountPtr of OperatorBox_. 
        """
        return _ML.Operator_GetRCPOperatorBox(self, *args)

    def GetRCPAuxOperatorBox(self, *args):
        """
        GetRCPAuxOperatorBox(self) -> Teuchos::RefCountPtr<(ML_Operator_Box)>

        const
        Teuchos::RefCountPtr<ML_Operator_Box>&
        MLAPI::Operator::GetRCPAuxOperatorBox() const

        Returns the RefCountPtr of AuxOperatorBox_. 
        """
        return _ML.Operator_GetRCPAuxOperatorBox(self, *args)

    def GetRCPRowMatrix(self, *args):
        """
        GetRCPRowMatrix(self) -> Teuchos::RefCountPtr<(Epetra_RowMatrix)>

        const
        Teuchos::RefCountPtr<Epetra_RowMatrix>&
        MLAPI::Operator::GetRCPRowMatrix() const

        Returns the RefCountPtr of RowMatrix_. 
        """
        return _ML.Operator_GetRCPRowMatrix(self, *args)

    def GetGRID(self, *args):
        """
        GetGRID(self, int LRID) -> int

        int
        MLAPI::Operator::GetGRID(const int LRID) const

        Returns the global ID of local row ID LRID. 
        """
        return _ML.Operator_GetGRID(self, *args)

    def GetGCID(self, *args):
        """
        GetGCID(self, int LCID) -> int

        int
        MLAPI::Operator::GetGCID(const int LCID) const

        Returns the global ID of local column ID LCID. 
        """
        return _ML.Operator_GetGCID(self, *args)

    def Apply(self, *args):
        """
        Apply(self, MultiVector X, MultiVector Y) -> int

        int
        MLAPI::Operator::Apply(const MultiVector &X, MultiVector &Y) const

        Applies this operator to LHS, returns the result in RHS. 
        """
        return _ML.Operator_Apply(self, *args)

    def BuildColumnSpace(self, *args):
        """
        BuildColumnSpace(self)

        void
        MLAPI::Operator::BuildColumnSpace()

        Build the column space, by computing the GID of all local columns. 
        """
        return _ML.Operator_BuildColumnSpace(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, PyObject args) -> PyObject"""
        return _ML.Operator___getitem__(self, *args)

    def __add__(self, *args):
        """__add__(self, Operator rhs) -> Operator"""
        return _ML.Operator___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, Operator rhs) -> Operator"""
        return _ML.Operator___sub__(self, *args)

    def __mul__(self, *args):
        """
        __mul__(self, MultiVector rhs) -> MultiVector
        __mul__(self, Operator rhs) -> Operator
        __mul__(self, double rhs) -> Operator
        """
        return _ML.Operator___mul__(self, *args)

    def __div__(self, *args):
        """__div__(self, double rhs) -> Operator"""
        return _ML.Operator___div__(self, *args)

Operator_swigregister = _ML.Operator_swigregister
Operator_swigregister(Operator)

class PyMatrix(Operator):
    """Proxy of C++ PyMatrix class"""
    __swig_setmethods__ = {}
    for _s in [Operator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PyMatrix, name, value)
    __swig_getmethods__ = {}
    for _s in [Operator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PyMatrix, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Space RowSpace, Space ColSpace) -> PyMatrix"""
        this = _ML.new_PyMatrix(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ML.delete_PyMatrix
    __del__ = lambda self : None;
    def GetRowSpace(self, *args):
        """GetRowSpace(self) -> Space"""
        return _ML.PyMatrix_GetRowSpace(self, *args)

    def SetElement(self, *args):
        """SetElement(self, int row, int col, double value)"""
        return _ML.PyMatrix_SetElement(self, *args)

    def FillComplete(self, *args):
        """FillComplete(self)"""
        return _ML.PyMatrix_FillComplete(self, *args)

    def GetMatrix(self, *args):
        """GetMatrix(self) -> FECrsMatrix"""
        return _ML.PyMatrix_GetMatrix(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, PyObject args, double val) -> PyObject"""
        return _ML.PyMatrix___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, PyObject args) -> PyObject"""
        return _ML.PyMatrix___getitem__(self, *args)

PyMatrix_swigregister = _ML.PyMatrix_swigregister
PyMatrix_swigregister(PyMatrix)

ML_MEM_SIZE = _ML.ML_MEM_SIZE
ML_MEM_INITIAL = _ML.ML_MEM_INITIAL
ML_MEM_FINAL = _ML.ML_MEM_FINAL
ML_MEM_SMOOTHER = _ML.ML_MEM_SMOOTHER
ML_MEM_COARSE = _ML.ML_MEM_COARSE
ML_MEM_HIERARCHY = _ML.ML_MEM_HIERARCHY
ML_MEM_PREC_FIRST = _ML.ML_MEM_PREC_FIRST
ML_MEM_PREC_OTHER = _ML.ML_MEM_PREC_OTHER
ML_MEM_TOT1 = _ML.ML_MEM_TOT1
ML_MEM_TOT2 = _ML.ML_MEM_TOT2
ML_MEM_INITIAL_MALLOC = _ML.ML_MEM_INITIAL_MALLOC
ML_MEM_FINAL_MALLOC = _ML.ML_MEM_FINAL_MALLOC
ML_MEM_SMOOTHER_MALLOC = _ML.ML_MEM_SMOOTHER_MALLOC
ML_MEM_COARSE_MALLOC = _ML.ML_MEM_COARSE_MALLOC
ML_MEM_HIERARCHY_MALLOC = _ML.ML_MEM_HIERARCHY_MALLOC
ML_MEM_PREC_FIRST_MALLOC = _ML.ML_MEM_PREC_FIRST_MALLOC
ML_MEM_PREC_OTHER_MALLOC = _ML.ML_MEM_PREC_OTHER_MALLOC
ML_MEM_TOT1_MALLOC = _ML.ML_MEM_TOT1_MALLOC
ML_MEM_TOT2_MALLOC = _ML.ML_MEM_TOT2_MALLOC

def SetDefaults(*args):
  """
    SetDefaults(string ProblemType, ParameterList List, int options = None, 
        double params = None, bool OverWrite = True) -> int
    """
  return _ML.SetDefaults(*args)

def SetDefaultsDD(*args):
  """
    SetDefaultsDD(ParameterList List, Teuchos::RCP<(std::vector<(int,std::allocator<(int)>)>)> options, 
        Teuchos::RCP<(std::vector<(double,std::allocator<(double)>)>)> params, 
        bool Overwrite = True) -> int
    """
  return _ML.SetDefaultsDD(*args)

def SetDefaultsDD_LU(*args):
  """
    SetDefaultsDD_LU(ParameterList List, Teuchos::RCP<(std::vector<(int,std::allocator<(int)>)>)> options, 
        Teuchos::RCP<(std::vector<(double,std::allocator<(double)>)>)> params, 
        bool Overwrite = True) -> int
    """
  return _ML.SetDefaultsDD_LU(*args)

def SetDefaultsDD_3Levels(*args):
  """
    SetDefaultsDD_3Levels(ParameterList List, Teuchos::RCP<(std::vector<(int,std::allocator<(int)>)>)> options, 
        Teuchos::RCP<(std::vector<(double,std::allocator<(double)>)>)> params, 
        bool Overwrite = True) -> int
    """
  return _ML.SetDefaultsDD_3Levels(*args)

def SetDefaultsDD_3Levels_LU(*args):
  """
    SetDefaultsDD_3Levels_LU(ParameterList List, Teuchos::RCP<(std::vector<(int,std::allocator<(int)>)>)> options, 
        Teuchos::RCP<(std::vector<(double,std::allocator<(double)>)>)> params, 
        bool Overwrite = True) -> int
    """
  return _ML.SetDefaultsDD_3Levels_LU(*args)

def SetDefaultsMaxwell(*args):
  """
    SetDefaultsMaxwell(ParameterList List, Teuchos::RCP<(std::vector<(int,std::allocator<(int)>)>)> options, 
        Teuchos::RCP<(std::vector<(double,std::allocator<(double)>)>)> params, 
        bool Overwrite = True) -> int
    """
  return _ML.SetDefaultsMaxwell(*args)

def SetDefaultsSA(*args):
  """
    SetDefaultsSA(ParameterList List, Teuchos::RCP<(std::vector<(int,std::allocator<(int)>)>)> options, 
        Teuchos::RCP<(std::vector<(double,std::allocator<(double)>)>)> params, 
        bool Overwrite = True) -> int
    """
  return _ML.SetDefaultsSA(*args)

def SetDefaultsNSSA(*args):
  """
    SetDefaultsNSSA(ParameterList List, Teuchos::RCP<(std::vector<(int,std::allocator<(int)>)>)> options, 
        Teuchos::RCP<(std::vector<(double,std::allocator<(double)>)>)> params, 
        bool Overwrite = True) -> int
    """
  return _ML.SetDefaultsNSSA(*args)

def ReadXML(*args):
  """ReadXML(string FileName, ParameterList List, Comm Comm) -> int"""
  return _ML.ReadXML(*args)
ML_SA_FAMILY = _ML.ML_SA_FAMILY
ML_MAXWELL = _ML.ML_MAXWELL
ML_COMPOSITE = _ML.ML_COMPOSITE
class MultiLevelPreconditioner(Epetra.Operator):
    """
    ML black-box preconditioner for Epetra_RowMatrix derived classes.

    C++ includes: ml_MultiLevelPreconditioner.h 
    """
    __swig_setmethods__ = {}
    for _s in [Epetra.Operator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiLevelPreconditioner, name, value)
    __swig_getmethods__ = {}
    for _s in [Epetra.Operator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiLevelPreconditioner, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, RowMatrix RowMatrix, bool ComputePrec = True) -> MultiLevelPreconditioner
        __init__(self, RowMatrix RowMatrix, ParameterList List, bool ComputePrec = True) -> MultiLevelPreconditioner
        __init__(self, ML_Operator Operator, ParameterList List, bool ComputePrec = True) -> MultiLevelPreconditioner
        __init__(self, ML_Operator Operator, ParameterList List, RowMatrix DiagOperators, 
            ParameterList DiagLists, int NBlocks = 1, 
            bool ComputePrec = True) -> MultiLevelPreconditioner
        __init__(self, RowMatrix EdgeMatrix, RowMatrix GradMatrix, RowMatrix NodeMatrix, 
            ParameterList List, bool ComputePrec = True, 
            bool UseNodeMatrixForSmoother = False) -> MultiLevelPreconditioner
        __init__(self, RowMatrix CurlCurlMatrix, RowMatrix MassMatrix, RowMatrix TMatrix, 
            RowMatrix NodeMatrix, ParameterList List, 
            bool ComputePrec = True) -> MultiLevelPreconditioner
        __init__(self, Epetra_MsrMatrix EdgeMatrix, ML_Operator GradMatrix, 
            AZ_MATRIX NodeMatrix, int proc_config, ParameterList List, 
            bool ComputePrec = True) -> MultiLevelPreconditioner

        ML black-box preconditioner for Epetra_RowMatrix derived classes.

        C++ includes: ml_MultiLevelPreconditioner.h 
        """
        this = _ML.new_MultiLevelPreconditioner(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ML.delete_MultiLevelPreconditioner
    __del__ = lambda self : None;
    def Label(self, *args):
        """
        Label(self) -> char

        virtual const char*
        Epetra_Operator::Label() const =0

        Returns a character string describing the operator. 
        """
        return _ML.MultiLevelPreconditioner_Label(self, *args)

    def PrintUnused(self, *args):
        """
        PrintUnused(self)
        PrintUnused(self,  os)
        PrintUnused(self, int MyPID)
        """
        return _ML.MultiLevelPreconditioner_PrintUnused(self, *args)

    def GetList(self, *args):
        """GetList(self) -> ParameterList"""
        return _ML.MultiLevelPreconditioner_GetList(self, *args)

    def GetOutputList(self, *args):
        """GetOutputList(self) -> ParameterList"""
        return _ML.MultiLevelPreconditioner_GetOutputList(self, *args)

    def PrintList(self, *args):
        """PrintList(self)"""
        return _ML.MultiLevelPreconditioner_PrintList(self, *args)

    def SetParameterList(self, *args):
        """SetParameterList(self, ParameterList List) -> int"""
        return _ML.MultiLevelPreconditioner_SetParameterList(self, *args)

    def Apply(self, *args):
        """
        Apply(self, MultiVector x, MultiVector y) -> int

        In C++, the Apply() method is pure virtual, thus intended to be
        overridden by derived classes.  In python, cross-language polymorphism
        is supported, and you are expected to derive classes from this base
        class and redefine the Apply() method.  C++ code (e.g., AztecOO
        solvers) can call back to your Apply() method as needed.  You must
        support two arguments, labeled here MultiVector x and MultiVector y.
        These will be converted from Epetra_MultiVector C++ objects to
        numpy-hybrid Epetra.MultiVector objects before they are passed to you.
        Thus, it is legal to use slice indexing and other numpy features to
        compute y from x.

        If application of your operator is successful, return 0; else return
        some non-zero error code.

        It is strongly suggested that you prevent Apply() from raising any
        exceptions.  Accidental errors can be prevented by wrapping your code
        in a try block:

            try:
                # Your code goes here...
            except Exception, e:
                print 'A python exception was raised by method Apply:'
                print e
                return -1

        By returning a -1, you inform the calling routine that Apply() was
        unsuccessful.


        virtual int
        Epetra_Operator::Apply(const Epetra_MultiVector &X, Epetra_MultiVector
        &Y) const =0

        Returns the result of a Epetra_Operator applied to a
        Epetra_MultiVector X in Y.

        Parameters:
        -----------

        In:  X - A Epetra_MultiVector of dimension NumVectors to multiply with
        matrix.

        Out:  Y -A Epetra_MultiVector of dimension NumVectors containing
        result.

        Integer error code, set to 0 if successful. 
        """
        return _ML.MultiLevelPreconditioner_Apply(self, *args)

    def ApplyInverse(self, *args):
        """
        ApplyInverse(self, MultiVector x, MultiVector y) -> int

        In C++, the ApplyInverse() method is pure virtual, thus intended to be
        overridden by derived classes.  In python, cross-language polymorphism
        is supported, and you are expected to derive classes from this base
        class and redefine the ApplyInverse() method.  C++ code (e.g., AztecOO
        solvers) can call back to your ApplyInverse() method as needed.  You
        must support two arguments, labeled here MultiVector x and MultiVector
        y.  These will be converted from Epetra_MultiVector C++ objects to
        numpy-hybrid Epetra.MultiVector objects before they are passed to you.
        Thus, it is legal to use slice indexing and other numpy features to
        compute y from x.

        If application of your operator is successful, return 0; else return
        some non-zero error code.

        It is strongly suggested that you prevent ApplyInverse() from raising
        any exceptions.  Accidental errors can be prevented by wrapping your
        code in a try block:

            try:
                # Your code goes here...
            except Exception, e:
                print 'A python exception was raised by method ApplyInverse:'
                print e
                return -1

        By returning a -1, you inform the calling routine that ApplyInverse()
        was unsuccessful.


        virtual int
        Epetra_Operator::ApplyInverse(const Epetra_MultiVector &X,
        Epetra_MultiVector &Y) const =0

        Returns the result of a Epetra_Operator inverse applied to an
        Epetra_MultiVector X in Y.

        Parameters:
        -----------

        In:  X - A Epetra_MultiVector of dimension NumVectors to solve for.

        Out:  Y -A Epetra_MultiVector of dimension NumVectors containing
        result.

        Integer error code, set to 0 if successful.

        WARNING:  In order to work with AztecOO, any implementation of this
        method must support the case where X and Y are the same object. 
        """
        return _ML.MultiLevelPreconditioner_ApplyInverse(self, *args)

    def ComputePreconditioner(self, *args):
        """ComputePreconditioner(self, bool CheckFiltering = False) -> int"""
        return _ML.MultiLevelPreconditioner_ComputePreconditioner(self, *args)

    def ReComputePreconditioner(self, *args):
        """ReComputePreconditioner(self) -> int"""
        return _ML.MultiLevelPreconditioner_ReComputePreconditioner(self, *args)

    def ComputeAdaptivePreconditioner(self, *args):
        """ComputeAdaptivePreconditioner(self, int TentativeNullSpaceSize, double TentativeNullSpace) -> int"""
        return _ML.MultiLevelPreconditioner_ComputeAdaptivePreconditioner(self, *args)

    def IsPreconditionerComputed(self, *args):
        """IsPreconditionerComputed(self) -> int"""
        return _ML.MultiLevelPreconditioner_IsPreconditionerComputed(self, *args)

    def SetOwnership(self, *args):
        """SetOwnership(self, bool ownership) -> int"""
        return _ML.MultiLevelPreconditioner_SetOwnership(self, *args)

    def SetUseTranspose(self, *args):
        """
        SetUseTranspose(self, bool UseTranspose) -> int

        virtual int
        Epetra_Operator::SetUseTranspose(bool UseTranspose)=0

        If set true, transpose of this operator will be applied.

        This flag allows the transpose of the given operator to be used
        implicitly. Setting this flag affects only the Apply() and
        ApplyInverse() methods. If the implementation of this interface does
        not support transpose use, this method should return a value of -1.

        Parameters:
        -----------

        In:  UseTranspose -If true, multiply by the transpose of operator,
        otherwise just use operator.

        Integer error code, set to 0 if successful. Set to -1 if this
        implementation does not support transpose. 
        """
        return _ML.MultiLevelPreconditioner_SetUseTranspose(self, *args)

    def NormInf(self, *args):
        """
        NormInf(self) -> double

        virtual double
        Epetra_Operator::NormInf() const =0

        Returns the infinity norm of the global matrix. 
        """
        return _ML.MultiLevelPreconditioner_NormInf(self, *args)

    def UseTranspose(self, *args):
        """
        UseTranspose(self) -> bool

        virtual bool
        Epetra_Operator::UseTranspose() const =0

        Returns the current UseTranspose setting. 
        """
        return _ML.MultiLevelPreconditioner_UseTranspose(self, *args)

    def HasNormInf(self, *args):
        """
        HasNormInf(self) -> bool

        virtual bool
        Epetra_Operator::HasNormInf() const =0

        Returns true if the this object can provide an approximate Inf-norm,
        false otherwise. 
        """
        return _ML.MultiLevelPreconditioner_HasNormInf(self, *args)

    def Comm(self, *args):
        """
        Comm(self) -> Comm

        virtual const
        Epetra_Comm& Epetra_Operator::Comm() const =0

        Returns a pointer to the Epetra_Comm communicator associated with this
        operator. 
        """
        return _ML.MultiLevelPreconditioner_Comm(self, *args)

    def OperatorDomainMap(self, *args):
        """
        OperatorDomainMap(self) -> Map

        virtual
        const Epetra_Map& Epetra_Operator::OperatorDomainMap() const =0

        Returns the Epetra_Map object associated with the domain of this
        operator. 
        """
        return _ML.MultiLevelPreconditioner_OperatorDomainMap(self, *args)

    def OperatorRangeMap(self, *args):
        """
        OperatorRangeMap(self) -> Map

        virtual
        const Epetra_Map& Epetra_Operator::OperatorRangeMap() const =0

        Returns the Epetra_Map object associated with the range of this
        operator. 
        """
        return _ML.MultiLevelPreconditioner_OperatorRangeMap(self, *args)

    def DestroyPreconditioner(self, *args):
        """DestroyPreconditioner(self) -> int"""
        return _ML.MultiLevelPreconditioner_DestroyPreconditioner(self, *args)

    def RowMatrix(self, *args):
        """RowMatrix(self) -> RowMatrix"""
        return _ML.MultiLevelPreconditioner_RowMatrix(self, *args)

    def Map(self, *args):
        """Map(self) -> BlockMap"""
        return _ML.MultiLevelPreconditioner_Map(self, *args)

    def NumGlobalRows(self, *args):
        """NumGlobalRows(self) -> int"""
        return _ML.MultiLevelPreconditioner_NumGlobalRows(self, *args)

    def NumGlobalCols(self, *args):
        """NumGlobalCols(self) -> int"""
        return _ML.MultiLevelPreconditioner_NumGlobalCols(self, *args)

    def NumMyRows(self, *args):
        """NumMyRows(self) -> int"""
        return _ML.MultiLevelPreconditioner_NumMyRows(self, *args)

    def NumMyCols(self, *args):
        """NumMyCols(self) -> int"""
        return _ML.MultiLevelPreconditioner_NumMyCols(self, *args)

    def PrintStencil2D(self, *args):
        """PrintStencil2D(self, int nx, int ny, int NodeID = -1, int EquationID = 0) -> int"""
        return _ML.MultiLevelPreconditioner_PrintStencil2D(self, *args)

    def AnalyzeHierarchy(self, *args):
        """
        AnalyzeHierarchy(self, bool AnalyzeMatrices, int PreCycles, int PostCycles, 
            int MLCycles) -> int
        """
        return _ML.MultiLevelPreconditioner_AnalyzeHierarchy(self, *args)

    def AnalyzeSmoothers(self, *args):
        """AnalyzeSmoothers(self, int NumPreCycles = 1, int NumPostCycles = 1) -> int"""
        return _ML.MultiLevelPreconditioner_AnalyzeSmoothers(self, *args)

    def AnalyzeCoarse(self, *args):
        """AnalyzeCoarse(self) -> int"""
        return _ML.MultiLevelPreconditioner_AnalyzeCoarse(self, *args)

    def AnalyzeCycle(self, *args):
        """AnalyzeCycle(self, int NumCycles = 1) -> int"""
        return _ML.MultiLevelPreconditioner_AnalyzeCycle(self, *args)

    def TestSmoothers(self, *args):
        """
        TestSmoothers(self, ParameterList InputList, bool IsSymmetric = False) -> int
        TestSmoothers(self, bool IsSymmetric = False) -> int
        """
        return _ML.MultiLevelPreconditioner_TestSmoothers(self, *args)

    def GetML(self, *args):
        """GetML(self, int WhichML = -1) -> ML"""
        return _ML.MultiLevelPreconditioner_GetML(self, *args)

    def GetML_Aggregate(self, *args):
        """GetML_Aggregate(self) -> ML_Aggregate"""
        return _ML.MultiLevelPreconditioner_GetML_Aggregate(self, *args)

    def Visualize(self, *args):
        """
        Visualize(self, bool VizAggre, bool VizPreSmoother, bool VizPostSmoother, 
            bool VizCycle, int NumApplPreSmoother, 
            int NumApplPostSmoother, int NumCycleSmoother) -> int
        """
        return _ML.MultiLevelPreconditioner_Visualize(self, *args)

    def VisualizeAggregates(self, *args):
        """VisualizeAggregates(self) -> int"""
        return _ML.MultiLevelPreconditioner_VisualizeAggregates(self, *args)

    def VisualizeSmoothers(self, *args):
        """VisualizeSmoothers(self, int NumPrecCycles = 1, int NumPostCycles = 1) -> int"""
        return _ML.MultiLevelPreconditioner_VisualizeSmoothers(self, *args)

    def VisualizeCycle(self, *args):
        """VisualizeCycle(self, int NumCycles = 1) -> int"""
        return _ML.MultiLevelPreconditioner_VisualizeCycle(self, *args)

    def CreateLabel(self, *args):
        """CreateLabel(self) -> int"""
        return _ML.MultiLevelPreconditioner_CreateLabel(self, *args)

    def ReportTime(self, *args):
        """ReportTime(self)"""
        return _ML.MultiLevelPreconditioner_ReportTime(self, *args)

    def SetParameterListAndNullSpace(self, *args):
        """SetParameterListAndNullSpace(self, PyObject obj, Epetra_MultiVector NullSpace) -> int"""
        return _ML.MultiLevelPreconditioner_SetParameterListAndNullSpace(self, *args)

MultiLevelPreconditioner_swigregister = _ML.MultiLevelPreconditioner_swigregister
MultiLevelPreconditioner_swigregister(MultiLevelPreconditioner)

class InverseOperator(BaseOperator,CompObject,TimeObject):
    """
    InverseOperator: basic class to define smoother and coarse solvers.

    Marzio Sala, D-INFK/ETHZ.

    C++ includes: MLAPI_InverseOperator.h 
    """
    __swig_setmethods__ = {}
    for _s in [BaseOperator,CompObject,TimeObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InverseOperator, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseOperator,CompObject,TimeObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InverseOperator, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> InverseOperator
        __init__(self, Operator Op, string Type) -> InverseOperator
        __init__(self, Operator Op, string Type, ParameterList List) -> InverseOperator
        __init__(self, InverseOperator RHS) -> InverseOperator

        MLAPI::InverseOperator::InverseOperator(const InverseOperator &RHS)

        Copy constructor. 
        """
        this = _ML.new_InverseOperator(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ML.delete_InverseOperator
    __del__ = lambda self : None;
    def GetOperatorRangeSpace(self, *args):
        """
        GetOperatorRangeSpace(self) -> Space

        const Space MLAPI::InverseOperator::GetOperatorRangeSpace() const

        Returns a reference to the range space of this object. 
        """
        return _ML.InverseOperator_GetOperatorRangeSpace(self, *args)

    def GetOperatorDomainSpace(self, *args):
        """
        GetOperatorDomainSpace(self) -> Space

        const Space MLAPI::InverseOperator::GetOperatorDomainSpace() const

        Returns a reference to the domain space of this object. 
        """
        return _ML.InverseOperator_GetOperatorDomainSpace(self, *args)

    def GetRangeSpace(self, *args):
        """
        GetRangeSpace(self) -> Space

        const
        Space MLAPI::InverseOperator::GetRangeSpace() const

        Returns a reference to the range space of this object. 
        """
        return _ML.InverseOperator_GetRangeSpace(self, *args)

    def GetDomainSpace(self, *args):
        """
        GetDomainSpace(self) -> Space

        const
        Space MLAPI::InverseOperator::GetDomainSpace() const

        Returns a reference to the domain space of this object. 
        """
        return _ML.InverseOperator_GetDomainSpace(self, *args)

    def RCPRowMatrix(self, *args):
        """
        RCPRowMatrix(self) -> Teuchos::RefCountPtr<(Epetra_RowMatrix)>

        const
        Teuchos::RefCountPtr<Epetra_RowMatrix>
        MLAPI::InverseOperator::RCPRowMatrix() const

        Returns pointer of the internally stored ML_Epetra::RowMatrix object.

        """
        return _ML.InverseOperator_RCPRowMatrix(self, *args)

    def RowMatrix(self, *args):
        """
        RowMatrix(self) -> RowMatrix

        Epetra_RowMatrix* MLAPI::InverseOperator::RowMatrix() const

        Returns pointer of the internally stored ML_Epetra::RowMatrix object.

        """
        return _ML.InverseOperator_RowMatrix(self, *args)

    def GetOperator(self, *args):
        """
        GetOperator(self) -> Operator

        const
        Operator& MLAPI::InverseOperator::GetOperator() const

        Returns a reference to the Operator of which this object defines the
        inverse. 
        """
        return _ML.InverseOperator_GetOperator(self, *args)

    def GetRCPData(self, *args):
        """
        GetRCPData(self) -> Teuchos::RefCountPtr<(Ifpack_Preconditioner)>
        GetRCPData(self) -> Teuchos::RefCountPtr<(Ifpack_Preconditioner)>

        const
        Teuchos::RefCountPtr<Ifpack_Preconditioner>&
        MLAPI::InverseOperator::GetRCPData() const

        Returns a pointer to the internally stored IFPACK preconditioner. 
        """
        return _ML.InverseOperator_GetRCPData(self, *args)

    def GetRCPMLPrec(self, *args):
        """
        GetRCPMLPrec(self) -> Teuchos::RefCountPtr<(ML_Epetra::MultiLevelPreconditioner)>
        GetRCPMLPrec(self) -> Teuchos::RefCountPtr<(ML_Epetra::MultiLevelPreconditioner)>

        const
        Teuchos::RefCountPtr<ML_Epetra::MultiLevelPreconditioner>&
        MLAPI::InverseOperator::GetRCPMLPrec() const

        Returns a pointer to the internally stored ML preconditioner. 
        """
        return _ML.InverseOperator_GetRCPMLPrec(self, *args)

    def Apply(self, *args):
        """
        Apply(self, MultiVector x, MultiVector y) -> int

        int
        MLAPI::InverseOperator::Apply(const MultiVector &x, MultiVector &y)
        const

        Applies this object to vector lhs, returns values in rhs. 
        """
        return _ML.InverseOperator_Apply(self, *args)

    def __call__(self, *args):
        """
        __call__(self, MultiVector LHS) -> MultiVector
        __call__(self, MultiVector LHS, MultiVector RHS) -> MultiVector
        """
        return _ML.InverseOperator___call__(self, *args)

    def __mul__(self, *args):
        """__mul__(self, MultiVector rhs) -> MultiVector"""
        return _ML.InverseOperator___mul__(self, *args)

    def Reshape(self, *args):
        """
        Reshape(self)
        Reshape(self, Operator Op, string Type)
        Reshape(self, Operator Op, string Type, ParameterList List, ParameterList pushlist = None)
        Reshape(self, Ifpack_Preconditioner prec, Operator Op, bool ownership)
        Reshape(self, Operator Op, string Type, PyObject obj) -> bool

        void
        MLAPI::InverseOperator::Reshape(Ifpack_Preconditioner *prec, const
        Operator &Op, const bool ownership)

        Reshape with preconstructed smoother as Ifpack_Preconditioner. 
        """
        return _ML.InverseOperator_Reshape(self, *args)

InverseOperator_swigregister = _ML.InverseOperator_swigregister
InverseOperator_swigregister(InverseOperator)


def GetRAP(*args):
  """
    GetRAP(Operator R, Operator A, Operator P) -> Operator

    Operator MLAPI::GetRAP(const
    Operator &R, const Operator &A, const Operator &P)

    Performs a triple matrix-matrix product, res = R * A *P. 
    """
  return _ML.GetRAP(*args)

def GetTranspose(*args):
  """
    GetTranspose(Operator A, bool byrow = True) -> Operator

    Operator
    MLAPI::GetTranspose(const Operator &A, const bool byrow=true)

    Returns a newly created transpose of A. 
    """
  return _ML.GetTranspose(*args)

def GetIdentity(*args):
  """
    GetIdentity(Space DomainSpace, Space RangeSpace) -> Operator

    Operator
    MLAPI::GetIdentity(const Space &DomainSpace, const Space &RangeSpace)

    Returns the identity matrix. 
    """
  return _ML.GetIdentity(*args)

def GetJacobiIterationOperator(*args):
  """
    GetJacobiIterationOperator(Operator Amat, double Damping) -> Operator

    Operator
    MLAPI::GetJacobiIterationOperator(const Operator &Amat, double
    Damping)

    Returns an operator defined as (I - Damping A). 
    """
  return _ML.GetJacobiIterationOperator(*args)

def GetPtent1D(*args):
  """
    GetPtent1D(MultiVector D, int offset = 0) -> Operator

    Operator
    MLAPI::GetPtent1D(const MultiVector &D, const int offset=0)

    Returns a newly created operator, containing D on the diagonal. 
    """
  return _ML.GetPtent1D(*args)

def ML_Operator_Add2(*args):
  """
    ML_Operator_Add2(ML_Operator A, ML_Operator B, ML_Operator C, int matrix_type, 
        double scalarA, double scalarB) -> int

    int
    MLAPI::ML_Operator_Add2(ML_Operator *A, ML_Operator *B, ML_Operator
    *C, int matrix_type, double scalarA, double scalarB) 
    """
  return _ML.ML_Operator_Add2(*args)

def AnalyzeCheap(*args):
  """
    AnalyzeCheap(Operator A)

    void
    MLAPI::AnalyzeCheap(const Operator &A)

    Performs a cheap analysis of the properties of the input operator. 
    """
  return _ML.AnalyzeCheap(*args)

def PrintSparsity(*args):
  """
    PrintSparsity(Operator A, int NumPDEEquations = 1)

    void
    MLAPI::PrintSparsity(const Operator &A, int NumPDEEquations=1)

    Prints on file the sparsity structure of input operator. 
    """
  return _ML.PrintSparsity(*args)

def GetScaledOperator(*args):
  """
    GetScaledOperator(Operator A, double alpha) -> Operator

    Operator
    MLAPI::GetScaledOperator(const Operator &A, const double alpha)

    Multiply A by a double value, alpha. 
    """
  return _ML.GetScaledOperator(*args)
class EpetraBaseOperator(Epetra.Operator):
    """
    Basic class to wrap MLAPI::InverseOperator into Epetra_Operator.

    Marzio Sala, SNL 9214.

    C++ includes: MLAPI_EpetraBaseOperator.h 
    """
    __swig_setmethods__ = {}
    for _s in [Epetra.Operator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EpetraBaseOperator, name, value)
    __swig_getmethods__ = {}
    for _s in [Epetra.Operator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EpetraBaseOperator, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, Map Map, BaseOperator Op) -> EpetraBaseOperator

        MLAPI::EpetraBaseOperator::EpetraBaseOperator(const Epetra_Map &Map,
        const BaseOperator &Op)

        Constructor. 
        """
        this = _ML.new_EpetraBaseOperator(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ML.delete_EpetraBaseOperator
    __del__ = lambda self : None;
    def ApplyInverse(self, *args):
        """
        ApplyInverse(self, Epetra_MultiVector X_Epetra, Epetra_MultiVector Y_Epetra) -> int

        int
        MLAPI::EpetraBaseOperator::ApplyInverse(const Epetra_MultiVector
        &X_Epetra, Epetra_MultiVector &Y_Epetra) const

        Applies the operator to X, returns the results in Y.

        Apply() and ApplyInverse() are the SAME function! 
        """
        return _ML.EpetraBaseOperator_ApplyInverse(self, *args)

    def SetUseTranspose(self, *args):
        """
        SetUseTranspose(self, bool UseTranspose) -> int

        virtual int MLAPI::EpetraBaseOperator::SetUseTranspose(bool
        UseTranspose)

        Sets the use of tranpose (NOT IMPLEMENTED). 
        """
        return _ML.EpetraBaseOperator_SetUseTranspose(self, *args)

    def Apply(self, *args):
        """
        Apply(self, Epetra_MultiVector X_Epetra, Epetra_MultiVector Y_Epetra) -> int

        virtual int
        MLAPI::EpetraBaseOperator::Apply(const Epetra_MultiVector &X_Epetra,
        Epetra_MultiVector &Y_Epetra) const

        Applies the operator to X, returns the results in Y. 
        """
        return _ML.EpetraBaseOperator_Apply(self, *args)

    def NormInf(self, *args):
        """
        NormInf(self) -> double

        virtual
        double MLAPI::EpetraBaseOperator::NormInf() const

        NOT IMPLEMENTED. 
        """
        return _ML.EpetraBaseOperator_NormInf(self, *args)

    def Label(self, *args):
        """
        Label(self) -> char

        virtual
        const char* MLAPI::EpetraBaseOperator::Label() const

        Returns the label of this object. 
        """
        return _ML.EpetraBaseOperator_Label(self, *args)

    def UseTranspose(self, *args):
        """
        UseTranspose(self) -> bool

        virtual bool MLAPI::EpetraBaseOperator::UseTranspose() const

        Returns false. 
        """
        return _ML.EpetraBaseOperator_UseTranspose(self, *args)

    def HasNormInf(self, *args):
        """
        HasNormInf(self) -> bool

        virtual
        bool MLAPI::EpetraBaseOperator::HasNormInf() const

        NOT IMPLEMENTED. 
        """
        return _ML.EpetraBaseOperator_HasNormInf(self, *args)

    def Comm(self, *args):
        """
        Comm(self) -> Comm

        virtual const
        Epetra_Comm& MLAPI::EpetraBaseOperator::Comm() const

        Returns a reference to the communicator object. 
        """
        return _ML.EpetraBaseOperator_Comm(self, *args)

    def OperatorDomainMap(self, *args):
        """
        OperatorDomainMap(self) -> Map

        virtual const Epetra_Map&
        MLAPI::EpetraBaseOperator::OperatorDomainMap() const

        Returns a reference to the OperatorDomainMap. 
        """
        return _ML.EpetraBaseOperator_OperatorDomainMap(self, *args)

    def OperatorRangeMap(self, *args):
        """
        OperatorRangeMap(self) -> Map

        virtual const Epetra_Map&
        MLAPI::EpetraBaseOperator::OperatorRangeMap() const

        Returns a reference to the OperatorRangeMap. 
        """
        return _ML.EpetraBaseOperator_OperatorRangeMap(self, *args)

    def Map(self, *args):
        """
        Map(self) -> Map

        virtual const
        Epetra_Map& MLAPI::EpetraBaseOperator::Map() const

        Returns a reference to the Map of this object. 
        """
        return _ML.EpetraBaseOperator_Map(self, *args)

    def GetBaseOperator(self, *args):
        """
        GetBaseOperator(self) -> BaseOperator

        const BaseOperator& MLAPI::EpetraBaseOperator::GetBaseOperator() const

        """
        return _ML.EpetraBaseOperator_GetBaseOperator(self, *args)

EpetraBaseOperator_swigregister = _ML.EpetraBaseOperator_swigregister
EpetraBaseOperator_swigregister(EpetraBaseOperator)

def GetDiagonal(*args):
  """
    GetDiagonal(Operator A) -> MultiVector
    GetDiagonal(Operator A, int offset) -> MultiVector
    GetDiagonal(MultiVector D) -> Operator

    Operator
    MLAPI::GetDiagonal(const MultiVector &D)

    Returns a newly created operator, containing D on the diagonal. 
    """
  return _ML.GetDiagonal(*args)

def Duplicate(*args):
  """
    Duplicate(MultiVector y) -> MultiVector
    Duplicate(MultiVector y, int v) -> MultiVector
    Duplicate(Operator A) -> Operator

    Operator
    MLAPI::Duplicate(const Operator &A)

    Duplicates a given operator. 
    """
  return _ML.Duplicate(*args)


def Krylov(*args):
  """
    Krylov(Operator A, MultiVector LHS, MultiVector RHS, BaseOperator Prec, 
        ParameterList List)

    void MLAPI::Krylov(const
    Operator &A, const MultiVector &LHS, const MultiVector &RHS, const
    BaseOperator &Prec, Teuchos::ParameterList &List) 
    """
  return _ML.Krylov(*args)

def GetAggregates(*args):
  """
    GetAggregates(RowMatrix A, ParameterList List, double thisns, Epetra_IntVector aggrinfo) -> int

    int
    MLAPI::GetAggregates(Epetra_RowMatrix &A, Teuchos::ParameterList
    &List, double *thisns, Epetra_IntVector &aggrinfo)

    Call ML aggregation on A according to parameters supplied in List.
    Return aggregates in aggrinfo.

    On input, map of aggrinfo has to map row map of A. On output,
    aggrinfo[i] contains number of aggregate the row belongs to, where
    aggregates are numbered starting from 0. Return value is the
    processor-local number of aggregates build. If aggrinfo[i] >= return-
    value, then i is a processor local row of a row that ML has detected
    to be on a Dirichlet BC.

    Parameters:
    -----------

    A:  (in): Matrix to be aggregated on

    List:  (in): ParameterList containing ML options

    thisns:  (in): nullspace

    aggrinfo(out):  ::  vector containing aggregation information

    Map of aggrinfo has to match rowmap of A on input.

    returns processor-local number of aggregates

    Michael Gee (gee@lnm.mw.tum.de) 
    """
  return _ML.GetAggregates(*args)

def GetGlobalAggregates(*args):
  """
    GetGlobalAggregates(RowMatrix A, ParameterList List, double thisns, Epetra_IntVector aggrinfo) -> int

    int
    MLAPI::GetGlobalAggregates(Epetra_RowMatrix &A, Teuchos::ParameterList
    &List, double *thisns, Epetra_IntVector &aggrinfo)

    Call ML aggregation on A according to parameters supplied in List.
    Return aggregates in aggrinfo.

    On input, map of aggrinfo has to map row map of A. On output,
    aggrinfo[i] contains number of global aggregate the row belongs to,
    where aggregates are numbered starting from 0 globally. Return value
    is the processor-local number of aggregates build. If aggrinfo[i] < 0,
    then i is a processor local row that ML has detected to be on a
    Dirichlet BC. if aggrinfo[i] >= 0, then i is a processor local row and
    aggrinfo[i] is a global aggregate id.

    Parameters:
    -----------

    A:  (in): Matrix to be aggregated on

    List:  (in): ParameterList containing ML options

    thisns:  (in): nullspace

    aggrinfo(out):  ::  vector containing aggregation information in
    global numbering

    Map of aggrinfo has to match rowmap of A on input.

    returns processor-local number of aggregates

    Michael Gee (gee@lnm.mw.tum.de) 
    """
  return _ML.GetGlobalAggregates(*args)

def MaxEigAnorm(*args):
  """
    MaxEigAnorm(Operator Op, bool DiagonalScaling = False) -> double

    double
    MLAPI::MaxEigAnorm(const Operator &Op, const bool
    DiagonalScaling=false)

    Computes the maximum eigenvalue of Op using the A-norm of the
    operator. 
    """
  return _ML.MaxEigAnorm(*args)

def MaxEigCG(*args):
  """
    MaxEigCG(Operator Op, bool DiagonalScaling = False) -> double

    double MLAPI::MaxEigCG(const
    Operator &Op, const bool DiagonalScaling=false)

    Computes the maximum eigenvalue of Op using the CG method. 
    """
  return _ML.MaxEigCG(*args)

def MaxEigPowerMethod(*args):
  """
    MaxEigPowerMethod(Operator Op, bool DiagonalScaling = False) -> double

    double
    MLAPI::MaxEigPowerMethod(const Operator &Op, const bool
    DiagonalScaling=false)

    Computes the maximum eigenvalue of Op using the power method. 
    """
  return _ML.MaxEigPowerMethod(*args)

def MaxEigAnasazi(*args):
  """
    MaxEigAnasazi(Operator Op, bool DiagonalScaling = False) -> double

    double
    MLAPI::MaxEigAnasazi(const Operator &Op, const bool
    DiagonalScaling=false)

    Computes the maximum eigenvalue of Op using Anasazi. 
    """
  return _ML.MaxEigAnasazi(*args)

def Eig(*args):
  """
    Eig(Operator Op, MultiVector ER, MultiVector EI)

    void MLAPI::Eig(const Operator
    &Op, MultiVector &ER, MultiVector &EI)

    Computes eigenvalues and eigenvectors using LAPACK (w/ one process
    only). 
    """
  return _ML.Eig(*args)

def Eigs(*args):
  """
    Eigs(Operator A, int NumEigenvalues, MultiVector ER, MultiVector EI)

    void MLAPI::Eigs(const Operator
    &A, int NumEigenvalues, MultiVector &ER, MultiVector &EI) 
    """
  return _ML.Eigs(*args)

def Gallery(*args):
  """
    Gallery(string ProblemType, Space MySpace) -> Operator

    Operator MLAPI::Gallery(const
    string ProblemType, const Space &MySpace)

    Creates a matrix using the TRIUTILS gallery. 
    """
  return _ML.Gallery(*args)

def GetShiftedLaplacian1D(*args):
  """
    GetShiftedLaplacian1D(int NX, double Factor = 0.99) -> Operator

    Operator
    MLAPI::GetShiftedLaplacian1D(const int NX, const double Factor=0.99)

    Creates a 1D shifted Laplacian. 
    """
  return _ML.GetShiftedLaplacian1D(*args)

def GetShiftedLaplacian2D(*args):
  """
    GetShiftedLaplacian2D(int NX, int NY, double Factor = 0.99, bool RandomScale = False) -> Operator

    Operator
    MLAPI::GetShiftedLaplacian2D(const int NX, const int NY, const double
    Factor=0.99, const bool RandomScale=false)

    Creates a 2D shifted Laplacian. 
    """
  return _ML.GetShiftedLaplacian2D(*args)

def ReadMatrix(*args):
  """
    ReadMatrix(char FileName) -> Operator

    Operator
    MLAPI::ReadMatrix(const char *FileName)

    Reads a matrix in MATLAB format. 
    """
  return _ML.ReadMatrix(*args)

def GetRecirc2D(*args):
  """
    GetRecirc2D(int NX, int NY, double conv, double diff) -> Operator

    Operator
    MLAPI::GetRecirc2D(const int NX, const int NY, const double conv,
    const double diff)

    Creates a recirculation problem in 2D. 
    """
  return _ML.GetRecirc2D(*args)

def ReadParameterList(*args):
  """
    ReadParameterList(char FileName) -> ParameterList

    Teuchos::ParameterList MLAPI::ReadParameterList(const char *FileName)

    Populates a list from specified file. 
    """
  return _ML.ReadParameterList(*args)

def GetPNonSmoothed(*args):
  """
    GetPNonSmoothed(Operator A, MultiVector ThisNS, MultiVector NextNS, 
        PyObject obj) -> Operator
    """
  return _ML.GetPNonSmoothed(*args)

def Iterate(*args):
  """
    Iterate(Operator A, MultiVector LHS, MultiVector RHS, BaseOperator Prec, 
        PyObject obj) -> bool
    """
  return _ML.Iterate(*args)
# This file is compatible with both classic and new-style classes.


def __add__(*args):
  """
    __add__(MultiVector x, MultiVector y) -> MultiVector
    __add__(MultiVector x, double alpha) -> MultiVector
    __add__(double alpha, MultiVector x) -> MultiVector
    __add__(Operator A, Operator B) -> Operator
    """
  return _ML.__add__(*args)

def __sub__(*args):
  """
    __sub__(MultiVector x, MultiVector y) -> MultiVector
    __sub__(MultiVector x, double alpha) -> MultiVector
    __sub__(double alpha, MultiVector x) -> MultiVector
    __sub__(Operator A, Operator B) -> Operator
    """
  return _ML.__sub__(*args)

def __div__(*args):
  """
    __div__(Operator A, double alpha) -> Operator
    __div__(MultiVector x, double alpha) -> MultiVector
    """
  return _ML.__div__(*args)

def __mul__(*args):
  """
    __mul__(Operator A, MultiVector y) -> MultiVector
    __mul__(Operator A, Operator B) -> Operator
    __mul__(Operator A, double alpha) -> Operator
    __mul__(double alpha, Operator A) -> Operator
    __mul__(MultiVector x, double alpha) -> MultiVector
    __mul__(double alpha, MultiVector x) -> MultiVector
    __mul__(BaseOperator A, MultiVector x) -> MultiVector
    __mul__(MultiVector x, MultiVector y) -> double
    """
  return _ML.__mul__(*args)

def GetPtent(*args):
  """
    GetPtent(Operator A, ParameterList List, MultiVector ThisNS, 
        Operator Ptent, MultiVector NextNS)
    GetPtent(Operator A, ParameterList List, Operator Ptent)
    GetPtent(RowMatrix A, ParameterList List, double thisns, Teuchos::RCP<(Epetra_CrsMatrix)> Ptent, 
        Teuchos::RCP<(Epetra_MultiVector)> NextNS, 
        int domainoffset = 0)
    GetPtent(RowMatrix A, ParameterList List, double thisns, Teuchos::RCP<(Epetra_CrsMatrix)> Ptent, 
        int domainoffset = 0)

    void MLAPI::GetPtent(const
    Epetra_RowMatrix &A, Teuchos::ParameterList &List, double *thisns,
    Teuchos::RCP< Epetra_CrsMatrix > &Ptent, const int domainoffset=0)

    Builds the tentative prolongator using aggregation.

    Build Ptent and NextNS as usual but as Epetra objects.

    Parameters:
    -----------

    A:  (in): Matrix to be aggregated on

    List:  (in): ParameterList containing ML options

    thisns:  (in): nullspace in format ML accepts

    Ptent(out):  ::  Matrix containing tentative prolongator

    domainoffset:  (in,optional): give an offset such that the domainmap
    of Ptent starts global numbering from domainoffset instead from zero.
    This is useful to create block matrices.

    Michael Gee (gee@lnm.mw.tum.de) 
    """
  return _ML.GetPtent(*args)