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

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _cmatrixmethods
else:
    import _cmatrixmethods

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


SUCCESS = _cmatrixmethods.SUCCESS
NUMERICAL = _cmatrixmethods.NUMERICAL
NOCONVERG = _cmatrixmethods.NOCONVERG
INVALID_INPUT = _cmatrixmethods.INVALID_INPUT
class CG_Unpre(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _cmatrixmethods.CG_Unpre_swiginit(self, _cmatrixmethods.new_CG_Unpre())
    __swig_destroy__ = _cmatrixmethods.delete_CG_Unpre

    def solve(self, m, rhs, x):
        return _cmatrixmethods.CG_Unpre_solve(self, m, rhs, x)

    def set_max_iterations(self, iters):
        return _cmatrixmethods.CG_Unpre_set_max_iterations(self, iters)

    def max_iterations(self):
        return _cmatrixmethods.CG_Unpre_max_iterations(self)

    def set_tolerance(self, tol):
        return _cmatrixmethods.CG_Unpre_set_tolerance(self, tol)

    def tolerance(self):
        return _cmatrixmethods.CG_Unpre_tolerance(self)

    def iterations(self):
        return _cmatrixmethods.CG_Unpre_iterations(self)

    def error(self):
        return _cmatrixmethods.CG_Unpre_error(self)

# Register CG_Unpre in _cmatrixmethods:
_cmatrixmethods.CG_Unpre_swigregister(CG_Unpre)
class CG_Diag(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _cmatrixmethods.CG_Diag_swiginit(self, _cmatrixmethods.new_CG_Diag())
    __swig_destroy__ = _cmatrixmethods.delete_CG_Diag

    def solve(self, m, rhs, x):
        return _cmatrixmethods.CG_Diag_solve(self, m, rhs, x)

    def set_max_iterations(self, iters):
        return _cmatrixmethods.CG_Diag_set_max_iterations(self, iters)

    def max_iterations(self):
        return _cmatrixmethods.CG_Diag_max_iterations(self)

    def set_tolerance(self, tol):
        return _cmatrixmethods.CG_Diag_set_tolerance(self, tol)

    def tolerance(self):
        return _cmatrixmethods.CG_Diag_tolerance(self)

    def iterations(self):
        return _cmatrixmethods.CG_Diag_iterations(self)

    def error(self):
        return _cmatrixmethods.CG_Diag_error(self)

# Register CG_Diag in _cmatrixmethods:
_cmatrixmethods.CG_Diag_swigregister(CG_Diag)
class CG_ILUT(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _cmatrixmethods.CG_ILUT_swiginit(self, _cmatrixmethods.new_CG_ILUT())
    __swig_destroy__ = _cmatrixmethods.delete_CG_ILUT

    def solve(self, m, rhs, x):
        return _cmatrixmethods.CG_ILUT_solve(self, m, rhs, x)

    def set_max_iterations(self, iters):
        return _cmatrixmethods.CG_ILUT_set_max_iterations(self, iters)

    def max_iterations(self):
        return _cmatrixmethods.CG_ILUT_max_iterations(self)

    def set_tolerance(self, tol):
        return _cmatrixmethods.CG_ILUT_set_tolerance(self, tol)

    def tolerance(self):
        return _cmatrixmethods.CG_ILUT_tolerance(self)

    def iterations(self):
        return _cmatrixmethods.CG_ILUT_iterations(self)

    def error(self):
        return _cmatrixmethods.CG_ILUT_error(self)

# Register CG_ILUT in _cmatrixmethods:
_cmatrixmethods.CG_ILUT_swigregister(CG_ILUT)
class CG_IC(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _cmatrixmethods.CG_IC_swiginit(self, _cmatrixmethods.new_CG_IC())
    __swig_destroy__ = _cmatrixmethods.delete_CG_IC

    def solve(self, m, rhs, x):
        return _cmatrixmethods.CG_IC_solve(self, m, rhs, x)

    def set_max_iterations(self, iters):
        return _cmatrixmethods.CG_IC_set_max_iterations(self, iters)

    def max_iterations(self):
        return _cmatrixmethods.CG_IC_max_iterations(self)

    def set_tolerance(self, tol):
        return _cmatrixmethods.CG_IC_set_tolerance(self, tol)

    def tolerance(self):
        return _cmatrixmethods.CG_IC_tolerance(self)

    def iterations(self):
        return _cmatrixmethods.CG_IC_iterations(self)

    def error(self):
        return _cmatrixmethods.CG_IC_error(self)

# Register CG_IC in _cmatrixmethods:
_cmatrixmethods.CG_IC_swigregister(CG_IC)
class BiCGStab_Unpre(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _cmatrixmethods.BiCGStab_Unpre_swiginit(self, _cmatrixmethods.new_BiCGStab_Unpre())
    __swig_destroy__ = _cmatrixmethods.delete_BiCGStab_Unpre

    def solve(self, m, rhs, x):
        return _cmatrixmethods.BiCGStab_Unpre_solve(self, m, rhs, x)

    def set_max_iterations(self, iters):
        return _cmatrixmethods.BiCGStab_Unpre_set_max_iterations(self, iters)

    def max_iterations(self):
        return _cmatrixmethods.BiCGStab_Unpre_max_iterations(self)

    def set_tolerance(self, tol):
        return _cmatrixmethods.BiCGStab_Unpre_set_tolerance(self, tol)

    def tolerance(self):
        return _cmatrixmethods.BiCGStab_Unpre_tolerance(self)

    def iterations(self):
        return _cmatrixmethods.BiCGStab_Unpre_iterations(self)

    def error(self):
        return _cmatrixmethods.BiCGStab_Unpre_error(self)

# Register BiCGStab_Unpre in _cmatrixmethods:
_cmatrixmethods.BiCGStab_Unpre_swigregister(BiCGStab_Unpre)
class BiCGStab_Diag(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _cmatrixmethods.BiCGStab_Diag_swiginit(self, _cmatrixmethods.new_BiCGStab_Diag())
    __swig_destroy__ = _cmatrixmethods.delete_BiCGStab_Diag

    def solve(self, m, rhs, x):
        return _cmatrixmethods.BiCGStab_Diag_solve(self, m, rhs, x)

    def set_max_iterations(self, iters):
        return _cmatrixmethods.BiCGStab_Diag_set_max_iterations(self, iters)

    def max_iterations(self):
        return _cmatrixmethods.BiCGStab_Diag_max_iterations(self)

    def set_tolerance(self, tol):
        return _cmatrixmethods.BiCGStab_Diag_set_tolerance(self, tol)

    def tolerance(self):
        return _cmatrixmethods.BiCGStab_Diag_tolerance(self)

    def iterations(self):
        return _cmatrixmethods.BiCGStab_Diag_iterations(self)

    def error(self):
        return _cmatrixmethods.BiCGStab_Diag_error(self)

# Register BiCGStab_Diag in _cmatrixmethods:
_cmatrixmethods.BiCGStab_Diag_swigregister(BiCGStab_Diag)
class BiCGStab_ILUT(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _cmatrixmethods.BiCGStab_ILUT_swiginit(self, _cmatrixmethods.new_BiCGStab_ILUT())
    __swig_destroy__ = _cmatrixmethods.delete_BiCGStab_ILUT

    def solve(self, m, rhs, x):
        return _cmatrixmethods.BiCGStab_ILUT_solve(self, m, rhs, x)

    def set_max_iterations(self, iters):
        return _cmatrixmethods.BiCGStab_ILUT_set_max_iterations(self, iters)

    def max_iterations(self):
        return _cmatrixmethods.BiCGStab_ILUT_max_iterations(self)

    def set_tolerance(self, tol):
        return _cmatrixmethods.BiCGStab_ILUT_set_tolerance(self, tol)

    def tolerance(self):
        return _cmatrixmethods.BiCGStab_ILUT_tolerance(self)

    def iterations(self):
        return _cmatrixmethods.BiCGStab_ILUT_iterations(self)

    def error(self):
        return _cmatrixmethods.BiCGStab_ILUT_error(self)

# Register BiCGStab_ILUT in _cmatrixmethods:
_cmatrixmethods.BiCGStab_ILUT_swigregister(BiCGStab_ILUT)
class BiCGStab_IC(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _cmatrixmethods.BiCGStab_IC_swiginit(self, _cmatrixmethods.new_BiCGStab_IC())
    __swig_destroy__ = _cmatrixmethods.delete_BiCGStab_IC

    def solve(self, m, rhs, x):
        return _cmatrixmethods.BiCGStab_IC_solve(self, m, rhs, x)

    def set_max_iterations(self, iters):
        return _cmatrixmethods.BiCGStab_IC_set_max_iterations(self, iters)

    def max_iterations(self):
        return _cmatrixmethods.BiCGStab_IC_max_iterations(self)

    def set_tolerance(self, tol):
        return _cmatrixmethods.BiCGStab_IC_set_tolerance(self, tol)

    def tolerance(self):
        return _cmatrixmethods.BiCGStab_IC_tolerance(self)

    def iterations(self):
        return _cmatrixmethods.BiCGStab_IC_iterations(self)

    def error(self):
        return _cmatrixmethods.BiCGStab_IC_error(self)

# Register BiCGStab_IC in _cmatrixmethods:
_cmatrixmethods.BiCGStab_IC_swigregister(BiCGStab_IC)
class SimplicialLLT(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _cmatrixmethods.SimplicialLLT_swiginit(self, _cmatrixmethods.new_SimplicialLLT())
    __swig_destroy__ = _cmatrixmethods.delete_SimplicialLLT

    def solve(self, m, rhs, x):
        return _cmatrixmethods.SimplicialLLT_solve(self, m, rhs, x)

# Register SimplicialLLT in _cmatrixmethods:
_cmatrixmethods.SimplicialLLT_swigregister(SimplicialLLT)
class SimplicialLDLT(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _cmatrixmethods.SimplicialLDLT_swiginit(self, _cmatrixmethods.new_SimplicialLDLT())
    __swig_destroy__ = _cmatrixmethods.delete_SimplicialLDLT

    def solve(self, m, rhs, x):
        return _cmatrixmethods.SimplicialLDLT_solve(self, m, rhs, x)

# Register SimplicialLDLT in _cmatrixmethods:
_cmatrixmethods.SimplicialLDLT_swigregister(SimplicialLDLT)
class SparseLU(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _cmatrixmethods.SparseLU_swiginit(self, _cmatrixmethods.new_SparseLU())
    __swig_destroy__ = _cmatrixmethods.delete_SparseLU

    def solve(self, m, rhs, x):
        return _cmatrixmethods.SparseLU_solve(self, m, rhs, x)

# Register SparseLU in _cmatrixmethods:
_cmatrixmethods.SparseLU_swigregister(SparseLU)
class SparseQR(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _cmatrixmethods.SparseQR_swiginit(self, _cmatrixmethods.new_SparseQR())
    __swig_destroy__ = _cmatrixmethods.delete_SparseQR

    def solve(self, m, rhs, x):
        return _cmatrixmethods.SparseQR_solve(self, m, rhs, x)

# Register SparseQR in _cmatrixmethods:
_cmatrixmethods.SparseQR_swigregister(SparseQR)

