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

"""

PyTrilinos.LOCA.Homotopy is the python interface to namespace Homotopy
of the Trilinos continuation algorithm package LOCA:

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

The purpose of LOCA.Homotopy is to provide groups that allow for
Homotopy to be applied.  The python version of LOCA.Homotopy supports
the following classes:

    * Group          - LOCA's Homotopy algorithm
    * AbstractGroup  - Interface to underlying groups for homotopy calculations
    * DeflatedGroup  - LOCA's deflated Homotopy algorithm

"""


from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_Homotopy')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_Homotopy')
    _Homotopy = swig_import_helper()
    del swig_import_helper
elif _swig_python_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('_Homotopy', [dirname(__file__)])
        except ImportError:
            import _Homotopy
            return _Homotopy
        try:
            _mod = imp.load_module('_Homotopy', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _Homotopy = swig_import_helper()
    del swig_import_helper
else:
    import _Homotopy
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            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("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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,)

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

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


import PyTrilinos.Teuchos
import PyTrilinos.NOX.Abstract
import MultiContinuation
import Extended
import BorderedSystem
class Group(MultiContinuation.AbstractGroup, Extended.MultiAbstractGroup):
    """Proxy of C++ LOCA::Homotopy::Group class."""

    __swig_setmethods__ = {}
    for _s in [MultiContinuation.AbstractGroup, Extended.MultiAbstractGroup]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Group, name, value)
    __swig_getmethods__ = {}
    for _s in [MultiContinuation.AbstractGroup, Extended.MultiAbstractGroup]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Group, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(LOCA::Homotopy::Group self, ParameterList locaSublist, Teuchos::RCP< LOCA::GlobalData > const & global_data, Teuchos::RCP< LOCA::Homotopy::AbstractGroup > const & g, double scaleRandom=1.0, double scaleInitialGuess=0.0) -> Group
        __init__(LOCA::Homotopy::Group self, ParameterList locaSublist, Teuchos::RCP< LOCA::GlobalData > const & global_data, Teuchos::RCP< LOCA::Homotopy::AbstractGroup > const & g, Vector randomVector) -> Group
        __init__(LOCA::Homotopy::Group self, Group source, NOX::CopyType type) -> Group
        """
        this = _Homotopy.new_Group(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Homotopy.delete_Group

    def clone(self, *args):
        """clone(Group self, NOX::CopyType type) -> Teuchos::RCP< NOX::Abstract::Group >"""
        return _Homotopy.Group_clone(self, *args)


    def setX(self, *args):
        """setX(Group self, Vector y)"""
        return _Homotopy.Group_setX(self, *args)


    def computeX(self, *args):
        """computeX(Group self, Group g, Vector d, double step)"""
        return _Homotopy.Group_computeX(self, *args)


    def computeF(self, *args):
        """computeF(Group self) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.Group_computeF(self, *args)


    def computeJacobian(self, *args):
        """computeJacobian(Group self) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.Group_computeJacobian(self, *args)


    def computeGradient(self, *args):
        """computeGradient(Group self) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.Group_computeGradient(self, *args)


    def computeNewton(self, *args):
        """computeNewton(Group self, ParameterList params) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.Group_computeNewton(self, *args)


    def applyJacobian(self, *args):
        """applyJacobian(Group self, Vector input, Vector result) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.Group_applyJacobian(self, *args)


    def applyJacobianTranspose(self, *args):
        """applyJacobianTranspose(Group self, Vector input, Vector result) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.Group_applyJacobianTranspose(self, *args)


    def applyJacobianInverse(self, *args):
        """applyJacobianInverse(Group self, ParameterList params, Vector input, Vector result) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.Group_applyJacobianInverse(self, *args)


    def applyJacobianMultiVector(self, *args):
        """applyJacobianMultiVector(Group self, MultiVector input, MultiVector result) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.Group_applyJacobianMultiVector(self, *args)


    def applyJacobianTransposeMultiVector(self, *args):
        """applyJacobianTransposeMultiVector(Group self, MultiVector input, MultiVector result) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.Group_applyJacobianTransposeMultiVector(self, *args)


    def applyJacobianInverseMultiVector(self, *args):
        """applyJacobianInverseMultiVector(Group self, ParameterList params, MultiVector input, MultiVector result) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.Group_applyJacobianInverseMultiVector(self, *args)


    def isF(self, *args):
        """isF(Group self) -> bool"""
        return _Homotopy.Group_isF(self, *args)


    def isJacobian(self, *args):
        """isJacobian(Group self) -> bool"""
        return _Homotopy.Group_isJacobian(self, *args)


    def isGradient(self, *args):
        """isGradient(Group self) -> bool"""
        return _Homotopy.Group_isGradient(self, *args)


    def isNewton(self, *args):
        """isNewton(Group self) -> bool"""
        return _Homotopy.Group_isNewton(self, *args)


    def getNormF(self, *args):
        """getNormF(Group self) -> double"""
        return _Homotopy.Group_getNormF(self, *args)


    def getX(self, *args):
        """getX(Group self) -> Teuchos::RCP< NOX::Abstract::Vector const >"""
        return _Homotopy.Group_getX(self, *args)


    def getF(self, *args):
        """getF(Group self) -> Teuchos::RCP< NOX::Abstract::Vector const >"""
        return _Homotopy.Group_getF(self, *args)


    def getGradient(self, *args):
        """getGradient(Group self) -> Teuchos::RCP< NOX::Abstract::Vector const >"""
        return _Homotopy.Group_getGradient(self, *args)


    def getNewton(self, *args):
        """getNewton(Group self) -> Teuchos::RCP< NOX::Abstract::Vector const >"""
        return _Homotopy.Group_getNewton(self, *args)


    def getUnderlyingGroup(self, *args):
        """
        getUnderlyingGroup(Group self) -> Teuchos::RCP< LOCA::MultiContinuation::AbstractGroup const >
        getUnderlyingGroup(Group self) -> Teuchos::RCP< LOCA::MultiContinuation::AbstractGroup >
        """
        return _Homotopy.Group_getUnderlyingGroup(self, *args)


    def copy(self, *args):
        """copy(Group self, Group source)"""
        return _Homotopy.Group_copy(self, *args)


    def setParamsMulti(self, *args):
        """setParamsMulti(Group self, std::vector< int,std::allocator< int > > const & paramIDs, NOX::Abstract::MultiVector::DenseMatrix const & vals)"""
        return _Homotopy.Group_setParamsMulti(self, *args)


    def setParams(self, *args):
        """setParams(Group self, LOCA::ParameterVector const & p)"""
        return _Homotopy.Group_setParams(self, *args)


    def setParam(self, *args):
        """
        setParam(Group self, int paramID, double val)
        setParam(Group self, std::string paramID, double val)
        """
        return _Homotopy.Group_setParam(self, *args)


    def getParams(self, *args):
        """getParams(Group self) -> LOCA::ParameterVector const &"""
        return _Homotopy.Group_getParams(self, *args)


    def getParam(self, *args):
        """
        getParam(Group self, int paramID) -> double
        getParam(Group self, std::string paramID) -> double
        """
        return _Homotopy.Group_getParam(self, *args)


    def computeDfDpMulti(self, *args):
        """computeDfDpMulti(Group self, std::vector< int,std::allocator< int > > const & paramIDs, MultiVector dfdp, bool isValidF) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.Group_computeDfDpMulti(self, *args)


    def preProcessContinuationStep(self, *args):
        """preProcessContinuationStep(Group self, LOCA::Abstract::Iterator::StepStatus stepStatus)"""
        return _Homotopy.Group_preProcessContinuationStep(self, *args)


    def postProcessContinuationStep(self, *args):
        """postProcessContinuationStep(Group self, LOCA::Abstract::Iterator::StepStatus stepStatus)"""
        return _Homotopy.Group_postProcessContinuationStep(self, *args)


    def projectToDraw(self, *args):
        """projectToDraw(Group self, Vector x, double * px)"""
        return _Homotopy.Group_projectToDraw(self, *args)


    def projectToDrawDimension(self, *args):
        """projectToDrawDimension(Group self) -> int"""
        return _Homotopy.Group_projectToDrawDimension(self, *args)


    def printSolution(self, *args):
        """
        printSolution(Group self, double const conParam)
        printSolution(Group self, Vector x_, double const conParam)
        """
        return _Homotopy.Group_printSolution(self, *args)

Group_swigregister = _Homotopy.Group_swigregister
Group_swigregister(Group)

class AbstractGroup(MultiContinuation.AbstractGroup):
    """Proxy of C++ LOCA::Homotopy::AbstractGroup class."""

    __swig_setmethods__ = {}
    for _s in [MultiContinuation.AbstractGroup]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AbstractGroup, name, value)
    __swig_getmethods__ = {}
    for _s in [MultiContinuation.AbstractGroup]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, AbstractGroup, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _Homotopy.delete_AbstractGroup

    def augmentJacobianForHomotopy(self, *args):
        """augmentJacobianForHomotopy(AbstractGroup self, double a, double b) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.AbstractGroup_augmentJacobianForHomotopy(self, *args)

AbstractGroup_swigregister = _Homotopy.AbstractGroup_swigregister
AbstractGroup_swigregister(AbstractGroup)

class DeflatedGroup(Extended.MultiAbstractGroup, MultiContinuation.AbstractGroup, BorderedSystem.AbstractGroup):
    """Proxy of C++ LOCA::Homotopy::DeflatedGroup class."""

    __swig_setmethods__ = {}
    for _s in [Extended.MultiAbstractGroup, MultiContinuation.AbstractGroup, BorderedSystem.AbstractGroup]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DeflatedGroup, name, value)
    __swig_getmethods__ = {}
    for _s in [Extended.MultiAbstractGroup, MultiContinuation.AbstractGroup, BorderedSystem.AbstractGroup]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DeflatedGroup, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(LOCA::Homotopy::DeflatedGroup self, Teuchos::RCP< LOCA::GlobalData > const & global_data, Teuchos::RCP< Teuchos::ParameterList > const & topParams, Teuchos::RCP< Teuchos::ParameterList > const & hParams, Teuchos::RCP< LOCA::Homotopy::AbstractGroup > const & grp, Teuchos::RCP< NOX::Abstract::Vector const > const & start_vec, std::vector< Teuchos::RCP< NOX::Abstract::Vector const >,std::allocator< Teuchos::RCP< NOX::Abstract::Vector const > > > const & prev_solns, double const identity_sign=1.0) -> DeflatedGroup
        __init__(LOCA::Homotopy::DeflatedGroup self, DeflatedGroup source, NOX::CopyType type) -> DeflatedGroup
        """
        this = _Homotopy.new_DeflatedGroup(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Homotopy.delete_DeflatedGroup

    def getHomotopyParam(self, *args):
        """getHomotopyParam(DeflatedGroup self) -> double"""
        return _Homotopy.DeflatedGroup_getHomotopyParam(self, *args)


    def clone(self, *args):
        """clone(DeflatedGroup self, NOX::CopyType type) -> Teuchos::RCP< NOX::Abstract::Group >"""
        return _Homotopy.DeflatedGroup_clone(self, *args)


    def setX(self, *args):
        """setX(DeflatedGroup self, Vector y)"""
        return _Homotopy.DeflatedGroup_setX(self, *args)


    def computeX(self, *args):
        """computeX(DeflatedGroup self, Group g, Vector d, double step)"""
        return _Homotopy.DeflatedGroup_computeX(self, *args)


    def computeF(self, *args):
        """computeF(DeflatedGroup self) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.DeflatedGroup_computeF(self, *args)


    def computeJacobian(self, *args):
        """computeJacobian(DeflatedGroup self) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.DeflatedGroup_computeJacobian(self, *args)


    def computeGradient(self, *args):
        """computeGradient(DeflatedGroup self) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.DeflatedGroup_computeGradient(self, *args)


    def computeNewton(self, *args):
        """computeNewton(DeflatedGroup self, ParameterList params) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.DeflatedGroup_computeNewton(self, *args)


    def applyJacobian(self, *args):
        """applyJacobian(DeflatedGroup self, Vector input, Vector result) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.DeflatedGroup_applyJacobian(self, *args)


    def applyJacobianTranspose(self, *args):
        """applyJacobianTranspose(DeflatedGroup self, Vector input, Vector result) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.DeflatedGroup_applyJacobianTranspose(self, *args)


    def applyJacobianInverse(self, *args):
        """applyJacobianInverse(DeflatedGroup self, ParameterList params, Vector input, Vector result) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.DeflatedGroup_applyJacobianInverse(self, *args)


    def applyJacobianMultiVector(self, *args):
        """applyJacobianMultiVector(DeflatedGroup self, MultiVector input, MultiVector result) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.DeflatedGroup_applyJacobianMultiVector(self, *args)


    def applyJacobianTransposeMultiVector(self, *args):
        """applyJacobianTransposeMultiVector(DeflatedGroup self, MultiVector input, MultiVector result) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.DeflatedGroup_applyJacobianTransposeMultiVector(self, *args)


    def applyJacobianInverseMultiVector(self, *args):
        """applyJacobianInverseMultiVector(DeflatedGroup self, ParameterList params, MultiVector input, MultiVector result) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.DeflatedGroup_applyJacobianInverseMultiVector(self, *args)


    def isF(self, *args):
        """isF(DeflatedGroup self) -> bool"""
        return _Homotopy.DeflatedGroup_isF(self, *args)


    def isJacobian(self, *args):
        """isJacobian(DeflatedGroup self) -> bool"""
        return _Homotopy.DeflatedGroup_isJacobian(self, *args)


    def isGradient(self, *args):
        """isGradient(DeflatedGroup self) -> bool"""
        return _Homotopy.DeflatedGroup_isGradient(self, *args)


    def isNewton(self, *args):
        """isNewton(DeflatedGroup self) -> bool"""
        return _Homotopy.DeflatedGroup_isNewton(self, *args)


    def getNormF(self, *args):
        """getNormF(DeflatedGroup self) -> double"""
        return _Homotopy.DeflatedGroup_getNormF(self, *args)


    def getX(self, *args):
        """getX(DeflatedGroup self) -> Teuchos::RCP< NOX::Abstract::Vector const >"""
        return _Homotopy.DeflatedGroup_getX(self, *args)


    def getF(self, *args):
        """getF(DeflatedGroup self) -> Teuchos::RCP< NOX::Abstract::Vector const >"""
        return _Homotopy.DeflatedGroup_getF(self, *args)


    def getGradient(self, *args):
        """getGradient(DeflatedGroup self) -> Teuchos::RCP< NOX::Abstract::Vector const >"""
        return _Homotopy.DeflatedGroup_getGradient(self, *args)


    def getNewton(self, *args):
        """getNewton(DeflatedGroup self) -> Teuchos::RCP< NOX::Abstract::Vector const >"""
        return _Homotopy.DeflatedGroup_getNewton(self, *args)


    def getNormNewtonSolveResidual(self, *args):
        """getNormNewtonSolveResidual(DeflatedGroup self) -> double"""
        return _Homotopy.DeflatedGroup_getNormNewtonSolveResidual(self, *args)


    def getUnderlyingGroup(self, *args):
        """
        getUnderlyingGroup(DeflatedGroup self) -> Teuchos::RCP< LOCA::MultiContinuation::AbstractGroup const >
        getUnderlyingGroup(DeflatedGroup self) -> Teuchos::RCP< LOCA::MultiContinuation::AbstractGroup >
        """
        return _Homotopy.DeflatedGroup_getUnderlyingGroup(self, *args)


    def copy(self, *args):
        """copy(DeflatedGroup self, Group source)"""
        return _Homotopy.DeflatedGroup_copy(self, *args)


    def setParamsMulti(self, *args):
        """setParamsMulti(DeflatedGroup self, std::vector< int,std::allocator< int > > const & paramIDs, NOX::Abstract::MultiVector::DenseMatrix const & vals)"""
        return _Homotopy.DeflatedGroup_setParamsMulti(self, *args)


    def setParams(self, *args):
        """setParams(DeflatedGroup self, LOCA::ParameterVector const & p)"""
        return _Homotopy.DeflatedGroup_setParams(self, *args)


    def setParam(self, *args):
        """
        setParam(DeflatedGroup self, int paramID, double val)
        setParam(DeflatedGroup self, std::string paramID, double val)
        """
        return _Homotopy.DeflatedGroup_setParam(self, *args)


    def getParams(self, *args):
        """getParams(DeflatedGroup self) -> LOCA::ParameterVector const &"""
        return _Homotopy.DeflatedGroup_getParams(self, *args)


    def getParam(self, *args):
        """
        getParam(DeflatedGroup self, int paramID) -> double
        getParam(DeflatedGroup self, std::string paramID) -> double
        """
        return _Homotopy.DeflatedGroup_getParam(self, *args)


    def computeDfDpMulti(self, *args):
        """computeDfDpMulti(DeflatedGroup self, std::vector< int,std::allocator< int > > const & paramIDs, MultiVector dfdp, bool isValidF) -> NOX::Abstract::Group::ReturnType"""
        return _Homotopy.DeflatedGroup_computeDfDpMulti(self, *args)


    def preProcessContinuationStep(self, *args):
        """preProcessContinuationStep(DeflatedGroup self, LOCA::Abstract::Iterator::StepStatus stepStatus)"""
        return _Homotopy.DeflatedGroup_preProcessContinuationStep(self, *args)


    def postProcessContinuationStep(self, *args):
        """postProcessContinuationStep(DeflatedGroup self, LOCA::Abstract::Iterator::StepStatus stepStatus)"""
        return _Homotopy.DeflatedGroup_postProcessContinuationStep(self, *args)


    def projectToDraw(self, *args):
        """projectToDraw(DeflatedGroup self, Vector x, double * px)"""
        return _Homotopy.DeflatedGroup_projectToDraw(self, *args)


    def projectToDrawDimension(self, *args):
        """projectToDrawDimension(DeflatedGroup self) -> int"""
        return _Homotopy.DeflatedGroup_projectToDrawDimension(self, *args)


    def computeScaledDotProduct(self, *args):
        """computeScaledDotProduct(DeflatedGroup self, Vector a, Vector b) -> double"""
        return _Homotopy.DeflatedGroup_computeScaledDotProduct(self, *args)


    def printSolution(self, *args):
        """
        printSolution(DeflatedGroup self, double const conParam)
        printSolution(DeflatedGroup self, Vector x, double const conParam)
        """
        return _Homotopy.DeflatedGroup_printSolution(self, *args)


    def scaleVector(self, *args):
        """scaleVector(DeflatedGroup self, Vector x)"""
        return _Homotopy.DeflatedGroup_scaleVector(self, *args)


    def getBorderedWidth(self, *args):
        """getBorderedWidth(DeflatedGroup self) -> int"""
        return _Homotopy.DeflatedGroup_getBorderedWidth(self, *args)


    def getUnborderedGroup(self, *args):
        """getUnborderedGroup(DeflatedGroup self) -> Teuchos::RCP< NOX::Abstract::Group const >"""
        return _Homotopy.DeflatedGroup_getUnborderedGroup(self, *args)


    def isCombinedAZero(self, *args):
        """isCombinedAZero(DeflatedGroup self) -> bool"""
        return _Homotopy.DeflatedGroup_isCombinedAZero(self, *args)


    def isCombinedBZero(self, *args):
        """isCombinedBZero(DeflatedGroup self) -> bool"""
        return _Homotopy.DeflatedGroup_isCombinedBZero(self, *args)


    def isCombinedCZero(self, *args):
        """isCombinedCZero(DeflatedGroup self) -> bool"""
        return _Homotopy.DeflatedGroup_isCombinedCZero(self, *args)


    def extractSolutionComponent(self, *args):
        """extractSolutionComponent(DeflatedGroup self, MultiVector v, MultiVector v_x)"""
        return _Homotopy.DeflatedGroup_extractSolutionComponent(self, *args)


    def extractParameterComponent(self, *args):
        """extractParameterComponent(DeflatedGroup self, bool use_transpose, MultiVector v, NOX::Abstract::MultiVector::DenseMatrix & v_p)"""
        return _Homotopy.DeflatedGroup_extractParameterComponent(self, *args)


    def loadNestedComponents(self, *args):
        """loadNestedComponents(DeflatedGroup self, MultiVector v_x, NOX::Abstract::MultiVector::DenseMatrix const & v_p, MultiVector v)"""
        return _Homotopy.DeflatedGroup_loadNestedComponents(self, *args)


    def fillA(self, *args):
        """fillA(DeflatedGroup self, MultiVector A)"""
        return _Homotopy.DeflatedGroup_fillA(self, *args)


    def fillB(self, *args):
        """fillB(DeflatedGroup self, MultiVector B)"""
        return _Homotopy.DeflatedGroup_fillB(self, *args)


    def fillC(self, *args):
        """fillC(DeflatedGroup self, NOX::Abstract::MultiVector::DenseMatrix & C)"""
        return _Homotopy.DeflatedGroup_fillC(self, *args)

DeflatedGroup_swigregister = _Homotopy.DeflatedGroup_swigregister
DeflatedGroup_swigregister(DeflatedGroup)

# This file is compatible with both classic and new-style classes.


