python-pytrilinos 10.4.0.dfsg-1ubuntu2 / usr / share / pyshared / PyTrilinos / AztecOO.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.AztecOO is the python interface to the Trilinos iterative
linear solver package AztecOO:

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

AztecOO is the object-oriented interface to Aztec, Sandia's venerable
Krylov-space linear system solver package.  Note that the C++ version
of AztecOO uses the prefix 'AztecOO_' which has been stripped from the
python version.  AztecOO requires the Epetra module. The IFPACK and ML
modules can extend the preconditioning capabilities of AztecOO.

AztecOO has a single class:

    * AztecOO  - Object-oriented interface to Aztec package

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

    * exAztecOO.py
    * exAztecOO_Operator.py
    * exAztecOO_RowMatrix.py
    * exAztecOO_BasicRowMatrix.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('_AztecOO', [dirname(__file__)])
        except ImportError:
            import _AztecOO
            return _AztecOO
        if fp is not None:
            try:
                _mod = imp.load_module('_AztecOO', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _AztecOO = swig_import_helper()
    del swig_import_helper
else:
    import _AztecOO
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


AZ_NOT_MPI = _AztecOO.AZ_NOT_MPI
AZ_MSG_TYPE = _AztecOO.AZ_MSG_TYPE
AZ_NUM_MSGS = _AztecOO.AZ_NUM_MSGS
AZ_MAX_MEMORY_SIZE = _AztecOO.AZ_MAX_MEMORY_SIZE
AZ_MAX_MSG_BUFF_SIZE = _AztecOO.AZ_MAX_MSG_BUFF_SIZE
AZ_MAX_NEIGHBORS = _AztecOO.AZ_MAX_NEIGHBORS
AZ_MAX_MESSAGE_SIZE = _AztecOO.AZ_MAX_MESSAGE_SIZE
AZ_FALSE = _AztecOO.AZ_FALSE
AZ_TRUE = _AztecOO.AZ_TRUE
AZ_MAX_POLY_ORDER = _AztecOO.AZ_MAX_POLY_ORDER
AZ_default = _AztecOO.AZ_default
AZ_cg = _AztecOO.AZ_cg
AZ_gmres = _AztecOO.AZ_gmres
AZ_cgs = _AztecOO.AZ_cgs
AZ_tfqmr = _AztecOO.AZ_tfqmr
AZ_bicgstab = _AztecOO.AZ_bicgstab
AZ_slu = _AztecOO.AZ_slu
AZ_symmlq = _AztecOO.AZ_symmlq
AZ_GMRESR = _AztecOO.AZ_GMRESR
AZ_fixed_pt = _AztecOO.AZ_fixed_pt
AZ_analyze = _AztecOO.AZ_analyze
AZ_lu = _AztecOO.AZ_lu
AZ_cg_condnum = _AztecOO.AZ_cg_condnum
AZ_gmres_condnum = _AztecOO.AZ_gmres_condnum
AZ_BJacobi = _AztecOO.AZ_BJacobi
AZ_row_sum = _AztecOO.AZ_row_sum
AZ_sym_diag = _AztecOO.AZ_sym_diag
AZ_sym_row_sum = _AztecOO.AZ_sym_row_sum
AZ_equil = _AztecOO.AZ_equil
AZ_sym_BJacobi = _AztecOO.AZ_sym_BJacobi
AZ_none = _AztecOO.AZ_none
AZ_Jacobi = _AztecOO.AZ_Jacobi
AZ_sym_GS = _AztecOO.AZ_sym_GS
AZ_Neumann = _AztecOO.AZ_Neumann
AZ_ls = _AztecOO.AZ_ls
AZ_ilu = _AztecOO.AZ_ilu
AZ_bilu = _AztecOO.AZ_bilu
AZ_icc = _AztecOO.AZ_icc
AZ_ilut = _AztecOO.AZ_ilut
AZ_rilu = _AztecOO.AZ_rilu
AZ_recursive = _AztecOO.AZ_recursive
AZ_smoother = _AztecOO.AZ_smoother
AZ_dom_decomp = _AztecOO.AZ_dom_decomp
AZ_multilevel = _AztecOO.AZ_multilevel
AZ_user_precond = _AztecOO.AZ_user_precond
AZ_bilu_ifp = _AztecOO.AZ_bilu_ifp
AZ_r0 = _AztecOO.AZ_r0
AZ_rhs = _AztecOO.AZ_rhs
AZ_Anorm = _AztecOO.AZ_Anorm
AZ_sol = _AztecOO.AZ_sol
AZ_weighted = _AztecOO.AZ_weighted
AZ_expected_values = _AztecOO.AZ_expected_values
AZ_noscaled = _AztecOO.AZ_noscaled
AZTECOO_conv_test = _AztecOO.AZTECOO_conv_test
AZ_inf_noscaled = _AztecOO.AZ_inf_noscaled
AZ_all = _AztecOO.AZ_all
AZ_last = _AztecOO.AZ_last
AZ_summary = _AztecOO.AZ_summary
AZ_warnings = _AztecOO.AZ_warnings
AZ_input_form = _AztecOO.AZ_input_form
AZ_global_mat = _AztecOO.AZ_global_mat
AZ_explicit = _AztecOO.AZ_explicit
AZ_calc = _AztecOO.AZ_calc
AZ_recalc = _AztecOO.AZ_recalc
AZ_reuse = _AztecOO.AZ_reuse
AZ_sys_reuse = _AztecOO.AZ_sys_reuse
AZ_diag = _AztecOO.AZ_diag
AZ_full = _AztecOO.AZ_full
AZ_standard = _AztecOO.AZ_standard
AZ_symmetric = _AztecOO.AZ_symmetric
AZ_classic = _AztecOO.AZ_classic
AZ_modified = _AztecOO.AZ_modified
AZ_single_classic = _AztecOO.AZ_single_classic
AZ_single_modified = _AztecOO.AZ_single_modified
AZ_double_classic = _AztecOO.AZ_double_classic
AZ_double_modified = _AztecOO.AZ_double_modified
AZ_resid = _AztecOO.AZ_resid
AZ_rand = _AztecOO.AZ_rand
AZ_normal = _AztecOO.AZ_normal
AZ_param = _AztecOO.AZ_param
AZ_breakdown = _AztecOO.AZ_breakdown
AZ_maxits = _AztecOO.AZ_maxits
AZ_loss = _AztecOO.AZ_loss
AZ_ill_cond = _AztecOO.AZ_ill_cond
AZ_solver = _AztecOO.AZ_solver
AZ_scaling = _AztecOO.AZ_scaling
AZ_precond = _AztecOO.AZ_precond
AZ_conv = _AztecOO.AZ_conv
AZ_output = _AztecOO.AZ_output
AZ_pre_calc = _AztecOO.AZ_pre_calc
AZ_max_iter = _AztecOO.AZ_max_iter
AZ_poly_ord = _AztecOO.AZ_poly_ord
AZ_overlap = _AztecOO.AZ_overlap
AZ_type_overlap = _AztecOO.AZ_type_overlap
AZ_kspace = _AztecOO.AZ_kspace
AZ_orthog = _AztecOO.AZ_orthog
AZ_aux_vec = _AztecOO.AZ_aux_vec
AZ_reorder = _AztecOO.AZ_reorder
AZ_keep_info = _AztecOO.AZ_keep_info
AZ_recursion_level = _AztecOO.AZ_recursion_level
AZ_print_freq = _AztecOO.AZ_print_freq
AZ_graph_fill = _AztecOO.AZ_graph_fill
AZ_subdomain_solve = _AztecOO.AZ_subdomain_solve
AZ_init_guess = _AztecOO.AZ_init_guess
AZ_keep_kvecs = _AztecOO.AZ_keep_kvecs
AZ_apply_kvecs = _AztecOO.AZ_apply_kvecs
AZ_orth_kvecs = _AztecOO.AZ_orth_kvecs
AZ_ignore_scaling = _AztecOO.AZ_ignore_scaling
AZ_check_update_size = _AztecOO.AZ_check_update_size
AZ_extreme = _AztecOO.AZ_extreme
AZ_diagnostics = _AztecOO.AZ_diagnostics
AZ_tol = _AztecOO.AZ_tol
AZ_drop = _AztecOO.AZ_drop
AZ_ilut_fill = _AztecOO.AZ_ilut_fill
AZ_omega = _AztecOO.AZ_omega
AZ_rthresh = _AztecOO.AZ_rthresh
AZ_athresh = _AztecOO.AZ_athresh
AZ_update_reduction = _AztecOO.AZ_update_reduction
AZ_temp = _AztecOO.AZ_temp
AZ_ill_cond_thresh = _AztecOO.AZ_ill_cond_thresh
AZ_weights = _AztecOO.AZ_weights
AZ_matrix_type = _AztecOO.AZ_matrix_type
AZ_N_internal = _AztecOO.AZ_N_internal
AZ_N_border = _AztecOO.AZ_N_border
AZ_N_external = _AztecOO.AZ_N_external
AZ_N_int_blk = _AztecOO.AZ_N_int_blk
AZ_N_bord_blk = _AztecOO.AZ_N_bord_blk
AZ_N_ext_blk = _AztecOO.AZ_N_ext_blk
AZ_N_neigh = _AztecOO.AZ_N_neigh
AZ_total_send = _AztecOO.AZ_total_send
AZ_name = _AztecOO.AZ_name
AZ_internal_use = _AztecOO.AZ_internal_use
AZ_N_rows = _AztecOO.AZ_N_rows
AZ_neighbors = _AztecOO.AZ_neighbors
AZ_rec_length = _AztecOO.AZ_rec_length
AZ_send_length = _AztecOO.AZ_send_length
AZ_send_list = _AztecOO.AZ_send_list
SIZEOF_MPI_AZCOMM = _AztecOO.SIZEOF_MPI_AZCOMM
AZ_OPTIONS_SIZE = _AztecOO.AZ_OPTIONS_SIZE
AZ_FIRST_USER_OPTION = _AztecOO.AZ_FIRST_USER_OPTION
AZ_PARAMS_SIZE = _AztecOO.AZ_PARAMS_SIZE
AZ_FIRST_USER_PARAM = _AztecOO.AZ_FIRST_USER_PARAM
AZ_PROC_SIZE = _AztecOO.AZ_PROC_SIZE
AZ_STATUS_SIZE = _AztecOO.AZ_STATUS_SIZE
AZ_COMM_SIZE = _AztecOO.AZ_COMM_SIZE
AZ_CONV_INFO_SIZE = _AztecOO.AZ_CONV_INFO_SIZE
AZ_COMMLESS_DATA_ORG_SIZE = _AztecOO.AZ_COMMLESS_DATA_ORG_SIZE
AZ_its = _AztecOO.AZ_its
AZ_why = _AztecOO.AZ_why
AZ_r = _AztecOO.AZ_r
AZ_rec_r = _AztecOO.AZ_rec_r
AZ_scaled_r = _AztecOO.AZ_scaled_r
AZ_first_precond = _AztecOO.AZ_first_precond
AZ_solve_time = _AztecOO.AZ_solve_time
AZ_Aztec_version = _AztecOO.AZ_Aztec_version
AZ_condnum = _AztecOO.AZ_condnum
AZ_lambda_min = _AztecOO.AZ_lambda_min
AZ_lambda_max = _AztecOO.AZ_lambda_max
AZ_Comm_MPI = _AztecOO.AZ_Comm_MPI
AZ_node = _AztecOO.AZ_node
AZ_N_procs = _AztecOO.AZ_N_procs
AZ_dim = _AztecOO.AZ_dim
AZ_MPI_Tag = _AztecOO.AZ_MPI_Tag
AZ_Comm_Set = _AztecOO.AZ_Comm_Set
AZ_Done_by_User = _AztecOO.AZ_Done_by_User
AZ_linear = _AztecOO.AZ_linear
AZ_file = _AztecOO.AZ_file
AZ_box = _AztecOO.AZ_box
AZ_ALLOC = _AztecOO.AZ_ALLOC
AZ_CLEAR = _AztecOO.AZ_CLEAR
AZ_REALLOC = _AztecOO.AZ_REALLOC
AZ_SELECTIVE_CLEAR = _AztecOO.AZ_SELECTIVE_CLEAR
AZ_SPEC_REALLOC = _AztecOO.AZ_SPEC_REALLOC
AZ_RESET_STRING = _AztecOO.AZ_RESET_STRING
AZ_SUBSELECTIVE_CLEAR = _AztecOO.AZ_SUBSELECTIVE_CLEAR
AZ_EVERYBODY_BUT_CLEAR = _AztecOO.AZ_EVERYBODY_BUT_CLEAR
AZ_EMPTY = _AztecOO.AZ_EMPTY
AZ_LOOKFOR_PRINT = _AztecOO.AZ_LOOKFOR_PRINT
AZ_CLEAR_ALL = _AztecOO.AZ_CLEAR_ALL
AZ_SYS = _AztecOO.AZ_SYS
AZ_OLD_ADDRESS = _AztecOO.AZ_OLD_ADDRESS
AZ_NEW_ADDRESS = _AztecOO.AZ_NEW_ADDRESS
AZ_SPECIAL = _AztecOO.AZ_SPECIAL
AZ_SOLVER_PARAMS = _AztecOO.AZ_SOLVER_PARAMS
AZ_MSR_MATRIX = _AztecOO.AZ_MSR_MATRIX
AZ_VBR_MATRIX = _AztecOO.AZ_VBR_MATRIX
AZ_USER_MATRIX = _AztecOO.AZ_USER_MATRIX
AZ_SCALE_MAT_RHS_SOL = _AztecOO.AZ_SCALE_MAT_RHS_SOL
AZ_SCALE_RHS = _AztecOO.AZ_SCALE_RHS
AZ_INVSCALE_RHS = _AztecOO.AZ_INVSCALE_RHS
AZ_SCALE_SOL = _AztecOO.AZ_SCALE_SOL
AZ_INVSCALE_SOL = _AztecOO.AZ_INVSCALE_SOL
AZ_DESTROY_SCALING_DATA = _AztecOO.AZ_DESTROY_SCALING_DATA
AZ_NOT_FIRST = _AztecOO.AZ_NOT_FIRST
AZ_FIRST_TIME = _AztecOO.AZ_FIRST_TIME
AZ_QUIT = _AztecOO.AZ_QUIT
AZ_CONTINUE = _AztecOO.AZ_CONTINUE
AZ_PACK = _AztecOO.AZ_PACK
AZ_SEND = _AztecOO.AZ_SEND
AZ_CONVERT_TO_LOCAL = _AztecOO.AZ_CONVERT_TO_LOCAL
AZ_CONVERT_BACK_TO_GLOBAL = _AztecOO.AZ_CONVERT_BACK_TO_GLOBAL
AZ_NO_EXTRA_SPACE = _AztecOO.AZ_NO_EXTRA_SPACE
AZ_ZERO = _AztecOO.AZ_ZERO
AZ_NOT_ZERO = _AztecOO.AZ_NOT_ZERO
AZ_Nspace = _AztecOO.AZ_Nspace
AZ_Nkept = _AztecOO.AZ_Nkept
AZ_left_scaling = _AztecOO.AZ_left_scaling
AZ_right_scaling = _AztecOO.AZ_right_scaling
AZ_left_and_right_scaling = _AztecOO.AZ_left_and_right_scaling
AZ_call_scale_f = _AztecOO.AZ_call_scale_f
AZ_inv_scaling = _AztecOO.AZ_inv_scaling
AZ_low = _AztecOO.AZ_low
AZ_high = _AztecOO.AZ_high
AZ_TEST_ELE = _AztecOO.AZ_TEST_ELE
AZ_ALL = _AztecOO.AZ_ALL
AZ_EXTERNS = _AztecOO.AZ_EXTERNS
AZ_GLOBAL = _AztecOO.AZ_GLOBAL
AZ_LOCAL = _AztecOO.AZ_LOCAL
import Epetra
import Teuchos

def AztecOO_Version(*args):
  """
    AztecOO_Version() -> string

    string AztecOO_Version() 
    """
  return _AztecOO.AztecOO_Version(*args)
__version__ = AztecOO_Version().split()[3]

class AztecOO(_object):
    """
    AztecOO: An object-oriented wrapper for Aztec.

    Currently it accepts a Petra matrix, initial guess and RHS as separate
    arguments, or alternatively, accepts a Epetra_LinearProblem. If
    constructed using a Epetra_LinearProblem, AztecOO will infer some
    solver/preconditioner, etc., options and parameters. Users may
    override these choices and manually choose from among the full set of
    Aztec options using the SetAztecOption() and SetAztecParam()
    functions.

    AztecOO will solve a linear systems of equations: $ AX=B $, using
    Epetra objects and the Aztec solver library, where $A$ is an
    Epetra_Operator or Epetra_RowMatrix (note that the Epetra_Operator
    class is a base class for Epetra_RowMatrix so that Epetra_RowMatrix
    isa Epetra_Operator.) $X$ and $B$ are Epetra_MultiVector objects.

    WARNING:   AztecOO does not presently support solution of more than
    one simultaneous right-hand-side.

    C++ includes: AztecOO.h 
    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AztecOO, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AztecOO, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, Operator A, Epetra_MultiVector X, Epetra_MultiVector B) -> AztecOO
        __init__(self, RowMatrix A, Epetra_MultiVector X, Epetra_MultiVector B) -> AztecOO
        __init__(self, LinearProblem LinearProblem) -> AztecOO
        __init__(self) -> AztecOO
        __init__(self, AztecOO Solver) -> AztecOO

        AztecOO::AztecOO(const
        AztecOO &Solver)

        AztecOO Copy Constructor.

        Makes copy of an existing AztecOO instance. 
        """
        this = _AztecOO.new_AztecOO(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AztecOO.delete_AztecOO
    __del__ = lambda self : None;
    def SetProblem(self, *args):
        """
        SetProblem(self, LinearProblem prob, bool call_SetPrecMatrix = False) -> int

        int
        AztecOO::SetProblem(const Epetra_LinearProblem &prob, bool
        call_SetPrecMatrix=false)

        AztecOO Epetra_LinearProblem Set.

        Associates an already defined Epetra_LinearProblem as the problem that
        will be solved during iterations. This method allows the user to
        change which problem is being solved by an existing AztecOO object.

        Internally calls SetUserMatrix() if the Epetra_LinearProblem's
        operator can be cast to Epetra_RowMatrix, otherwise calls
        SetUserOperator().

        IMPORTANT WARNING *** This method calls SetUserMatrix(), which also
        sets the *preconditioner* matrix to the matrix passed in, by
        internally calling SetPrecMatrix(), but *ONLY* if SetPrecMatrix()
        hasn't previously been called. If the user wants to make sure that any
        pre-existing preconditioner is replaced, they must set the optional
        bool argument 'call_SetPrecMatrix' to true, which will force this
        function to call SetPrecMatrix().

        WARNING:  If a preconditioner has been pre-built and associated with
        this AztecOO object, the Epetra_LinearProblem being passed in to this
        method must have compatible domain and range maps. 
        """
        return _AztecOO.AztecOO_SetProblem(self, *args)

    def SetUserOperator(self, *args):
        """
        SetUserOperator(self, Operator UserOperator) -> int

        int
        AztecOO::SetUserOperator(Epetra_Operator *UserOperator)

        AztecOO User Operator Set.

        Associates an already defined Epetra_Operator as the linear operator
        for the linear system system that will be solved during iterations.
        This set method allows the user to pass any type of linear operator to
        AztecOO, as long as the operator implements the Epetra_Operator pure
        virtual class, and has proper domain and range map dimensions.
        Epetra_CrsMatrix and Epetra_VbrMatrix objects can be passed in through
        this method. 
        """
        return _AztecOO.AztecOO_SetUserOperator(self, *args)

    def SetUserMatrix(self, *args):
        """
        SetUserMatrix(self, RowMatrix UserMatrix, bool call_SetPrecMatrix = False) -> int

        int
        AztecOO::SetUserMatrix(Epetra_RowMatrix *UserMatrix, bool
        call_SetPrecMatrix=false)

        AztecOO User Matrix Set.

        Associates an already defined Epetra_Matrix as the matrix that will be
        used by AztecOO as the linear operator when solving the linear system.
        Epetra_CrsMatrix and Epetra_VbrMatrix objects can be passed in through
        this method.

        IMPORTANT WARNING *** This method sets the preconditioner matrix to
        the matrix passed in here, by internally calling SetPrecMatrix(), but
        *ONLY* if SetPrecMatrix() hasn't previously been called. If the user
        wants to make sure that any pre-existing preconditioner is replaced,
        they must set the optional bool argument 'call_SetPrecMatrix' to true,
        which will force this function to call SetPrecMatrix(). 
        """
        return _AztecOO.AztecOO_SetUserMatrix(self, *args)

    def SetLHS(self, *args):
        """
        SetLHS(self, Epetra_MultiVector X) -> int

        int
        AztecOO::SetLHS(Epetra_MultiVector *X)

        AztecOO LHS Set.

        Associates an already defined Epetra_MultiVector (or Epetra_Vector) as
        the initial guess and location where the solution will be return. 
        """
        return _AztecOO.AztecOO_SetLHS(self, *args)

    def SetRHS(self, *args):
        """
        SetRHS(self, Epetra_MultiVector B) -> int

        int
        AztecOO::SetRHS(Epetra_MultiVector *B)

        AztecOO RHS Set.

        Associates an already defined Epetra_MultiVector (or Epetra_Vector) as
        the right-hand-side of the linear system. 
        """
        return _AztecOO.AztecOO_SetRHS(self, *args)

    def UnsetLHSRHS(self, *args):
        """UnsetLHSRHS(self) -> int"""
        return _AztecOO.AztecOO_UnsetLHSRHS(self, *args)

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

        int
        AztecOO::SetPrecMatrix(Epetra_RowMatrix *PrecMatrix)

        AztecOO Preconditioner Matrix Set.

        Associates an already defined Epetra_Matrix as the matrix that will be
        used by AztecOO when constructing native AztecOO preconditioners. By
        default, if AztecOO native preconditioners are used, the original
        operator matrix will be used as the source for deriving the
        preconditioner. However, there are instances where a user would like
        to have the preconditioner be defined using a different matrix than
        the original operator matrix. Another common situation is where the
        user may not have the operator in matrix form but has a matrix that
        approximates the operator and can be used as the basis for an
        incomplete factorization. This set method allows the user to pass any
        Epetra_RowMatrix to AztecOO for use in constructing an AztecOO native
        preconditioner, as long as the matrix implements the Epetra_RowMatrix
        pure virtual class, and has proper domain and range map dimensions.
        Epetra_CrsMatrix and Epetra_VbrMatrix objects can be passed in through
        this method. 
        """
        return _AztecOO.AztecOO_SetPrecMatrix(self, *args)

    def SetPrecOperator(self, *args):
        """
        SetPrecOperator(self, Operator PrecOperator) -> int

        int
        AztecOO::SetPrecOperator(Epetra_Operator *PrecOperator)

        AztecOO External Preconditioner Set.

        Associates an already defined Epetra_Operator as the preconditioner
        that will be called during iterations. This set method allows the user
        to pass any type of preconditioner to AztecOO, as long as the
        preconditioner implements the Epetra_Operator pure virtual class, and
        has proper domain and range map dimensions. Ifpack preconditioners can
        be passed in through this method. 
        """
        return _AztecOO.AztecOO_SetPrecOperator(self, *args)

    def SetStatusTest(self, *args):
        """
        SetStatusTest(self, AztecOO_StatusTest StatusTest) -> int

        int
        AztecOO::SetStatusTest(AztecOO_StatusTest *StatusTest)

        AztecOO External Convergence/Status Test Set.

        Assigns an already defined AztecOO_StatusTest object as the class that
        will determine when iterations should stop, either because convergence
        was reached or the iteration failed. This method allows a large
        variety of convergence tests to be used with AztecOO. The
        AztecOO_StatusTest class is a pure virtual class, so any class that
        implements its interface can be passed in to this set method. A number
        of pre-defined AztecOO_StatusTest derived classes are already
        available, including AztecOO_StatusTestCombo, a class that allows
        logical combinations of other status test objects for sophisticated
        convergence testing. 
        """
        return _AztecOO.AztecOO_SetStatusTest(self, *args)

    def SetOutputStream(self, *args):
        """
        SetOutputStream(self,  ostrm)

        void
        AztecOO::SetOutputStream(std::ostream &ostrm)

        Set std::ostream for Aztec's screen output.

        This sets the destination for output that Aztec would normally send to
        stdout. 
        """
        return _AztecOO.AztecOO_SetOutputStream(self, *args)

    def SetErrorStream(self, *args):
        """
        SetErrorStream(self,  errstrm)

        void
        AztecOO::SetErrorStream(std::ostream &errstrm)

        Set std::ostream for Aztec's error output.

        This sets the destination for output that Aztec would normally send to
        stderr. 
        """
        return _AztecOO.AztecOO_SetErrorStream(self, *args)

    def SetPreconditioner(self, *args):
        """
        SetPreconditioner(self, AZ_PRECOND Prec) -> int
        SetPreconditioner(self, AZ_PREC_FUN prec_function, void prec_data) -> int

        int
        AztecOO::SetPreconditioner(AZ_PREC_FUN prec_function, void *prec_data)

        AztecOO External Preconditioner Set (function and data).

        Associates an external function and data pointer with preconditioner

        """
        return _AztecOO.AztecOO_SetPreconditioner(self, *args)

    def SetScaling(self, *args):
        """
        SetScaling(self, AZ_SCALING Scaling) -> int

        int
        AztecOO::SetScaling(struct AZ_SCALING *Scaling)

        AztecOO External Scaling Set.

        Associates an already defined Aztec scaling object with this solve. 
        """
        return _AztecOO.AztecOO_SetScaling(self, *args)

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

        int
        AztecOO::SetMatrixName(int label)

        AztecOO Label Matrix for Aztec.

        This is used to label individual matrices within Aztec. This might be
        useful if several Aztec invocations are involved corresponding to
        different matrices. 
        """
        return _AztecOO.AztecOO_SetMatrixName(self, *args)

    def SetLabel(self, *args):
        """
        SetLabel(self, char Label)

        void
        AztecOO::SetLabel(const char *const Label)

        Set Label this AztecOO object.

        Defines the label used to describe the this object. 
        """
        return _AztecOO.AztecOO_SetLabel(self, *args)

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

        const char *
        AztecOO::GetLabel() const

        Get the label describing this AztecOO object.

        Returns the string used to define this object. 
        """
        return _AztecOO.AztecOO_GetLabel(self, *args)

    def ConstructPreconditioner(self, *args):
        """
        ConstructPreconditioner(self, double condest) -> int

        int
        AztecOO::ConstructPreconditioner(double &condest)

        Forces explicit construction and retention of an AztecOO native
        preconditioner.

        AztecOO typically constructs the preconditioner on the first call to
        the solve function. However, there are situations where we would like
        to compute the preconditioner ahead of time. One particular case is
        when we want to confirm that the preconditioner well-conditioned. This
        method allows us to precompute the preconditioner. It also provides a
        estimate of the condition number of the preconditioner. If  condest is
        large, e.g., > 1.0e+14, it is likely the preconditioner will fail. In
        this case, using threshold values (available in the incomplete
        factorizations) can be used to reduce the condition number.

        Note: This method does not work for user-defined preconditioners
        (defined via calls to SetPrecOperator(). It will return with an error
        code of -1 for this case. 
        """
        return _AztecOO.AztecOO_ConstructPreconditioner(self, *args)

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

        int
        AztecOO::DestroyPreconditioner()

        Destroys a preconditioner computed using ConstructPreconditioner().

        The ConstructPreconditioner() method creates a persistent
        preconditioner. In other words the preconditioner will be used by all
        calls to the Iterate() method. DestroyPreconditioner() deletes the
        current preconditioner and restores AztecOO to a state where the
        preconditioner will computed on first use of the preconditioner solve.

        """
        return _AztecOO.AztecOO_DestroyPreconditioner(self, *args)

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

        double AztecOO::Condest()
        const

        Returns the condition number estimate for the current preconditioner,
        if one exists, returns -1.0 if no estimate. 
        """
        return _AztecOO.AztecOO_Condest(self, *args)

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

        int AztecOO::CheckInput()
        const

        Prints a summary of solver parameters, performs simple sanity checks.

        """
        return _AztecOO.AztecOO_CheckInput(self, *args)

    def GetProblem(self, *args):
        """
        GetProblem(self) -> LinearProblem

        Epetra_LinearProblem*
        AztecOO::GetProblem() const

        Get a pointer to the Linear Problem used to construct this solver;
        returns zero if not available. 
        """
        return _AztecOO.AztecOO_GetProblem(self, *args)

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

        Epetra_Operator*
        AztecOO::GetUserOperator() const

        Get a pointer to the user operator A. 
        """
        return _AztecOO.AztecOO_GetUserOperator(self, *args)

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

        Epetra_RowMatrix*
        AztecOO::GetUserMatrix() const

        Get a pointer to the user matrix A. 
        """
        return _AztecOO.AztecOO_GetUserMatrix(self, *args)

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

        Epetra_Operator*
        AztecOO::GetPrecOperator() const

        Get a pointer to the preconditioner operator. 
        """
        return _AztecOO.AztecOO_GetPrecOperator(self, *args)

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

        Epetra_RowMatrix*
        AztecOO::GetPrecMatrix() const

        Get a pointer to the matrix used to construct the preconditioner. 
        """
        return _AztecOO.AztecOO_GetPrecMatrix(self, *args)

    def GetLHS(self, *args):
        """
        GetLHS(self) -> Epetra_MultiVector

        Epetra_MultiVector*
        AztecOO::GetLHS() const

        Get a pointer to the left-hand-side X. 
        """
        return _AztecOO.AztecOO_GetLHS(self, *args)

    def GetRHS(self, *args):
        """
        GetRHS(self) -> Epetra_MultiVector

        Epetra_MultiVector*
        AztecOO::GetRHS() const

        Get a pointer to the right-hand-side B. 
        """
        return _AztecOO.AztecOO_GetRHS(self, *args)

    def PrintLinearSystem(self, *args):
        """
        PrintLinearSystem(self, char name)

        void
        AztecOO::PrintLinearSystem(const char *name)

        Print linear-system to files.

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

        name:  Print the matrix to the file A_'name', and print the solution
        and rhs vectors to files X_'name' and B_'name', respectively. Will
        only produce a matrix file if the run-time-type of the matrix is
        either Epetra_CrsMatrix or Epetra_VbrMatrix. 
        """
        return _AztecOO.AztecOO_PrintLinearSystem(self, *args)

    def SetParameters(self, *args):
        """SetParameters(self, ParameterList parameterlist, bool cerr_warning_if_unused = False) -> int"""
        return _AztecOO.AztecOO_SetParameters(self, *args)

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

        int
        AztecOO::SetAztecDefaults()

        AztecOO function to restore default options/parameter settings.

        This function is called automatically within AztecOO's constructor,
        but if constructed using a Epetra_LinearProblem object, some options
        are reset based on the ProblemDifficultyLevel associated with the
        Epetra_LinearProblem.

        See the Aztec 2.1 User Guide for a complete list of these options.

        WARNING:  In AztecOO, the default value of options[AZ_poly_ord] is set
        to 1. This is different than Aztec 2.1, but the preferred value since
        Jacobi preconditioning is used much more often than polynomial
        preconditioning and one step of Jacobi is far more effective than 3
        steps. 
        """
        return _AztecOO.AztecOO_SetAztecDefaults(self, *args)

    def SetAztecOption(self, *args):
        """
        SetAztecOption(self, int option, int value) -> int

        int
        AztecOO::SetAztecOption(int option, int value)

        AztecOO option setting function.

        Set a specific Aztec option value. Example:
        problem.SetAztecOption(AZ_precond, AZ_Jacobi)

        See the Aztec 2.1 User Guide for a complete list of these options. 
        """
        return _AztecOO.AztecOO_SetAztecOption(self, *args)

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

        int
        AztecOO::GetAztecOption(int option)

        AztecOO option getting function.

        Get a specific Aztec optioin value. Example:
        problem.GetAztecOption(AZ_precond)

        See the Aztec 2.1 User Guide for a complete list of these options. 
        """
        return _AztecOO.AztecOO_GetAztecOption(self, *args)

    def SetAztecParam(self, *args):
        """
        SetAztecParam(self, int param, double value) -> int

        int
        AztecOO::SetAztecParam(int param, double value)

        AztecOO param setting function.

        Set a specific Aztec parameter value. Example:
        problem.SetAztecParam(AZ_drop, 1.0E-6)

        See the Aztec 2.1 User Guide for a complete list of these parameters.

        """
        return _AztecOO.AztecOO_SetAztecParam(self, *args)

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

        int
        AztecOO::SetAllAztecOptions(const int *options)

        AztecOO option setting function.

        Set all Aztec option values using an existing Aztec options array. 
        """
        return _AztecOO.AztecOO_SetAllAztecOptions(self, *args)

    def SetAllAztecParams(self, *args):
        """
        SetAllAztecParams(self, double params) -> int

        int
        AztecOO::SetAllAztecParams(const double *params)

        AztecOO param setting function.

        Set all Aztec parameter values using an existing Aztec params array.

        """
        return _AztecOO.AztecOO_SetAllAztecParams(self, *args)

    def Iterate(self, *args):
        """
        Iterate(self, int MaxIters, double Tolerance) -> int
        Iterate(self, RowMatrix A, Epetra_MultiVector X, Epetra_MultiVector B, 
            int MaxIters, double Tolerance) -> int

        int
        AztecOO::Iterate(Epetra_RowMatrix *A, Epetra_MultiVector *X,
        Epetra_MultiVector *B, int MaxIters, double Tolerance)

        AztecOO iteration function.

        Iterates on the specified matrix and vectors until MaxIters or
        Tolerance is reached.. 
        """
        return _AztecOO.AztecOO_Iterate(self, *args)

    def recursiveIterate(self, *args):
        """
        recursiveIterate(self, int MaxIters, double Tolerance) -> int

        int
        AztecOO::recursiveIterate(int MaxIters, double Tolerance)

        AztecOO iteration functions.

        Iterates on the current problem until MaxIters or Tolerance is
        reached.. This one should be suitable for recursive invocations of
        Aztec. 
        """
        return _AztecOO.AztecOO_recursiveIterate(self, *args)

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

        int
        AztecOO::SetUseAdaptiveDefaultsTrue()

        Force the AdaptiveIterate() method to use default adaptive strategy.

        """
        return _AztecOO.AztecOO_SetUseAdaptiveDefaultsTrue(self, *args)

    def SetAdaptiveParams(self, *args):
        """
        SetAdaptiveParams(self, int NumTrials, double athresholds, double rthresholds, 
            double condestThreshold, double maxFill, 
            int maxKspace) -> int

        int
        AztecOO::SetAdaptiveParams(int NumTrials, double *athresholds, double
        *rthresholds, double condestThreshold, double maxFill, int maxKspace)

        Set the parameter that control the AdaptiveIterate() method.

        The AdaptiveIterate() method attempts to solve a given problem using
        multiple preconditioner and iterative method tuning parameters. There
        are defaults that are coded into AdaptiveIterate() method, but the
        defaults can be over-ridden by the use of the SetAdaptiveParams()
        method. Details of condition number management follow:

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

        NumTrials:  In The number of Athresh and Rthresh pairs that should be
        tried when attempting to stabilize the preconditioner.

        athresholds:  In The list of absolute threshold values that should be
        tried when attempting to stabilize the preconditioner.

        rthresholds:  In The list of relative threshold values that should be
        tried when attempting to stabilize the preconditioner.

        condestThreshold:  In If the condition number estimate of the
        preconditioner is above this number, no attempt will be made to try
        iterations. Instead a new preconditioner will be computed using the
        next threshold pair.

        maxFill:  In In addition to managing the condest, the
        AdaptiveIterate() method will also try to increase the preconditioner
        fill if it is determined that this might help. maxFill specifies the
        maximum fill allowed.

        maxKspace:  In In addition to managing the condest, the
        AdaptiveIterate() method will also try to increase the Krylov subspace
        size if GMRES is being used and it is determined that this might help.
        maxKspace specifies the maximum Krylov subspace allowed. 
        """
        return _AztecOO.AztecOO_SetAdaptiveParams(self, *args)

    def AdaptiveIterate(self, *args):
        """
        AdaptiveIterate(self, int MaxIters, int MaxSolveAttempts, double Tolerance) -> int

        int
        AztecOO::AdaptiveIterate(int MaxIters, int MaxSolveAttempts, double
        Tolerance)

        Attempts to solve the given linear problem using an adaptive strategy.

        """
        return _AztecOO.AztecOO_AdaptiveIterate(self, *args)

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

        int AztecOO::NumIters()
        const

        Returns the total number of iterations performed on this problem. 
        """
        return _AztecOO.AztecOO_NumIters(self, *args)

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

        double
        AztecOO::TrueResidual() const

        Returns the true unscaled residual for this problem. 
        """
        return _AztecOO.AztecOO_TrueResidual(self, *args)

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

        double
        AztecOO::ScaledResidual() const

        Returns the true scaled residual for this problem. 
        """
        return _AztecOO.AztecOO_ScaledResidual(self, *args)

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

        double
        AztecOO::RecursiveResidual() const

        Returns the recursive residual for this problem. 
        """
        return _AztecOO.AztecOO_RecursiveResidual(self, *args)

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

        double
        AztecOO::SolveTime() const

        Returns the solve time. 
        """
        return _AztecOO.AztecOO_SolveTime(self, *args)

    def GetAllAztecOptions(self, *args):
        """
        GetAllAztecOptions(self) -> PyObject

        const int*
        AztecOO::GetAllAztecOptions() const

        AztecOO option setting function.

        Return a pointer to an array (size AZ_OPTIONS_SIZE) of all of the
        currently set aztec options. 
        """
        return _AztecOO.AztecOO_GetAllAztecOptions(self, *args)

    def GetAllAztecParams(self, *args):
        """
        GetAllAztecParams(self) -> PyObject

        const double*
        AztecOO::GetAllAztecParams() const

        AztecOO param setting function.

        Return a pointer to an array (size AZ_PARAMS_SIZE) of all of the
        currently set aztec parameters. 
        """
        return _AztecOO.AztecOO_GetAllAztecParams(self, *args)

    def GetAztecStatus(self, *args):
        """
        GetAztecStatus(self) -> PyObject

        const double*
        AztecOO::GetAztecStatus() const

        Return the Aztec status after iterating.

        Returns pointer to the underlying Aztec Status array (of length
        AZ_STATUS_SIZE). See the Aztec documenation. 
        """
        return _AztecOO.AztecOO_GetAztecStatus(self, *args)

AztecOO_swigregister = _AztecOO.AztecOO_swigregister
AztecOO_swigregister(AztecOO)


def Epetra_Aztec_matvec(*args):
  """
    Epetra_Aztec_matvec(double x, double y, AZ_MATRIX Amat, int proc_config)

    void
    Epetra_Aztec_matvec(double x[], double y[], AZ_MATRIX *Amat, int
    proc_config[]) 
    """
  return _AztecOO.Epetra_Aztec_matvec(*args)

def Epetra_Aztec_matnorminf(*args):
  """
    Epetra_Aztec_matnorminf(AZ_MATRIX Amat) -> double

    double
    Epetra_Aztec_matnorminf(AZ_MATRIX *Amat) 
    """
  return _AztecOO.Epetra_Aztec_matnorminf(*args)

def Epetra_Aztec_operatorvec(*args):
  """
    Epetra_Aztec_operatorvec(double x, double y, AZ_MATRIX Amat, int proc_config)

    void
    Epetra_Aztec_operatorvec(double x[], double y[], AZ_MATRIX *Amat, int
    proc_config[]) 
    """
  return _AztecOO.Epetra_Aztec_operatorvec(*args)

def Epetra_Aztec_operatornorminf(*args):
  """
    Epetra_Aztec_operatornorminf(AZ_MATRIX Amat) -> double

    double
    Epetra_Aztec_operatornorminf(AZ_MATRIX *Amat) 
    """
  return _AztecOO.Epetra_Aztec_operatornorminf(*args)

def Epetra_Aztec_precond(*args):
  """
    Epetra_Aztec_precond(double x, int input_options, int proc_config, double input_params, 
        AZ_MATRIX Amat, AZ_PRECOND prec)

    void
    Epetra_Aztec_precond(double x[], int input_options[], int
    proc_config[], double input_params[], AZ_MATRIX *Amat, AZ_PRECOND
    *prec) 
    """
  return _AztecOO.Epetra_Aztec_precond(*args)

def Epetra_Aztec_getrow(*args):
  """
    Epetra_Aztec_getrow(int columns, double values, int row_lengths, AZ_MATRIX Amat, 
        int N_requested_rows, int requested_rows, 
        int allocated_space) -> int

    int
    Epetra_Aztec_getrow(int columns[], double values[], int row_lengths[],
    AZ_MATRIX *Amat, int N_requested_rows, int requested_rows[], int
    allocated_space) 
    """
  return _AztecOO.Epetra_Aztec_getrow(*args)

def Epetra_Aztec_comm_wrapper(*args):
  """
    Epetra_Aztec_comm_wrapper(double vec, AZ_MATRIX Amat) -> int

    int
    Epetra_Aztec_comm_wrapper(double vec[], AZ_MATRIX *Amat) 
    """
  return _AztecOO.Epetra_Aztec_comm_wrapper(*args)

def AztecOO_StatusTest_wrapper(*args):
  """
    AztecOO_StatusTest_wrapper(void conv_test_obj, void res_vector_obj, int iteration, 
        double res_vector, int print_info, int sol_updated, 
        int converged, int isnan, double rnorm, 
        int r_avail)

    void
    AztecOO_StatusTest_wrapper(void *conv_test_obj, void *res_vector_obj,
    int iteration, double *res_vector, int print_info, int sol_updated,
    int *converged, int *isnan, double *rnorm, int *r_avail) 
    """
  return _AztecOO.AztecOO_StatusTest_wrapper(*args)
# This file is compatible with both classic and new-style classes.