# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.8
#
# 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
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('_core', [dirname(__file__)])
        except ImportError:
            from . import _core
            return _core
        if fp is not None:
            try:
                _mod = imp.load_module('_core', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _core = swig_import_helper()
    del swig_import_helper
else:
    from . import _core
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):
        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_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

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



_core.SHARED_PTR_DISOWN_swigconstant(_core)
SHARED_PTR_DISOWN = _core.SHARED_PTR_DISOWN
class SwigPyIterator(_object):
    """Proxy of C++ swig::SwigPyIterator class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _core.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        """
        value(SwigPyIterator self) -> PyObject *

        Parameters
        ----------
        self: swig::SwigPyIterator const *

        """
        return _core.SwigPyIterator_value(self)


    def incr(self, n=1):
        """
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator

        Parameters
        ----------
        n: size_t

        incr(SwigPyIterator self) -> SwigPyIterator

        Parameters
        ----------
        self: swig::SwigPyIterator *

        """
        return _core.SwigPyIterator_incr(self, n)


    def decr(self, n=1):
        """
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator

        Parameters
        ----------
        n: size_t

        decr(SwigPyIterator self) -> SwigPyIterator

        Parameters
        ----------
        self: swig::SwigPyIterator *

        """
        return _core.SwigPyIterator_decr(self, n)


    def distance(self, x):
        """
        distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _core.SwigPyIterator_distance(self, x)


    def equal(self, x):
        """
        equal(SwigPyIterator self, SwigPyIterator x) -> bool

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _core.SwigPyIterator_equal(self, x)


    def copy(self):
        """
        copy(SwigPyIterator self) -> SwigPyIterator

        Parameters
        ----------
        self: swig::SwigPyIterator const *

        """
        return _core.SwigPyIterator_copy(self)


    def __next__(self):
        """
        next(SwigPyIterator self) -> PyObject *

        Parameters
        ----------
        self: swig::SwigPyIterator *

        """
        return _core.SwigPyIterator_next(self)


    def __next__(self):
        """
        __next__(SwigPyIterator self) -> PyObject *

        Parameters
        ----------
        self: swig::SwigPyIterator *

        """
        return _core.SwigPyIterator___next__(self)


    def previous(self):
        """
        previous(SwigPyIterator self) -> PyObject *

        Parameters
        ----------
        self: swig::SwigPyIterator *

        """
        return _core.SwigPyIterator_previous(self)


    def advance(self, n):
        """
        advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _core.SwigPyIterator_advance(self, n)


    def __eq__(self, x):
        """
        __eq__(SwigPyIterator self, SwigPyIterator x) -> bool

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _core.SwigPyIterator___eq__(self, x)


    def __ne__(self, x):
        """
        __ne__(SwigPyIterator self, SwigPyIterator x) -> bool

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _core.SwigPyIterator___ne__(self, x)


    def __iadd__(self, n):
        """
        __iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _core.SwigPyIterator___iadd__(self, n)


    def __isub__(self, n):
        """
        __isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _core.SwigPyIterator___isub__(self, n)


    def __add__(self, n):
        """
        __add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _core.SwigPyIterator___add__(self, n)


    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _core.SwigPyIterator___sub__(self, *args)

    def __iter__(self):
        return self
SwigPyIterator_swigregister = _core.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class MatrixXdVec(_object):
    """Proxy of C++ std::vector<(MatrixXd)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatrixXdVec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MatrixXdVec, name)
    __repr__ = _swig_repr

    def iterator(self):
        """
        iterator(MatrixXdVec self) -> SwigPyIterator

        Parameters
        ----------
        self: std::vector< MatrixXd > *

        """
        return _core.MatrixXdVec_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __bool__(self):
        """
        __nonzero__(MatrixXdVec self) -> bool

        Parameters
        ----------
        self: std::vector< MatrixXd > const *

        """
        return _core.MatrixXdVec___nonzero__(self)


    def __bool__(self):
        """
        __bool__(MatrixXdVec self) -> bool

        Parameters
        ----------
        self: std::vector< MatrixXd > const *

        """
        return _core.MatrixXdVec___bool__(self)


    def __len__(self):
        """
        __len__(MatrixXdVec self) -> std::vector< MatrixXd >::size_type

        Parameters
        ----------
        self: std::vector< MatrixXd > const *

        """
        return _core.MatrixXdVec___len__(self)


    def __getslice__(self, i, j):
        """
        __getslice__(MatrixXdVec self, std::vector< MatrixXd >::difference_type i, std::vector< MatrixXd >::difference_type j) -> MatrixXdVec

        Parameters
        ----------
        i: std::vector< MatrixXd >::difference_type
        j: std::vector< MatrixXd >::difference_type

        """
        return _core.MatrixXdVec___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(MatrixXdVec self, std::vector< MatrixXd >::difference_type i, std::vector< MatrixXd >::difference_type j)

        Parameters
        ----------
        i: std::vector< MatrixXd >::difference_type
        j: std::vector< MatrixXd >::difference_type

        __setslice__(MatrixXdVec self, std::vector< MatrixXd >::difference_type i, std::vector< MatrixXd >::difference_type j, MatrixXdVec v)

        Parameters
        ----------
        i: std::vector< MatrixXd >::difference_type
        j: std::vector< MatrixXd >::difference_type
        v: std::vector< MatrixXd,std::allocator< MatrixXd > > const &

        """
        return _core.MatrixXdVec___setslice__(self, *args)


    def __delslice__(self, i, j):
        """
        __delslice__(MatrixXdVec self, std::vector< MatrixXd >::difference_type i, std::vector< MatrixXd >::difference_type j)

        Parameters
        ----------
        i: std::vector< MatrixXd >::difference_type
        j: std::vector< MatrixXd >::difference_type

        """
        return _core.MatrixXdVec___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(MatrixXdVec self, std::vector< MatrixXd >::difference_type i)

        Parameters
        ----------
        i: std::vector< MatrixXd >::difference_type

        __delitem__(MatrixXdVec self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _core.MatrixXdVec___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(MatrixXdVec self, PySliceObject * slice) -> MatrixXdVec

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(MatrixXdVec self, std::vector< MatrixXd >::difference_type i) -> std::vector< MatrixXd >::value_type const &

        Parameters
        ----------
        i: std::vector< MatrixXd >::difference_type

        """
        return _core.MatrixXdVec___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(MatrixXdVec self, PySliceObject * slice, MatrixXdVec v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< MatrixXd,std::allocator< MatrixXd > > const &

        __setitem__(MatrixXdVec self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(MatrixXdVec self, std::vector< MatrixXd >::difference_type i, std::vector< MatrixXd >::value_type const & x)

        Parameters
        ----------
        i: std::vector< MatrixXd >::difference_type
        x: std::vector< MatrixXd >::value_type const &

        """
        return _core.MatrixXdVec___setitem__(self, *args)


    def pop(self):
        """
        pop(MatrixXdVec self) -> std::vector< MatrixXd >::value_type

        Parameters
        ----------
        self: std::vector< MatrixXd > *

        """
        return _core.MatrixXdVec_pop(self)


    def append(self, x):
        """
        append(MatrixXdVec self, std::vector< MatrixXd >::value_type const & x)

        Parameters
        ----------
        x: std::vector< MatrixXd >::value_type const &

        """
        return _core.MatrixXdVec_append(self, x)


    def empty(self):
        """
        empty(MatrixXdVec self) -> bool

        Parameters
        ----------
        self: std::vector< MatrixXd > const *

        """
        return _core.MatrixXdVec_empty(self)


    def size(self):
        """
        size(MatrixXdVec self) -> std::vector< MatrixXd >::size_type

        Parameters
        ----------
        self: std::vector< MatrixXd > const *

        """
        return _core.MatrixXdVec_size(self)


    def swap(self, v):
        """
        swap(MatrixXdVec self, MatrixXdVec v)

        Parameters
        ----------
        v: std::vector< MatrixXd > &

        """
        return _core.MatrixXdVec_swap(self, v)


    def begin(self):
        """
        begin(MatrixXdVec self) -> std::vector< MatrixXd >::iterator

        Parameters
        ----------
        self: std::vector< MatrixXd > *

        """
        return _core.MatrixXdVec_begin(self)


    def end(self):
        """
        end(MatrixXdVec self) -> std::vector< MatrixXd >::iterator

        Parameters
        ----------
        self: std::vector< MatrixXd > *

        """
        return _core.MatrixXdVec_end(self)


    def rbegin(self):
        """
        rbegin(MatrixXdVec self) -> std::vector< MatrixXd >::reverse_iterator

        Parameters
        ----------
        self: std::vector< MatrixXd > *

        """
        return _core.MatrixXdVec_rbegin(self)


    def rend(self):
        """
        rend(MatrixXdVec self) -> std::vector< MatrixXd >::reverse_iterator

        Parameters
        ----------
        self: std::vector< MatrixXd > *

        """
        return _core.MatrixXdVec_rend(self)


    def clear(self):
        """
        clear(MatrixXdVec self)

        Parameters
        ----------
        self: std::vector< MatrixXd > *

        """
        return _core.MatrixXdVec_clear(self)


    def get_allocator(self):
        """
        get_allocator(MatrixXdVec self) -> std::vector< MatrixXd >::allocator_type

        Parameters
        ----------
        self: std::vector< MatrixXd > const *

        """
        return _core.MatrixXdVec_get_allocator(self)


    def pop_back(self):
        """
        pop_back(MatrixXdVec self)

        Parameters
        ----------
        self: std::vector< MatrixXd > *

        """
        return _core.MatrixXdVec_pop_back(self)


    def erase(self, *args):
        """
        erase(MatrixXdVec self, std::vector< MatrixXd >::iterator pos) -> std::vector< MatrixXd >::iterator

        Parameters
        ----------
        pos: std::vector< MatrixXd >::iterator

        erase(MatrixXdVec self, std::vector< MatrixXd >::iterator first, std::vector< MatrixXd >::iterator last) -> std::vector< MatrixXd >::iterator

        Parameters
        ----------
        first: std::vector< MatrixXd >::iterator
        last: std::vector< MatrixXd >::iterator

        """
        return _core.MatrixXdVec_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(MatrixXd)> self) -> MatrixXdVec
        __init__(std::vector<(MatrixXd)> self, MatrixXdVec arg2) -> MatrixXdVec

        Parameters
        ----------
        arg2: std::vector< MatrixXd > const &

        __init__(std::vector<(MatrixXd)> self, std::vector< MatrixXd >::size_type size) -> MatrixXdVec

        Parameters
        ----------
        size: std::vector< MatrixXd >::size_type

        __init__(std::vector<(MatrixXd)> self, std::vector< MatrixXd >::size_type size, std::vector< MatrixXd >::value_type const & value) -> MatrixXdVec

        Parameters
        ----------
        size: std::vector< MatrixXd >::size_type
        value: std::vector< MatrixXd >::value_type const &

        """
        this = _core.new_MatrixXdVec(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """
        push_back(MatrixXdVec self, std::vector< MatrixXd >::value_type const & x)

        Parameters
        ----------
        x: std::vector< MatrixXd >::value_type const &

        """
        return _core.MatrixXdVec_push_back(self, x)


    def front(self):
        """
        front(MatrixXdVec self) -> std::vector< MatrixXd >::value_type const &

        Parameters
        ----------
        self: std::vector< MatrixXd > const *

        """
        return _core.MatrixXdVec_front(self)


    def back(self):
        """
        back(MatrixXdVec self) -> std::vector< MatrixXd >::value_type const &

        Parameters
        ----------
        self: std::vector< MatrixXd > const *

        """
        return _core.MatrixXdVec_back(self)


    def assign(self, n, x):
        """
        assign(MatrixXdVec self, std::vector< MatrixXd >::size_type n, std::vector< MatrixXd >::value_type const & x)

        Parameters
        ----------
        n: std::vector< MatrixXd >::size_type
        x: std::vector< MatrixXd >::value_type const &

        """
        return _core.MatrixXdVec_assign(self, n, x)


    def resize(self, *args):
        """
        resize(MatrixXdVec self, std::vector< MatrixXd >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< MatrixXd >::size_type

        resize(MatrixXdVec self, std::vector< MatrixXd >::size_type new_size, std::vector< MatrixXd >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< MatrixXd >::size_type
        x: std::vector< MatrixXd >::value_type const &

        """
        return _core.MatrixXdVec_resize(self, *args)


    def insert(self, *args):
        """
        insert(MatrixXdVec self, std::vector< MatrixXd >::iterator pos, std::vector< MatrixXd >::value_type const & x) -> std::vector< MatrixXd >::iterator

        Parameters
        ----------
        pos: std::vector< MatrixXd >::iterator
        x: std::vector< MatrixXd >::value_type const &

        insert(MatrixXdVec self, std::vector< MatrixXd >::iterator pos, std::vector< MatrixXd >::size_type n, std::vector< MatrixXd >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< MatrixXd >::iterator
        n: std::vector< MatrixXd >::size_type
        x: std::vector< MatrixXd >::value_type const &

        """
        return _core.MatrixXdVec_insert(self, *args)


    def reserve(self, n):
        """
        reserve(MatrixXdVec self, std::vector< MatrixXd >::size_type n)

        Parameters
        ----------
        n: std::vector< MatrixXd >::size_type

        """
        return _core.MatrixXdVec_reserve(self, n)


    def capacity(self):
        """
        capacity(MatrixXdVec self) -> std::vector< MatrixXd >::size_type

        Parameters
        ----------
        self: std::vector< MatrixXd > const *

        """
        return _core.MatrixXdVec_capacity(self)

    __swig_destroy__ = _core.delete_MatrixXdVec
    __del__ = lambda self: None
MatrixXdVec_swigregister = _core.MatrixXdVec_swigregister
MatrixXdVec_swigregister(MatrixXdVec)

class StringVec(_object):
    """Proxy of C++ std::vector<(std::string)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringVec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringVec, name)
    __repr__ = _swig_repr

    def iterator(self):
        """
        iterator(StringVec self) -> SwigPyIterator

        Parameters
        ----------
        self: std::vector< std::string > *

        """
        return _core.StringVec_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __bool__(self):
        """
        __nonzero__(StringVec self) -> bool

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _core.StringVec___nonzero__(self)


    def __bool__(self):
        """
        __bool__(StringVec self) -> bool

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _core.StringVec___bool__(self)


    def __len__(self):
        """
        __len__(StringVec self) -> std::vector< std::string >::size_type

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _core.StringVec___len__(self)


    def __getslice__(self, i, j):
        """
        __getslice__(StringVec self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> StringVec

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        """
        return _core.StringVec___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(StringVec self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        __setslice__(StringVec self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, StringVec v)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type
        v: std::vector< std::string,std::allocator< std::string > > const &

        """
        return _core.StringVec___setslice__(self, *args)


    def __delslice__(self, i, j):
        """
        __delslice__(StringVec self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        """
        return _core.StringVec___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(StringVec self, std::vector< std::string >::difference_type i)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type

        __delitem__(StringVec self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _core.StringVec___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(StringVec self, PySliceObject * slice) -> StringVec

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(StringVec self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &

        Parameters
        ----------
        i: std::vector< std::string >::difference_type

        """
        return _core.StringVec___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(StringVec self, PySliceObject * slice, StringVec v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< std::string,std::allocator< std::string > > const &

        __setitem__(StringVec self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(StringVec self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        x: std::vector< std::string >::value_type const &

        """
        return _core.StringVec___setitem__(self, *args)


    def pop(self):
        """
        pop(StringVec self) -> std::vector< std::string >::value_type

        Parameters
        ----------
        self: std::vector< std::string > *

        """
        return _core.StringVec_pop(self)


    def append(self, x):
        """
        append(StringVec self, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        x: std::vector< std::string >::value_type const &

        """
        return _core.StringVec_append(self, x)


    def empty(self):
        """
        empty(StringVec self) -> bool

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _core.StringVec_empty(self)


    def size(self):
        """
        size(StringVec self) -> std::vector< std::string >::size_type

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _core.StringVec_size(self)


    def swap(self, v):
        """
        swap(StringVec self, StringVec v)

        Parameters
        ----------
        v: std::vector< std::string > &

        """
        return _core.StringVec_swap(self, v)


    def begin(self):
        """
        begin(StringVec self) -> std::vector< std::string >::iterator

        Parameters
        ----------
        self: std::vector< std::string > *

        """
        return _core.StringVec_begin(self)


    def end(self):
        """
        end(StringVec self) -> std::vector< std::string >::iterator

        Parameters
        ----------
        self: std::vector< std::string > *

        """
        return _core.StringVec_end(self)


    def rbegin(self):
        """
        rbegin(StringVec self) -> std::vector< std::string >::reverse_iterator

        Parameters
        ----------
        self: std::vector< std::string > *

        """
        return _core.StringVec_rbegin(self)


    def rend(self):
        """
        rend(StringVec self) -> std::vector< std::string >::reverse_iterator

        Parameters
        ----------
        self: std::vector< std::string > *

        """
        return _core.StringVec_rend(self)


    def clear(self):
        """
        clear(StringVec self)

        Parameters
        ----------
        self: std::vector< std::string > *

        """
        return _core.StringVec_clear(self)


    def get_allocator(self):
        """
        get_allocator(StringVec self) -> std::vector< std::string >::allocator_type

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _core.StringVec_get_allocator(self)


    def pop_back(self):
        """
        pop_back(StringVec self)

        Parameters
        ----------
        self: std::vector< std::string > *

        """
        return _core.StringVec_pop_back(self)


    def erase(self, *args):
        """
        erase(StringVec self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator

        Parameters
        ----------
        pos: std::vector< std::string >::iterator

        erase(StringVec self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator

        Parameters
        ----------
        first: std::vector< std::string >::iterator
        last: std::vector< std::string >::iterator

        """
        return _core.StringVec_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::string)> self) -> StringVec
        __init__(std::vector<(std::string)> self, StringVec arg2) -> StringVec

        Parameters
        ----------
        arg2: std::vector< std::string > const &

        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size) -> StringVec

        Parameters
        ----------
        size: std::vector< std::string >::size_type

        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> StringVec

        Parameters
        ----------
        size: std::vector< std::string >::size_type
        value: std::vector< std::string >::value_type const &

        """
        this = _core.new_StringVec(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """
        push_back(StringVec self, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        x: std::vector< std::string >::value_type const &

        """
        return _core.StringVec_push_back(self, x)


    def front(self):
        """
        front(StringVec self) -> std::vector< std::string >::value_type const &

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _core.StringVec_front(self)


    def back(self):
        """
        back(StringVec self) -> std::vector< std::string >::value_type const &

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _core.StringVec_back(self)


    def assign(self, n, x):
        """
        assign(StringVec self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        n: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _core.StringVec_assign(self, n, x)


    def resize(self, *args):
        """
        resize(StringVec self, std::vector< std::string >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< std::string >::size_type

        resize(StringVec self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _core.StringVec_resize(self, *args)


    def insert(self, *args):
        """
        insert(StringVec self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator

        Parameters
        ----------
        pos: std::vector< std::string >::iterator
        x: std::vector< std::string >::value_type const &

        insert(StringVec self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< std::string >::iterator
        n: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _core.StringVec_insert(self, *args)


    def reserve(self, n):
        """
        reserve(StringVec self, std::vector< std::string >::size_type n)

        Parameters
        ----------
        n: std::vector< std::string >::size_type

        """
        return _core.StringVec_reserve(self, n)


    def capacity(self):
        """
        capacity(StringVec self) -> std::vector< std::string >::size_type

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _core.StringVec_capacity(self)

    __swig_destroy__ = _core.delete_StringVec
    __del__ = lambda self: None
StringVec_swigregister = _core.StringVec_swigregister
StringVec_swigregister(StringVec)

class StringMatrixMap(_object):
    """Proxy of C++ std::map<(std::string,MatrixXd)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringMatrixMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringMatrixMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        """
        iterator(StringMatrixMap self) -> SwigPyIterator

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > *

        """
        return _core.StringMatrixMap_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __bool__(self):
        """
        __nonzero__(StringMatrixMap self) -> bool

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > const *

        """
        return _core.StringMatrixMap___nonzero__(self)


    def __bool__(self):
        """
        __bool__(StringMatrixMap self) -> bool

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > const *

        """
        return _core.StringMatrixMap___bool__(self)


    def __len__(self):
        """
        __len__(StringMatrixMap self) -> std::map< std::string,MatrixXd >::size_type

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > const *

        """
        return _core.StringMatrixMap___len__(self)

    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        """
        __getitem__(StringMatrixMap self, std::map< std::string,MatrixXd >::key_type const & key) -> std::map< std::string,MatrixXd >::mapped_type const &

        Parameters
        ----------
        key: std::map< std::string,MatrixXd >::key_type const &

        """
        return _core.StringMatrixMap___getitem__(self, key)


    def __delitem__(self, key):
        """
        __delitem__(StringMatrixMap self, std::map< std::string,MatrixXd >::key_type const & key)

        Parameters
        ----------
        key: std::map< std::string,MatrixXd >::key_type const &

        """
        return _core.StringMatrixMap___delitem__(self, key)


    def has_key(self, key):
        """
        has_key(StringMatrixMap self, std::map< std::string,MatrixXd >::key_type const & key) -> bool

        Parameters
        ----------
        key: std::map< std::string,MatrixXd >::key_type const &

        """
        return _core.StringMatrixMap_has_key(self, key)


    def keys(self):
        """
        keys(StringMatrixMap self) -> PyObject *

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > *

        """
        return _core.StringMatrixMap_keys(self)


    def values(self):
        """
        values(StringMatrixMap self) -> PyObject *

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > *

        """
        return _core.StringMatrixMap_values(self)


    def items(self):
        """
        items(StringMatrixMap self) -> PyObject *

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > *

        """
        return _core.StringMatrixMap_items(self)


    def __contains__(self, key):
        """
        __contains__(StringMatrixMap self, std::map< std::string,MatrixXd >::key_type const & key) -> bool

        Parameters
        ----------
        key: std::map< std::string,MatrixXd >::key_type const &

        """
        return _core.StringMatrixMap___contains__(self, key)


    def key_iterator(self):
        """
        key_iterator(StringMatrixMap self) -> SwigPyIterator

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > *

        """
        return _core.StringMatrixMap_key_iterator(self)


    def value_iterator(self):
        """
        value_iterator(StringMatrixMap self) -> SwigPyIterator

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > *

        """
        return _core.StringMatrixMap_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(StringMatrixMap self, std::map< std::string,MatrixXd >::key_type const & key)

        Parameters
        ----------
        key: std::map< std::string,MatrixXd >::key_type const &

        __setitem__(StringMatrixMap self, std::map< std::string,MatrixXd >::key_type const & key, std::map< std::string,MatrixXd >::mapped_type const & x)

        Parameters
        ----------
        key: std::map< std::string,MatrixXd >::key_type const &
        x: std::map< std::string,MatrixXd >::mapped_type const &

        """
        return _core.StringMatrixMap___setitem__(self, *args)


    def asdict(self):
        """
        asdict(StringMatrixMap self) -> PyObject *

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > *

        """
        return _core.StringMatrixMap_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(std::string,MatrixXd)> self, std::less< std::string > const & arg2) -> StringMatrixMap

        Parameters
        ----------
        arg2: std::less< std::string > const &

        __init__(std::map<(std::string,MatrixXd)> self) -> StringMatrixMap
        __init__(std::map<(std::string,MatrixXd)> self, StringMatrixMap arg2) -> StringMatrixMap

        Parameters
        ----------
        arg2: std::map< std::string,MatrixXd > const &

        """
        this = _core.new_StringMatrixMap(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def empty(self):
        """
        empty(StringMatrixMap self) -> bool

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > const *

        """
        return _core.StringMatrixMap_empty(self)


    def size(self):
        """
        size(StringMatrixMap self) -> std::map< std::string,MatrixXd >::size_type

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > const *

        """
        return _core.StringMatrixMap_size(self)


    def swap(self, v):
        """
        swap(StringMatrixMap self, StringMatrixMap v)

        Parameters
        ----------
        v: std::map< std::string,MatrixXd > &

        """
        return _core.StringMatrixMap_swap(self, v)


    def begin(self):
        """
        begin(StringMatrixMap self) -> std::map< std::string,MatrixXd >::iterator

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > *

        """
        return _core.StringMatrixMap_begin(self)


    def end(self):
        """
        end(StringMatrixMap self) -> std::map< std::string,MatrixXd >::iterator

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > *

        """
        return _core.StringMatrixMap_end(self)


    def rbegin(self):
        """
        rbegin(StringMatrixMap self) -> std::map< std::string,MatrixXd >::reverse_iterator

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > *

        """
        return _core.StringMatrixMap_rbegin(self)


    def rend(self):
        """
        rend(StringMatrixMap self) -> std::map< std::string,MatrixXd >::reverse_iterator

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > *

        """
        return _core.StringMatrixMap_rend(self)


    def clear(self):
        """
        clear(StringMatrixMap self)

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > *

        """
        return _core.StringMatrixMap_clear(self)


    def get_allocator(self):
        """
        get_allocator(StringMatrixMap self) -> std::map< std::string,MatrixXd >::allocator_type

        Parameters
        ----------
        self: std::map< std::string,MatrixXd > const *

        """
        return _core.StringMatrixMap_get_allocator(self)


    def count(self, x):
        """
        count(StringMatrixMap self, std::map< std::string,MatrixXd >::key_type const & x) -> std::map< std::string,MatrixXd >::size_type

        Parameters
        ----------
        x: std::map< std::string,MatrixXd >::key_type const &

        """
        return _core.StringMatrixMap_count(self, x)


    def erase(self, *args):
        """
        erase(StringMatrixMap self, std::map< std::string,MatrixXd >::key_type const & x) -> std::map< std::string,MatrixXd >::size_type

        Parameters
        ----------
        x: std::map< std::string,MatrixXd >::key_type const &

        erase(StringMatrixMap self, std::map< std::string,MatrixXd >::iterator position)

        Parameters
        ----------
        position: std::map< std::string,MatrixXd >::iterator

        erase(StringMatrixMap self, std::map< std::string,MatrixXd >::iterator first, std::map< std::string,MatrixXd >::iterator last)

        Parameters
        ----------
        first: std::map< std::string,MatrixXd >::iterator
        last: std::map< std::string,MatrixXd >::iterator

        """
        return _core.StringMatrixMap_erase(self, *args)


    def find(self, x):
        """
        find(StringMatrixMap self, std::map< std::string,MatrixXd >::key_type const & x) -> std::map< std::string,MatrixXd >::iterator

        Parameters
        ----------
        x: std::map< std::string,MatrixXd >::key_type const &

        """
        return _core.StringMatrixMap_find(self, x)


    def lower_bound(self, x):
        """
        lower_bound(StringMatrixMap self, std::map< std::string,MatrixXd >::key_type const & x) -> std::map< std::string,MatrixXd >::iterator

        Parameters
        ----------
        x: std::map< std::string,MatrixXd >::key_type const &

        """
        return _core.StringMatrixMap_lower_bound(self, x)


    def upper_bound(self, x):
        """
        upper_bound(StringMatrixMap self, std::map< std::string,MatrixXd >::key_type const & x) -> std::map< std::string,MatrixXd >::iterator

        Parameters
        ----------
        x: std::map< std::string,MatrixXd >::key_type const &

        """
        return _core.StringMatrixMap_upper_bound(self, x)

    __swig_destroy__ = _core.delete_StringMatrixMap
    __del__ = lambda self: None
StringMatrixMap_swigregister = _core.StringMatrixMap_swigregister
StringMatrixMap_swigregister(StringMatrixMap)

class VectorXiVec(_object):
    """Proxy of C++ std::vector<(VectorXi)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorXiVec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VectorXiVec, name)
    __repr__ = _swig_repr

    def iterator(self):
        """
        iterator(VectorXiVec self) -> SwigPyIterator

        Parameters
        ----------
        self: std::vector< VectorXi > *

        """
        return _core.VectorXiVec_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __bool__(self):
        """
        __nonzero__(VectorXiVec self) -> bool

        Parameters
        ----------
        self: std::vector< VectorXi > const *

        """
        return _core.VectorXiVec___nonzero__(self)


    def __bool__(self):
        """
        __bool__(VectorXiVec self) -> bool

        Parameters
        ----------
        self: std::vector< VectorXi > const *

        """
        return _core.VectorXiVec___bool__(self)


    def __len__(self):
        """
        __len__(VectorXiVec self) -> std::vector< VectorXi >::size_type

        Parameters
        ----------
        self: std::vector< VectorXi > const *

        """
        return _core.VectorXiVec___len__(self)


    def __getslice__(self, i, j):
        """
        __getslice__(VectorXiVec self, std::vector< VectorXi >::difference_type i, std::vector< VectorXi >::difference_type j) -> VectorXiVec

        Parameters
        ----------
        i: std::vector< VectorXi >::difference_type
        j: std::vector< VectorXi >::difference_type

        """
        return _core.VectorXiVec___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(VectorXiVec self, std::vector< VectorXi >::difference_type i, std::vector< VectorXi >::difference_type j)

        Parameters
        ----------
        i: std::vector< VectorXi >::difference_type
        j: std::vector< VectorXi >::difference_type

        __setslice__(VectorXiVec self, std::vector< VectorXi >::difference_type i, std::vector< VectorXi >::difference_type j, VectorXiVec v)

        Parameters
        ----------
        i: std::vector< VectorXi >::difference_type
        j: std::vector< VectorXi >::difference_type
        v: std::vector< VectorXi,std::allocator< VectorXi > > const &

        """
        return _core.VectorXiVec___setslice__(self, *args)


    def __delslice__(self, i, j):
        """
        __delslice__(VectorXiVec self, std::vector< VectorXi >::difference_type i, std::vector< VectorXi >::difference_type j)

        Parameters
        ----------
        i: std::vector< VectorXi >::difference_type
        j: std::vector< VectorXi >::difference_type

        """
        return _core.VectorXiVec___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(VectorXiVec self, std::vector< VectorXi >::difference_type i)

        Parameters
        ----------
        i: std::vector< VectorXi >::difference_type

        __delitem__(VectorXiVec self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _core.VectorXiVec___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(VectorXiVec self, PySliceObject * slice) -> VectorXiVec

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(VectorXiVec self, std::vector< VectorXi >::difference_type i) -> std::vector< VectorXi >::value_type const &

        Parameters
        ----------
        i: std::vector< VectorXi >::difference_type

        """
        return _core.VectorXiVec___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(VectorXiVec self, PySliceObject * slice, VectorXiVec v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< VectorXi,std::allocator< VectorXi > > const &

        __setitem__(VectorXiVec self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(VectorXiVec self, std::vector< VectorXi >::difference_type i, std::vector< VectorXi >::value_type const & x)

        Parameters
        ----------
        i: std::vector< VectorXi >::difference_type
        x: std::vector< VectorXi >::value_type const &

        """
        return _core.VectorXiVec___setitem__(self, *args)


    def pop(self):
        """
        pop(VectorXiVec self) -> std::vector< VectorXi >::value_type

        Parameters
        ----------
        self: std::vector< VectorXi > *

        """
        return _core.VectorXiVec_pop(self)


    def append(self, x):
        """
        append(VectorXiVec self, std::vector< VectorXi >::value_type const & x)

        Parameters
        ----------
        x: std::vector< VectorXi >::value_type const &

        """
        return _core.VectorXiVec_append(self, x)


    def empty(self):
        """
        empty(VectorXiVec self) -> bool

        Parameters
        ----------
        self: std::vector< VectorXi > const *

        """
        return _core.VectorXiVec_empty(self)


    def size(self):
        """
        size(VectorXiVec self) -> std::vector< VectorXi >::size_type

        Parameters
        ----------
        self: std::vector< VectorXi > const *

        """
        return _core.VectorXiVec_size(self)


    def swap(self, v):
        """
        swap(VectorXiVec self, VectorXiVec v)

        Parameters
        ----------
        v: std::vector< VectorXi > &

        """
        return _core.VectorXiVec_swap(self, v)


    def begin(self):
        """
        begin(VectorXiVec self) -> std::vector< VectorXi >::iterator

        Parameters
        ----------
        self: std::vector< VectorXi > *

        """
        return _core.VectorXiVec_begin(self)


    def end(self):
        """
        end(VectorXiVec self) -> std::vector< VectorXi >::iterator

        Parameters
        ----------
        self: std::vector< VectorXi > *

        """
        return _core.VectorXiVec_end(self)


    def rbegin(self):
        """
        rbegin(VectorXiVec self) -> std::vector< VectorXi >::reverse_iterator

        Parameters
        ----------
        self: std::vector< VectorXi > *

        """
        return _core.VectorXiVec_rbegin(self)


    def rend(self):
        """
        rend(VectorXiVec self) -> std::vector< VectorXi >::reverse_iterator

        Parameters
        ----------
        self: std::vector< VectorXi > *

        """
        return _core.VectorXiVec_rend(self)


    def clear(self):
        """
        clear(VectorXiVec self)

        Parameters
        ----------
        self: std::vector< VectorXi > *

        """
        return _core.VectorXiVec_clear(self)


    def get_allocator(self):
        """
        get_allocator(VectorXiVec self) -> std::vector< VectorXi >::allocator_type

        Parameters
        ----------
        self: std::vector< VectorXi > const *

        """
        return _core.VectorXiVec_get_allocator(self)


    def pop_back(self):
        """
        pop_back(VectorXiVec self)

        Parameters
        ----------
        self: std::vector< VectorXi > *

        """
        return _core.VectorXiVec_pop_back(self)


    def erase(self, *args):
        """
        erase(VectorXiVec self, std::vector< VectorXi >::iterator pos) -> std::vector< VectorXi >::iterator

        Parameters
        ----------
        pos: std::vector< VectorXi >::iterator

        erase(VectorXiVec self, std::vector< VectorXi >::iterator first, std::vector< VectorXi >::iterator last) -> std::vector< VectorXi >::iterator

        Parameters
        ----------
        first: std::vector< VectorXi >::iterator
        last: std::vector< VectorXi >::iterator

        """
        return _core.VectorXiVec_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(VectorXi)> self) -> VectorXiVec
        __init__(std::vector<(VectorXi)> self, VectorXiVec arg2) -> VectorXiVec

        Parameters
        ----------
        arg2: std::vector< VectorXi > const &

        __init__(std::vector<(VectorXi)> self, std::vector< VectorXi >::size_type size) -> VectorXiVec

        Parameters
        ----------
        size: std::vector< VectorXi >::size_type

        __init__(std::vector<(VectorXi)> self, std::vector< VectorXi >::size_type size, std::vector< VectorXi >::value_type const & value) -> VectorXiVec

        Parameters
        ----------
        size: std::vector< VectorXi >::size_type
        value: std::vector< VectorXi >::value_type const &

        """
        this = _core.new_VectorXiVec(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """
        push_back(VectorXiVec self, std::vector< VectorXi >::value_type const & x)

        Parameters
        ----------
        x: std::vector< VectorXi >::value_type const &

        """
        return _core.VectorXiVec_push_back(self, x)


    def front(self):
        """
        front(VectorXiVec self) -> std::vector< VectorXi >::value_type const &

        Parameters
        ----------
        self: std::vector< VectorXi > const *

        """
        return _core.VectorXiVec_front(self)


    def back(self):
        """
        back(VectorXiVec self) -> std::vector< VectorXi >::value_type const &

        Parameters
        ----------
        self: std::vector< VectorXi > const *

        """
        return _core.VectorXiVec_back(self)


    def assign(self, n, x):
        """
        assign(VectorXiVec self, std::vector< VectorXi >::size_type n, std::vector< VectorXi >::value_type const & x)

        Parameters
        ----------
        n: std::vector< VectorXi >::size_type
        x: std::vector< VectorXi >::value_type const &

        """
        return _core.VectorXiVec_assign(self, n, x)


    def resize(self, *args):
        """
        resize(VectorXiVec self, std::vector< VectorXi >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< VectorXi >::size_type

        resize(VectorXiVec self, std::vector< VectorXi >::size_type new_size, std::vector< VectorXi >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< VectorXi >::size_type
        x: std::vector< VectorXi >::value_type const &

        """
        return _core.VectorXiVec_resize(self, *args)


    def insert(self, *args):
        """
        insert(VectorXiVec self, std::vector< VectorXi >::iterator pos, std::vector< VectorXi >::value_type const & x) -> std::vector< VectorXi >::iterator

        Parameters
        ----------
        pos: std::vector< VectorXi >::iterator
        x: std::vector< VectorXi >::value_type const &

        insert(VectorXiVec self, std::vector< VectorXi >::iterator pos, std::vector< VectorXi >::size_type n, std::vector< VectorXi >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< VectorXi >::iterator
        n: std::vector< VectorXi >::size_type
        x: std::vector< VectorXi >::value_type const &

        """
        return _core.VectorXiVec_insert(self, *args)


    def reserve(self, n):
        """
        reserve(VectorXiVec self, std::vector< VectorXi >::size_type n)

        Parameters
        ----------
        n: std::vector< VectorXi >::size_type

        """
        return _core.VectorXiVec_reserve(self, n)


    def capacity(self):
        """
        capacity(VectorXiVec self) -> std::vector< VectorXi >::size_type

        Parameters
        ----------
        self: std::vector< VectorXi > const *

        """
        return _core.VectorXiVec_capacity(self)

    __swig_destroy__ = _core.delete_VectorXiVec
    __del__ = lambda self: None
VectorXiVec_swigregister = _core.VectorXiVec_swigregister
VectorXiVec_swigregister(VectorXiVec)


_core.PI_swigconstant(_core)
PI = _core.PI

def isnan(val):
    """
    isnan(limix::mfloat_t val) -> bool

    Parameters
    ----------
    val: limix::mfloat_t

    """
    return _core.isnan(val)

def isinf(value):
    """
    isinf(limix::mfloat_t value) -> bool

    Parameters
    ----------
    value: limix::mfloat_t

    """
    return _core.isinf(value)

def exp(x):
    """
    exp(limix::mfloat_t x) -> limix::mfloat_t

    Parameters
    ----------
    x: limix::mfloat_t

    """
    return _core.exp(x)

def sqrt(x):
    """
    sqrt(limix::mfloat_t x) -> limix::mfloat_t

    Parameters
    ----------
    x: limix::mfloat_t

    """
    return _core.sqrt(x)

def log(x):
    """
    log(limix::mfloat_t x) -> limix::mfloat_t

    Parameters
    ----------
    x: limix::mfloat_t

    """
    return _core.log(x)

def inverse(x):
    """
    inverse(limix::mfloat_t x) -> limix::mfloat_t

    Parameters
    ----------
    x: limix::mfloat_t

    """
    return _core.inverse(x)
class CLimixException(_object):
    """Proxy of C++ limix::CLimixException class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CLimixException, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CLimixException, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(limix::CLimixException self, std::string str) -> CLimixException

        Parameters
        ----------
        str: std::string

        __init__(limix::CLimixException self) -> CLimixException
        """
        this = _core.new_CLimixException(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CLimixException
    __del__ = lambda self: None

    def what(self):
        """
        what(CLimixException self) -> std::string

        Parameters
        ----------
        self: limix::CLimixException *

        """
        return _core.CLimixException_what(self)

CLimixException_swigregister = _core.CLimixException_swigregister
CLimixException_swigregister(CLimixException)
cvar = _core.cvar
L2pi = cvar.L2pi

class CParamObject(_object):
    """Proxy of C++ limix::CParamObject class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CParamObject, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CParamObject, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(limix::CParamObject self) -> CParamObject"""
        this = _core.new_CParamObject()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def addSyncParent(self, l):
        """
        addSyncParent(CParamObject self, limix::Pbool l)

        Parameters
        ----------
        l: limix::Pbool

        """
        return _core.CParamObject_addSyncParent(self, l)


    def addSyncChild(self, l):
        """
        addSyncChild(CParamObject self, limix::Pbool l)

        Parameters
        ----------
        l: limix::Pbool

        """
        return _core.CParamObject_addSyncChild(self, l)


    def delSyncParent(self, l):
        """
        delSyncParent(CParamObject self, limix::Pbool l)

        Parameters
        ----------
        l: limix::Pbool

        """
        return _core.CParamObject_delSyncParent(self, l)


    def delSyncChild(self, l):
        """
        delSyncChild(CParamObject self, limix::Pbool l)

        Parameters
        ----------
        l: limix::Pbool

        """
        return _core.CParamObject_delSyncChild(self, l)


    def propagateSync(self, state=False):
        """
        propagateSync(CParamObject self, bool state=False)

        Parameters
        ----------
        state: bool

        propagateSync(CParamObject self)

        Parameters
        ----------
        self: limix::CParamObject *

        """
        return _core.CParamObject_propagateSync(self, state)


    def isInSync(self):
        """
        isInSync(CParamObject self) -> bool

        Parameters
        ----------
        self: limix::CParamObject *

        """
        return _core.CParamObject_isInSync(self)


    def setSync(self, state=True):
        """
        setSync(CParamObject self, bool state=True)

        Parameters
        ----------
        state: bool

        setSync(CParamObject self)

        Parameters
        ----------
        self: limix::CParamObject *

        """
        return _core.CParamObject_setSync(self, state)

    __swig_destroy__ = _core.delete_CParamObject
    __del__ = lambda self: None
CParamObject_swigregister = _core.CParamObject_swigregister
CParamObject_swigregister(CParamObject)

class CNamedCache(CParamObject):
    """Proxy of C++ limix::CNamedCache class."""

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

    def __init__(self):
        """__init__(limix::CNamedCache self) -> CNamedCache"""
        this = _core.new_CNamedCache()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CNamedCache
    __del__ = lambda self: None

    def set(self, name, m):
        """
        set(CNamedCache self, std::string name, PCVoid m)

        Parameters
        ----------
        name: std::string
        m: PCVoid

        """
        return _core.CNamedCache_set(self, name, m)


    def get(self, name):
        """
        get(CNamedCache self, std::string const & name) -> PCVoid

        Parameters
        ----------
        name: std::string const &

        """
        return _core.CNamedCache_get(self, name)

CNamedCache_swigregister = _core.CNamedCache_swigregister
CNamedCache_swigregister(CNamedCache)

class ACovarianceFunction(CParamObject):
    """Proxy of C++ limix::ACovarianceFunction class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _core.delete_ACovarianceFunction
    __del__ = lambda self: None

    def getName(self):
        """
        getName(ACovarianceFunction self) -> std::string

        Parameters
        ----------
        self: limix::ACovarianceFunction const *

        """
        return _core.ACovarianceFunction_getName(self)


    def setParams(self, params):
        """
        setParams(ACovarianceFunction self, limix::CovarParams const & params)

        Parameters
        ----------
        params: limix::CovarParams const &

        """
        return _core.ACovarianceFunction_setParams(self, params)


    def getParams(self):
        """
        getParams(ACovarianceFunction self)

        Parameters
        ----------
        self: limix::ACovarianceFunction const *

        """
        return _core.ACovarianceFunction_getParams(self)


    def getParamBounds0(self):
        """
        getParamBounds0(ACovarianceFunction self)

        Parameters
        ----------
        self: limix::ACovarianceFunction const *

        """
        return _core.ACovarianceFunction_getParamBounds0(self)


    def getParamBounds(self):
        """
        getParamBounds(ACovarianceFunction self)

        Parameters
        ----------
        self: limix::ACovarianceFunction const *

        """
        return _core.ACovarianceFunction_getParamBounds(self)


    def setParamBounds(self, lower, upper):
        """
        setParamBounds(ACovarianceFunction self, limix::CovarParams const & lower, limix::CovarParams const & upper)

        Parameters
        ----------
        lower: limix::CovarParams const &
        upper: limix::CovarParams const &

        """
        return _core.ACovarianceFunction_setParamBounds(self, lower, upper)


    def getParamMask(self):
        """
        getParamMask(ACovarianceFunction self)

        Parameters
        ----------
        self: limix::ACovarianceFunction const *

        """
        return _core.ACovarianceFunction_getParamMask(self)


    def setParamMask(self, params):
        """
        setParamMask(ACovarianceFunction self, limix::CovarParams const & params)

        Parameters
        ----------
        params: limix::CovarParams const &

        """
        return _core.ACovarianceFunction_setParamMask(self, params)


    def setX(self, X):
        """
        setX(ACovarianceFunction self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.ACovarianceFunction_setX(self, X)


    def setXcol(self, X, col):
        """
        setXcol(ACovarianceFunction self, limix::CovarInput const & X, limix::muint_t col)

        Parameters
        ----------
        X: limix::CovarInput const &
        col: limix::muint_t

        """
        return _core.ACovarianceFunction_setXcol(self, X, col)


    def getX(self):
        """
        getX(ACovarianceFunction self)

        Parameters
        ----------
        self: limix::ACovarianceFunction const *

        """
        return _core.ACovarianceFunction_getX(self)


    def getDimX(self):
        """
        getDimX(ACovarianceFunction self) -> limix::muint_t

        Parameters
        ----------
        self: limix::ACovarianceFunction const *

        """
        return _core.ACovarianceFunction_getDimX(self)


    def getNumberParams(self):
        """
        getNumberParams(ACovarianceFunction self) -> limix::muint_t

        Parameters
        ----------
        self: limix::ACovarianceFunction const *

        """
        return _core.ACovarianceFunction_getNumberParams(self)


    def getNumberDimensions(self):
        """
        getNumberDimensions(ACovarianceFunction self) -> limix::muint_t

        Parameters
        ----------
        self: limix::ACovarianceFunction const *

        """
        return _core.ACovarianceFunction_getNumberDimensions(self)


    def setNumberDimensions(self, numberDimensions):
        """
        setNumberDimensions(ACovarianceFunction self, limix::muint_t numberDimensions)

        Parameters
        ----------
        numberDimensions: limix::muint_t

        """
        return _core.ACovarianceFunction_setNumberDimensions(self, numberDimensions)


    def Kdim(self):
        """
        Kdim(ACovarianceFunction self) -> limix::muint_t

        Parameters
        ----------
        self: limix::ACovarianceFunction const *

        """
        return _core.ACovarianceFunction_Kdim(self)


    def K(self):
        """
        K(ACovarianceFunction self)

        Parameters
        ----------
        self: limix::ACovarianceFunction const *

        """
        return _core.ACovarianceFunction_K(self)


    def Kdiag(self):
        """
        Kdiag(ACovarianceFunction self)

        Parameters
        ----------
        self: limix::ACovarianceFunction const *

        """
        return _core.ACovarianceFunction_Kdiag(self)


    def Kgrad_X(self, d):
        """
        Kgrad_X(ACovarianceFunction self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.ACovarianceFunction_Kgrad_X(self, d)


    def Kcross(self, Xstar):
        """
        Kcross(ACovarianceFunction self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.ACovarianceFunction_Kcross(self, Xstar)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(ACovarianceFunction self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.ACovarianceFunction_Kcross_diag(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(ACovarianceFunction self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.ACovarianceFunction_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(ACovarianceFunction self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.ACovarianceFunction_Khess_param(self, i, j)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(ACovarianceFunction self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.ACovarianceFunction_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(ACovarianceFunction self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.ACovarianceFunction_Kdiag_grad_X(self, d)


    def check_covariance_Kgrad_theta(covar, relchange=1E-5, threshold=1E-2):
        """
        check_covariance_Kgrad_theta(ACovarianceFunction covar, limix::mfloat_t relchange=1E-5, limix::mfloat_t threshold=1E-2) -> bool

        Parameters
        ----------
        covar: limix::ACovarianceFunction &
        relchange: limix::mfloat_t
        threshold: limix::mfloat_t

        check_covariance_Kgrad_theta(ACovarianceFunction covar, limix::mfloat_t relchange=1E-5) -> bool

        Parameters
        ----------
        covar: limix::ACovarianceFunction &
        relchange: limix::mfloat_t

        check_covariance_Kgrad_theta(ACovarianceFunction covar) -> bool

        Parameters
        ----------
        covar: limix::ACovarianceFunction &

        """
        return _core.ACovarianceFunction_check_covariance_Kgrad_theta(covar, relchange, threshold)

    if _newclass:
        check_covariance_Kgrad_theta = staticmethod(check_covariance_Kgrad_theta)
    __swig_getmethods__["check_covariance_Kgrad_theta"] = lambda x: check_covariance_Kgrad_theta

    def check_covariance_Kgrad_x(covar, relchange=1E-5, threshold=1E-2, check_diag=True):
        """
        check_covariance_Kgrad_x(ACovarianceFunction covar, limix::mfloat_t relchange=1E-5, limix::mfloat_t threshold=1E-2, bool check_diag=True) -> bool

        Parameters
        ----------
        covar: limix::ACovarianceFunction &
        relchange: limix::mfloat_t
        threshold: limix::mfloat_t
        check_diag: bool

        check_covariance_Kgrad_x(ACovarianceFunction covar, limix::mfloat_t relchange=1E-5, limix::mfloat_t threshold=1E-2) -> bool

        Parameters
        ----------
        covar: limix::ACovarianceFunction &
        relchange: limix::mfloat_t
        threshold: limix::mfloat_t

        check_covariance_Kgrad_x(ACovarianceFunction covar, limix::mfloat_t relchange=1E-5) -> bool

        Parameters
        ----------
        covar: limix::ACovarianceFunction &
        relchange: limix::mfloat_t

        check_covariance_Kgrad_x(ACovarianceFunction covar) -> bool

        Parameters
        ----------
        covar: limix::ACovarianceFunction &

        """
        return _core.ACovarianceFunction_check_covariance_Kgrad_x(covar, relchange, threshold, check_diag)

    if _newclass:
        check_covariance_Kgrad_x = staticmethod(check_covariance_Kgrad_x)
    __swig_getmethods__["check_covariance_Kgrad_x"] = lambda x: check_covariance_Kgrad_x

    def Khess_param_num(covar, i, j):
        """
        Khess_param_num(ACovarianceFunction covar, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        covar: limix::ACovarianceFunction &
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.ACovarianceFunction_Khess_param_num(covar, i, j)

    if _newclass:
        Khess_param_num = staticmethod(Khess_param_num)
    __swig_getmethods__["Khess_param_num"] = lambda x: Khess_param_num
ACovarianceFunction_swigregister = _core.ACovarianceFunction_swigregister
ACovarianceFunction_swigregister(ACovarianceFunction)

def ACovarianceFunction_check_covariance_Kgrad_theta(covar, relchange=1E-5, threshold=1E-2):
    """
    check_covariance_Kgrad_theta(ACovarianceFunction covar, limix::mfloat_t relchange=1E-5, limix::mfloat_t threshold=1E-2) -> bool

    Parameters
    ----------
    covar: limix::ACovarianceFunction &
    relchange: limix::mfloat_t
    threshold: limix::mfloat_t

    check_covariance_Kgrad_theta(ACovarianceFunction covar, limix::mfloat_t relchange=1E-5) -> bool

    Parameters
    ----------
    covar: limix::ACovarianceFunction &
    relchange: limix::mfloat_t

    ACovarianceFunction_check_covariance_Kgrad_theta(ACovarianceFunction covar) -> bool

    Parameters
    ----------
    covar: limix::ACovarianceFunction &

    """
    return _core.ACovarianceFunction_check_covariance_Kgrad_theta(covar, relchange, threshold)

def ACovarianceFunction_check_covariance_Kgrad_x(covar, relchange=1E-5, threshold=1E-2, check_diag=True):
    """
    check_covariance_Kgrad_x(ACovarianceFunction covar, limix::mfloat_t relchange=1E-5, limix::mfloat_t threshold=1E-2, bool check_diag=True) -> bool

    Parameters
    ----------
    covar: limix::ACovarianceFunction &
    relchange: limix::mfloat_t
    threshold: limix::mfloat_t
    check_diag: bool

    check_covariance_Kgrad_x(ACovarianceFunction covar, limix::mfloat_t relchange=1E-5, limix::mfloat_t threshold=1E-2) -> bool

    Parameters
    ----------
    covar: limix::ACovarianceFunction &
    relchange: limix::mfloat_t
    threshold: limix::mfloat_t

    check_covariance_Kgrad_x(ACovarianceFunction covar, limix::mfloat_t relchange=1E-5) -> bool

    Parameters
    ----------
    covar: limix::ACovarianceFunction &
    relchange: limix::mfloat_t

    ACovarianceFunction_check_covariance_Kgrad_x(ACovarianceFunction covar) -> bool

    Parameters
    ----------
    covar: limix::ACovarianceFunction &

    """
    return _core.ACovarianceFunction_check_covariance_Kgrad_x(covar, relchange, threshold, check_diag)

def ACovarianceFunction_Khess_param_num(covar, i, j):
    """
    ACovarianceFunction_Khess_param_num(ACovarianceFunction covar, limix::muint_t const i, limix::muint_t const j)

    Parameters
    ----------
    covar: limix::ACovarianceFunction &
    i: limix::muint_t const
    j: limix::muint_t const

    """
    return _core.ACovarianceFunction_Khess_param_num(covar, i, j)

class CCovarianceFunctionCacheOld(CParamObject):
    """Proxy of C++ limix::CCovarianceFunctionCacheOld class."""

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

    def __init__(self, *args):
        """
        __init__(limix::CCovarianceFunctionCacheOld self) -> CCovarianceFunctionCacheOld
        __init__(limix::CCovarianceFunctionCacheOld self, limix::PCovarianceFunction covar) -> CCovarianceFunctionCacheOld

        Parameters
        ----------
        covar: limix::PCovarianceFunction

        """
        this = _core.new_CCovarianceFunctionCacheOld(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CCovarianceFunctionCacheOld
    __del__ = lambda self: None

    def setCovar(self, covar):
        """
        setCovar(CCovarianceFunctionCacheOld self, limix::PCovarianceFunction covar)

        Parameters
        ----------
        covar: limix::PCovarianceFunction

        """
        return _core.CCovarianceFunctionCacheOld_setCovar(self, covar)


    def addSyncChild(self, l):
        """
        addSyncChild(CCovarianceFunctionCacheOld self, limix::Pbool l)

        Parameters
        ----------
        l: limix::Pbool

        """
        return _core.CCovarianceFunctionCacheOld_addSyncChild(self, l)


    def delSyncChild(self, l):
        """
        delSyncChild(CCovarianceFunctionCacheOld self, limix::Pbool l)

        Parameters
        ----------
        l: limix::Pbool

        """
        return _core.CCovarianceFunctionCacheOld_delSyncChild(self, l)


    def getCovar(self):
        """
        getCovar(CCovarianceFunctionCacheOld self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::CCovarianceFunctionCacheOld *

        """
        return _core.CCovarianceFunctionCacheOld_getCovar(self)


    def rgetK(self):
        """
        rgetK(CCovarianceFunctionCacheOld self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CCovarianceFunctionCacheOld *

        """
        return _core.CCovarianceFunctionCacheOld_rgetK(self)


    def rgetUK(self):
        """
        rgetUK(CCovarianceFunctionCacheOld self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CCovarianceFunctionCacheOld *

        """
        return _core.CCovarianceFunctionCacheOld_rgetUK(self)


    def rgetSK(self):
        """
        rgetSK(CCovarianceFunctionCacheOld self) -> VectorXd &

        Parameters
        ----------
        self: limix::CCovarianceFunctionCacheOld *

        """
        return _core.CCovarianceFunctionCacheOld_rgetSK(self)


    def rgetCholK(self):
        """
        rgetCholK(CCovarianceFunctionCacheOld self) -> MatrixXdChol &

        Parameters
        ----------
        self: limix::CCovarianceFunctionCacheOld *

        """
        return _core.CCovarianceFunctionCacheOld_rgetCholK(self)

CCovarianceFunctionCacheOld_swigregister = _core.CCovarianceFunctionCacheOld_swigregister
CCovarianceFunctionCacheOld_swigregister(CCovarianceFunctionCacheOld)

class CCovLinearISO(ACovarianceFunction):
    """Proxy of C++ limix::CCovLinearISO class."""

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

    def __init__(self, numberDimensions=1):
        """
        __init__(limix::CCovLinearISO self, limix::muint_t numberDimensions=1) -> CCovLinearISO

        Parameters
        ----------
        numberDimensions: limix::muint_t

        __init__(limix::CCovLinearISO self) -> CCovLinearISO
        """
        this = _core.new_CCovLinearISO(numberDimensions)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CCovLinearISO
    __del__ = lambda self: None

    def Kcross(self, Xstar):
        """
        Kcross(CCovLinearISO self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CCovLinearISO_Kcross(self, Xstar)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CCovLinearISO self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CCovLinearISO_Kcross_diag(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(CCovLinearISO self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CCovLinearISO_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(CCovLinearISO self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CCovLinearISO_Khess_param(self, i, j)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(CCovLinearISO self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.CCovLinearISO_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(CCovLinearISO self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CCovLinearISO_Kdiag_grad_X(self, d)


    def getName(self):
        """
        getName(CCovLinearISO self) -> std::string

        Parameters
        ----------
        self: limix::CCovLinearISO const *

        """
        return _core.CCovLinearISO_getName(self)

CCovLinearISO_swigregister = _core.CCovLinearISO_swigregister
CCovLinearISO_swigregister(CCovLinearISO)

class CCovLinearARD(ACovarianceFunction):
    """Proxy of C++ limix::CCovLinearARD class."""

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

    def __init__(self, numberDimensions=1):
        """
        __init__(limix::CCovLinearARD self, limix::muint_t numberDimensions=1) -> CCovLinearARD

        Parameters
        ----------
        numberDimensions: limix::muint_t

        __init__(limix::CCovLinearARD self) -> CCovLinearARD
        """
        this = _core.new_CCovLinearARD(numberDimensions)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CCovLinearARD
    __del__ = lambda self: None

    def setNumberDimensions(self, numberDimensions):
        """
        setNumberDimensions(CCovLinearARD self, limix::muint_t numberDimensions)

        Parameters
        ----------
        numberDimensions: limix::muint_t

        """
        return _core.CCovLinearARD_setNumberDimensions(self, numberDimensions)


    def Kcross(self, Xstar):
        """
        Kcross(CCovLinearARD self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CCovLinearARD_Kcross(self, Xstar)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CCovLinearARD self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CCovLinearARD_Kcross_diag(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(CCovLinearARD self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CCovLinearARD_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(CCovLinearARD self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CCovLinearARD_Khess_param(self, i, j)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(CCovLinearARD self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.CCovLinearARD_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(CCovLinearARD self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CCovLinearARD_Kdiag_grad_X(self, d)


    def getName(self):
        """
        getName(CCovLinearARD self) -> std::string

        Parameters
        ----------
        self: limix::CCovLinearARD const *

        """
        return _core.CCovLinearARD_getName(self)

CCovLinearARD_swigregister = _core.CCovLinearARD_swigregister
CCovLinearARD_swigregister(CCovLinearARD)

class CCovLinearISODelta(ACovarianceFunction):
    """Proxy of C++ limix::CCovLinearISODelta class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _core.delete_CCovLinearISODelta
    __del__ = lambda self: None

    def Kcross(self, Xstar):
        """
        Kcross(CCovLinearISODelta self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CCovLinearISODelta_Kcross(self, Xstar)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CCovLinearISODelta self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CCovLinearISODelta_Kcross_diag(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(CCovLinearISODelta self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CCovLinearISODelta_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(CCovLinearISODelta self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CCovLinearISODelta_Khess_param(self, i, j)


    def getName(self):
        """
        getName(CCovLinearISODelta self) -> std::string

        Parameters
        ----------
        self: limix::CCovLinearISODelta const *

        """
        return _core.CCovLinearISODelta_getName(self)

CCovLinearISODelta_swigregister = _core.CCovLinearISODelta_swigregister
CCovLinearISODelta_swigregister(CCovLinearISODelta)

class CFreeFormCF(ACovarianceFunction):
    """Proxy of C++ limix::CFreeFormCF class."""

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

    def __init__(self, numberGroups):
        """
        __init__(limix::CFreeFormCF self, limix::muint_t numberGroups) -> CFreeFormCF

        Parameters
        ----------
        numberGroups: limix::muint_t

        """
        this = _core.new_CFreeFormCF(numberGroups)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CFreeFormCF
    __del__ = lambda self: None

    def setX(self, X):
        """
        setX(CFreeFormCF self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.CFreeFormCF_setX(self, X)


    def setXcol(self, X, col):
        """
        setXcol(CFreeFormCF self, limix::CovarInput const & X, limix::muint_t col)

        Parameters
        ----------
        X: limix::CovarInput const &
        col: limix::muint_t

        """
        return _core.CFreeFormCF_setXcol(self, X, col)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CFreeFormCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CFreeFormCF_Kcross_diag(self, Xstar)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(CFreeFormCF self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.CFreeFormCF_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(CFreeFormCF self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CFreeFormCF_Kdiag_grad_X(self, d)


    def Kdim(self):
        """
        Kdim(CFreeFormCF self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CFreeFormCF const *

        """
        return _core.CFreeFormCF_Kdim(self)


    def agetScales(self):
        """
        agetScales(CFreeFormCF self)

        Parameters
        ----------
        self: limix::CFreeFormCF *

        """
        return _core.CFreeFormCF_agetScales(self)


    def setParamsCovariance(self, K0):
        """
        setParamsCovariance(CFreeFormCF self, MatrixXd const & K0)

        Parameters
        ----------
        K0: MatrixXd const &

        """
        return _core.CFreeFormCF_setParamsCovariance(self, K0)


    def Kcross(self, Xstar):
        """
        Kcross(CFreeFormCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CFreeFormCF_Kcross(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(CFreeFormCF self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CFreeFormCF_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(CFreeFormCF self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CFreeFormCF_Khess_param(self, i, j)


    def agetParamMask0(self):
        """
        agetParamMask0(CFreeFormCF self)

        Parameters
        ----------
        self: limix::CFreeFormCF const *

        """
        return _core.CFreeFormCF_agetParamMask0(self)


    def getName(self):
        """
        getName(CFreeFormCF self) -> std::string

        Parameters
        ----------
        self: limix::CFreeFormCF const *

        """
        return _core.CFreeFormCF_getName(self)


    def setParamsVarCorr(self, paramsVC):
        """
        setParamsVarCorr(CFreeFormCF self, limix::CovarParams const & paramsVC)

        Parameters
        ----------
        paramsVC: limix::CovarParams const &

        """
        return _core.CFreeFormCF_setParamsVarCorr(self, paramsVC)


    def agetL0(self):
        """
        agetL0(CFreeFormCF self)

        Parameters
        ----------
        self: limix::CFreeFormCF const *

        """
        return _core.CFreeFormCF_agetL0(self)


    def agetL0grad_param(self, i):
        """
        agetL0grad_param(CFreeFormCF self, limix::muint_t i)

        Parameters
        ----------
        i: limix::muint_t

        """
        return _core.CFreeFormCF_agetL0grad_param(self, i)


    def getIparamDiag(self):
        """
        getIparamDiag(CFreeFormCF self)

        Parameters
        ----------
        self: limix::CFreeFormCF const *

        """
        return _core.CFreeFormCF_getIparamDiag(self)

CFreeFormCF_swigregister = _core.CFreeFormCF_swigregister
CFreeFormCF_swigregister(CFreeFormCF)

class CRankOneCF(ACovarianceFunction):
    """Proxy of C++ limix::CRankOneCF class."""

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

    def __init__(self, numberGroups):
        """
        __init__(limix::CRankOneCF self, limix::muint_t numberGroups) -> CRankOneCF

        Parameters
        ----------
        numberGroups: limix::muint_t

        """
        this = _core.new_CRankOneCF(numberGroups)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CRankOneCF
    __del__ = lambda self: None

    def setX(self, X):
        """
        setX(CRankOneCF self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.CRankOneCF_setX(self, X)


    def setXcol(self, X, col):
        """
        setXcol(CRankOneCF self, limix::CovarInput const & X, limix::muint_t col)

        Parameters
        ----------
        X: limix::CovarInput const &
        col: limix::muint_t

        """
        return _core.CRankOneCF_setXcol(self, X, col)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CRankOneCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CRankOneCF_Kcross_diag(self, Xstar)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(CRankOneCF self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.CRankOneCF_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(CRankOneCF self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CRankOneCF_Kdiag_grad_X(self, d)


    def Kdim(self):
        """
        Kdim(CRankOneCF self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CRankOneCF const *

        """
        return _core.CRankOneCF_Kdim(self)


    def agetScales(self):
        """
        agetScales(CRankOneCF self)

        Parameters
        ----------
        self: limix::CRankOneCF *

        """
        return _core.CRankOneCF_agetScales(self)


    def setParamsCovariance(self, K0):
        """
        setParamsCovariance(CRankOneCF self, MatrixXd const & K0)

        Parameters
        ----------
        K0: MatrixXd const &

        """
        return _core.CRankOneCF_setParamsCovariance(self, K0)


    def Kcross(self, Xstar):
        """
        Kcross(CRankOneCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CRankOneCF_Kcross(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(CRankOneCF self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CRankOneCF_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(CRankOneCF self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CRankOneCF_Khess_param(self, i, j)


    def agetParamMask0(self):
        """
        agetParamMask0(CRankOneCF self)

        Parameters
        ----------
        self: limix::CRankOneCF const *

        """
        return _core.CRankOneCF_agetParamMask0(self)


    def getName(self):
        """
        getName(CRankOneCF self) -> std::string

        Parameters
        ----------
        self: limix::CRankOneCF const *

        """
        return _core.CRankOneCF_getName(self)

CRankOneCF_swigregister = _core.CRankOneCF_swigregister
CRankOneCF_swigregister(CRankOneCF)

class CLowRankCF(ACovarianceFunction):
    """Proxy of C++ limix::CLowRankCF class."""

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

    def __init__(self, numberGroups, rank):
        """
        __init__(limix::CLowRankCF self, limix::muint_t numberGroups, limix::muint_t rank) -> CLowRankCF

        Parameters
        ----------
        numberGroups: limix::muint_t
        rank: limix::muint_t

        """
        this = _core.new_CLowRankCF(numberGroups, rank)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CLowRankCF
    __del__ = lambda self: None

    def setX(self, X):
        """
        setX(CLowRankCF self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.CLowRankCF_setX(self, X)


    def setXcol(self, X, col):
        """
        setXcol(CLowRankCF self, limix::CovarInput const & X, limix::muint_t col)

        Parameters
        ----------
        X: limix::CovarInput const &
        col: limix::muint_t

        """
        return _core.CLowRankCF_setXcol(self, X, col)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CLowRankCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CLowRankCF_Kcross_diag(self, Xstar)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(CLowRankCF self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.CLowRankCF_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(CLowRankCF self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CLowRankCF_Kdiag_grad_X(self, d)


    def Kdim(self):
        """
        Kdim(CLowRankCF self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CLowRankCF const *

        """
        return _core.CLowRankCF_Kdim(self)


    def agetScales(self):
        """
        agetScales(CLowRankCF self)

        Parameters
        ----------
        self: limix::CLowRankCF *

        """
        return _core.CLowRankCF_agetScales(self)


    def setParamsCovariance(self, K0):
        """
        setParamsCovariance(CLowRankCF self, MatrixXd const & K0)

        Parameters
        ----------
        K0: MatrixXd const &

        """
        return _core.CLowRankCF_setParamsCovariance(self, K0)


    def Kcross(self, Xstar):
        """
        Kcross(CLowRankCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CLowRankCF_Kcross(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(CLowRankCF self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CLowRankCF_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(CLowRankCF self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CLowRankCF_Khess_param(self, i, j)


    def agetParamMask0(self):
        """
        agetParamMask0(CLowRankCF self)

        Parameters
        ----------
        self: limix::CLowRankCF const *

        """
        return _core.CLowRankCF_agetParamMask0(self)


    def getName(self):
        """
        getName(CLowRankCF self) -> std::string

        Parameters
        ----------
        self: limix::CLowRankCF const *

        """
        return _core.CLowRankCF_getName(self)

CLowRankCF_swigregister = _core.CLowRankCF_swigregister
CLowRankCF_swigregister(CLowRankCF)

class CFixedCF(ACovarianceFunction):
    """Proxy of C++ limix::CFixedCF class."""

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

    def __init__(self, K0):
        """
        __init__(limix::CFixedCF self, MatrixXd const & K0) -> CFixedCF

        Parameters
        ----------
        K0: MatrixXd const &

        """
        this = _core.new_CFixedCF(K0)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CFixedCF
    __del__ = lambda self: None

    def agetScales(self):
        """
        agetScales(CFixedCF self)

        Parameters
        ----------
        self: limix::CFixedCF *

        """
        return _core.CFixedCF_agetScales(self)


    def setParamsCovariance(self, K0):
        """
        setParamsCovariance(CFixedCF self, MatrixXd const & K0)

        Parameters
        ----------
        K0: MatrixXd const &

        """
        return _core.CFixedCF_setParamsCovariance(self, K0)


    def Kcross(self, Xstar):
        """
        Kcross(CFixedCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CFixedCF_Kcross(self, Xstar)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CFixedCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CFixedCF_Kcross_diag(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(CFixedCF self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CFixedCF_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(CFixedCF self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CFixedCF_Khess_param(self, i, j)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(CFixedCF self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.CFixedCF_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(CFixedCF self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CFixedCF_Kdiag_grad_X(self, d)


    def K(self):
        """
        K(CFixedCF self)

        Parameters
        ----------
        self: limix::CFixedCF const *

        """
        return _core.CFixedCF_K(self)


    def Kdim(self):
        """
        Kdim(CFixedCF self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CFixedCF const *

        """
        return _core.CFixedCF_Kdim(self)


    def agetParamMask0(self):
        """
        agetParamMask0(CFixedCF self)

        Parameters
        ----------
        self: limix::CFixedCF const *

        """
        return _core.CFixedCF_agetParamMask0(self)


    def setK0(self, K0):
        """
        setK0(CFixedCF self, MatrixXd const & K0)

        Parameters
        ----------
        K0: MatrixXd const &

        """
        return _core.CFixedCF_setK0(self, K0)


    def setK0cross(self, Kcross):
        """
        setK0cross(CFixedCF self, MatrixXd const & Kcross)

        Parameters
        ----------
        Kcross: MatrixXd const &

        """
        return _core.CFixedCF_setK0cross(self, Kcross)


    def agetK0(self):
        """
        agetK0(CFixedCF self)

        Parameters
        ----------
        self: limix::CFixedCF const *

        """
        return _core.CFixedCF_agetK0(self)


    def agetK0cross(self):
        """
        agetK0cross(CFixedCF self)

        Parameters
        ----------
        self: limix::CFixedCF const *

        """
        return _core.CFixedCF_agetK0cross(self)


    def setK0cross_diag(self, Kcross_diag):
        """
        setK0cross_diag(CFixedCF self, VectorXd const & Kcross_diag)

        Parameters
        ----------
        Kcross_diag: VectorXd const &

        """
        return _core.CFixedCF_setK0cross_diag(self, Kcross_diag)


    def agetK0cross_diag(self):
        """
        agetK0cross_diag(CFixedCF self)

        Parameters
        ----------
        self: limix::CFixedCF const *

        """
        return _core.CFixedCF_agetK0cross_diag(self)


    def getName(self):
        """
        getName(CFixedCF self) -> std::string

        Parameters
        ----------
        self: limix::CFixedCF const *

        """
        return _core.CFixedCF_getName(self)

CFixedCF_swigregister = _core.CFixedCF_swigregister
CFixedCF_swigregister(CFixedCF)

class CDiagonalCF(ACovarianceFunction):
    """Proxy of C++ limix::CDiagonalCF class."""

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

    def __init__(self, numberGroups):
        """
        __init__(limix::CDiagonalCF self, limix::muint_t numberGroups) -> CDiagonalCF

        Parameters
        ----------
        numberGroups: limix::muint_t

        """
        this = _core.new_CDiagonalCF(numberGroups)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CDiagonalCF
    __del__ = lambda self: None

    def setX(self, X):
        """
        setX(CDiagonalCF self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.CDiagonalCF_setX(self, X)


    def setXcol(self, X, col):
        """
        setXcol(CDiagonalCF self, limix::CovarInput const & X, limix::muint_t col)

        Parameters
        ----------
        X: limix::CovarInput const &
        col: limix::muint_t

        """
        return _core.CDiagonalCF_setXcol(self, X, col)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CDiagonalCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CDiagonalCF_Kcross_diag(self, Xstar)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(CDiagonalCF self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.CDiagonalCF_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(CDiagonalCF self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CDiagonalCF_Kdiag_grad_X(self, d)


    def agetScales(self):
        """
        agetScales(CDiagonalCF self)

        Parameters
        ----------
        self: limix::CDiagonalCF *

        """
        return _core.CDiagonalCF_agetScales(self)


    def setParamsCovariance(self, K0):
        """
        setParamsCovariance(CDiagonalCF self, MatrixXd const & K0)

        Parameters
        ----------
        K0: MatrixXd const &

        """
        return _core.CDiagonalCF_setParamsCovariance(self, K0)


    def Kdim(self):
        """
        Kdim(CDiagonalCF self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CDiagonalCF const *

        """
        return _core.CDiagonalCF_Kdim(self)


    def Kcross(self, Xstar):
        """
        Kcross(CDiagonalCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CDiagonalCF_Kcross(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(CDiagonalCF self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CDiagonalCF_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(CDiagonalCF self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CDiagonalCF_Khess_param(self, i, j)


    def agetParamMask0(self):
        """
        agetParamMask0(CDiagonalCF self)

        Parameters
        ----------
        self: limix::CDiagonalCF const *

        """
        return _core.CDiagonalCF_agetParamMask0(self)


    def getName(self):
        """
        getName(CDiagonalCF self) -> std::string

        Parameters
        ----------
        self: limix::CDiagonalCF const *

        """
        return _core.CDiagonalCF_getName(self)

CDiagonalCF_swigregister = _core.CDiagonalCF_swigregister
CDiagonalCF_swigregister(CDiagonalCF)

class CRank1diagCF(ACovarianceFunction):
    """Proxy of C++ limix::CRank1diagCF class."""

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

    def __init__(self, numberGroups):
        """
        __init__(limix::CRank1diagCF self, limix::muint_t numberGroups) -> CRank1diagCF

        Parameters
        ----------
        numberGroups: limix::muint_t

        """
        this = _core.new_CRank1diagCF(numberGroups)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CRank1diagCF
    __del__ = lambda self: None

    def setX(self, X):
        """
        setX(CRank1diagCF self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.CRank1diagCF_setX(self, X)


    def setXcol(self, X, col):
        """
        setXcol(CRank1diagCF self, limix::CovarInput const & X, limix::muint_t col)

        Parameters
        ----------
        X: limix::CovarInput const &
        col: limix::muint_t

        """
        return _core.CRank1diagCF_setXcol(self, X, col)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CRank1diagCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CRank1diagCF_Kcross_diag(self, Xstar)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(CRank1diagCF self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.CRank1diagCF_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(CRank1diagCF self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CRank1diagCF_Kdiag_grad_X(self, d)


    def agetScales(self):
        """
        agetScales(CRank1diagCF self)

        Parameters
        ----------
        self: limix::CRank1diagCF *

        """
        return _core.CRank1diagCF_agetScales(self)


    def setParamsCovariance(self, K0):
        """
        setParamsCovariance(CRank1diagCF self, MatrixXd const & K0)

        Parameters
        ----------
        K0: MatrixXd const &

        """
        return _core.CRank1diagCF_setParamsCovariance(self, K0)


    def Kdim(self):
        """
        Kdim(CRank1diagCF self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CRank1diagCF const *

        """
        return _core.CRank1diagCF_Kdim(self)


    def agetRank1(self):
        """
        agetRank1(CRank1diagCF self)

        Parameters
        ----------
        self: limix::CRank1diagCF const *

        """
        return _core.CRank1diagCF_agetRank1(self)


    def agetDiag(self):
        """
        agetDiag(CRank1diagCF self)

        Parameters
        ----------
        self: limix::CRank1diagCF const *

        """
        return _core.CRank1diagCF_agetDiag(self)


    def Kcross(self, Xstar):
        """
        Kcross(CRank1diagCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CRank1diagCF_Kcross(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(CRank1diagCF self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CRank1diagCF_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(CRank1diagCF self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CRank1diagCF_Khess_param(self, i, j)


    def agetParamMask0(self):
        """
        agetParamMask0(CRank1diagCF self)

        Parameters
        ----------
        self: limix::CRank1diagCF const *

        """
        return _core.CRank1diagCF_agetParamMask0(self)


    def getName(self):
        """
        getName(CRank1diagCF self) -> std::string

        Parameters
        ----------
        self: limix::CRank1diagCF const *

        """
        return _core.CRank1diagCF_getName(self)

CRank1diagCF_swigregister = _core.CRank1diagCF_swigregister
CRank1diagCF_swigregister(CRank1diagCF)

class CSqExpCF(ACovarianceFunction):
    """Proxy of C++ limix::CSqExpCF class."""

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

    def __init__(self, numberGroups, dim):
        """
        __init__(limix::CSqExpCF self, limix::muint_t numberGroups, limix::muint_t dim) -> CSqExpCF

        Parameters
        ----------
        numberGroups: limix::muint_t
        dim: limix::muint_t

        """
        this = _core.new_CSqExpCF(numberGroups, dim)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CSqExpCF
    __del__ = lambda self: None

    def setX(self, X):
        """
        setX(CSqExpCF self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.CSqExpCF_setX(self, X)


    def setXcol(self, X, col):
        """
        setXcol(CSqExpCF self, limix::CovarInput const & X, limix::muint_t col)

        Parameters
        ----------
        X: limix::CovarInput const &
        col: limix::muint_t

        """
        return _core.CSqExpCF_setXcol(self, X, col)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CSqExpCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CSqExpCF_Kcross_diag(self, Xstar)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(CSqExpCF self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.CSqExpCF_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(CSqExpCF self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CSqExpCF_Kdiag_grad_X(self, d)


    def agetScales(self):
        """
        agetScales(CSqExpCF self)

        Parameters
        ----------
        self: limix::CSqExpCF *

        """
        return _core.CSqExpCF_agetScales(self)


    def setParamsCovariance(self, K0):
        """
        setParamsCovariance(CSqExpCF self, MatrixXd const & K0)

        Parameters
        ----------
        K0: MatrixXd const &

        """
        return _core.CSqExpCF_setParamsCovariance(self, K0)


    def Kdim(self):
        """
        Kdim(CSqExpCF self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CSqExpCF const *

        """
        return _core.CSqExpCF_Kdim(self)


    def Kcross(self, Xstar):
        """
        Kcross(CSqExpCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CSqExpCF_Kcross(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(CSqExpCF self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CSqExpCF_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(CSqExpCF self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CSqExpCF_Khess_param(self, i, j)


    def agetParamMask0(self):
        """
        agetParamMask0(CSqExpCF self)

        Parameters
        ----------
        self: limix::CSqExpCF const *

        """
        return _core.CSqExpCF_agetParamMask0(self)


    def getName(self):
        """
        getName(CSqExpCF self) -> std::string

        Parameters
        ----------
        self: limix::CSqExpCF const *

        """
        return _core.CSqExpCF_getName(self)

CSqExpCF_swigregister = _core.CSqExpCF_swigregister
CSqExpCF_swigregister(CSqExpCF)

class CFixedDiagonalCF(ACovarianceFunction):
    """Proxy of C++ limix::CFixedDiagonalCF class."""

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

    def __init__(self, covar, d):
        """
        __init__(limix::CFixedDiagonalCF self, limix::PCovarianceFunction covar, VectorXd const & d) -> CFixedDiagonalCF

        Parameters
        ----------
        covar: limix::PCovarianceFunction
        d: VectorXd const &

        """
        this = _core.new_CFixedDiagonalCF(covar, d)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CFixedDiagonalCF
    __del__ = lambda self: None

    def setParams(self, params):
        """
        setParams(CFixedDiagonalCF self, limix::CovarParams const & params)

        Parameters
        ----------
        params: limix::CovarParams const &

        """
        return _core.CFixedDiagonalCF_setParams(self, params)


    def getParams(self):
        """
        getParams(CFixedDiagonalCF self)

        Parameters
        ----------
        self: limix::CFixedDiagonalCF const *

        """
        return _core.CFixedDiagonalCF_getParams(self)


    def setX(self, X):
        """
        setX(CFixedDiagonalCF self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.CFixedDiagonalCF_setX(self, X)


    def setXcol(self, X, col):
        """
        setXcol(CFixedDiagonalCF self, limix::CovarInput const & X, limix::muint_t col)

        Parameters
        ----------
        X: limix::CovarInput const &
        col: limix::muint_t

        """
        return _core.CFixedDiagonalCF_setXcol(self, X, col)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CFixedDiagonalCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CFixedDiagonalCF_Kcross_diag(self, Xstar)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(CFixedDiagonalCF self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.CFixedDiagonalCF_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(CFixedDiagonalCF self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CFixedDiagonalCF_Kdiag_grad_X(self, d)


    def agetScales(self):
        """
        agetScales(CFixedDiagonalCF self)

        Parameters
        ----------
        self: limix::CFixedDiagonalCF *

        """
        return _core.CFixedDiagonalCF_agetScales(self)


    def setParamsCovariance(self, K0):
        """
        setParamsCovariance(CFixedDiagonalCF self, MatrixXd const & K0)

        Parameters
        ----------
        K0: MatrixXd const &

        """
        return _core.CFixedDiagonalCF_setParamsCovariance(self, K0)


    def Kdim(self):
        """
        Kdim(CFixedDiagonalCF self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CFixedDiagonalCF const *

        """
        return _core.CFixedDiagonalCF_Kdim(self)


    def Kcross(self, Xstar):
        """
        Kcross(CFixedDiagonalCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CFixedDiagonalCF_Kcross(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(CFixedDiagonalCF self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CFixedDiagonalCF_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(CFixedDiagonalCF self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CFixedDiagonalCF_Khess_param(self, i, j)


    def agetParamMask0(self):
        """
        agetParamMask0(CFixedDiagonalCF self)

        Parameters
        ----------
        self: limix::CFixedDiagonalCF const *

        """
        return _core.CFixedDiagonalCF_agetParamMask0(self)


    def getName(self):
        """
        getName(CFixedDiagonalCF self) -> std::string

        Parameters
        ----------
        self: limix::CFixedDiagonalCF const *

        """
        return _core.CFixedDiagonalCF_getName(self)

CFixedDiagonalCF_swigregister = _core.CFixedDiagonalCF_swigregister
CFixedDiagonalCF_swigregister(CFixedDiagonalCF)

class CPolyCF(ACovarianceFunction):
    """Proxy of C++ limix::CPolyCF class."""

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

    def __init__(self, numberGroups, n_dims, order):
        """
        __init__(limix::CPolyCF self, limix::muint_t numberGroups, limix::muint_t n_dims, limix::muint_t order) -> CPolyCF

        Parameters
        ----------
        numberGroups: limix::muint_t
        n_dims: limix::muint_t
        order: limix::muint_t

        """
        this = _core.new_CPolyCF(numberGroups, n_dims, order)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CPolyCF
    __del__ = lambda self: None

    def setX(self, X):
        """
        setX(CPolyCF self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.CPolyCF_setX(self, X)


    def setXcol(self, X, col):
        """
        setXcol(CPolyCF self, limix::CovarInput const & X, limix::muint_t col)

        Parameters
        ----------
        X: limix::CovarInput const &
        col: limix::muint_t

        """
        return _core.CPolyCF_setXcol(self, X, col)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CPolyCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CPolyCF_Kcross_diag(self, Xstar)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(CPolyCF self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.CPolyCF_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(CPolyCF self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CPolyCF_Kdiag_grad_X(self, d)


    def Kdim(self):
        """
        Kdim(CPolyCF self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CPolyCF const *

        """
        return _core.CPolyCF_Kdim(self)


    def agetScales(self):
        """
        agetScales(CPolyCF self)

        Parameters
        ----------
        self: limix::CPolyCF *

        """
        return _core.CPolyCF_agetScales(self)


    def setParamsCovariance(self, K0):
        """
        setParamsCovariance(CPolyCF self, MatrixXd const & K0)

        Parameters
        ----------
        K0: MatrixXd const &

        """
        return _core.CPolyCF_setParamsCovariance(self, K0)


    def Kcross(self, Xstar):
        """
        Kcross(CPolyCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CPolyCF_Kcross(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(CPolyCF self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CPolyCF_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(CPolyCF self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CPolyCF_Khess_param(self, i, j)


    def agetParamMask0(self):
        """
        agetParamMask0(CPolyCF self)

        Parameters
        ----------
        self: limix::CPolyCF const *

        """
        return _core.CPolyCF_agetParamMask0(self)


    def getName(self):
        """
        getName(CPolyCF self) -> std::string

        Parameters
        ----------
        self: limix::CPolyCF const *

        """
        return _core.CPolyCF_getName(self)

CPolyCF_swigregister = _core.CPolyCF_swigregister
CPolyCF_swigregister(CPolyCF)

class CCovSqexpARD(ACovarianceFunction):
    """Proxy of C++ limix::CCovSqexpARD class."""

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

    def __init__(self, numberDimensions=1):
        """
        __init__(limix::CCovSqexpARD self, limix::muint_t numberDimensions=1) -> CCovSqexpARD

        Parameters
        ----------
        numberDimensions: limix::muint_t

        __init__(limix::CCovSqexpARD self) -> CCovSqexpARD
        """
        this = _core.new_CCovSqexpARD(numberDimensions)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CCovSqexpARD
    __del__ = lambda self: None

    def setNumberDimensions(self, numberDimensions):
        """
        setNumberDimensions(CCovSqexpARD self, limix::muint_t numberDimensions)

        Parameters
        ----------
        numberDimensions: limix::muint_t

        """
        return _core.CCovSqexpARD_setNumberDimensions(self, numberDimensions)


    def Kcross(self, Xstar):
        """
        Kcross(CCovSqexpARD self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CCovSqexpARD_Kcross(self, Xstar)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CCovSqexpARD self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CCovSqexpARD_Kcross_diag(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(CCovSqexpARD self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CCovSqexpARD_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(CCovSqexpARD self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CCovSqexpARD_Khess_param(self, i, j)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(CCovSqexpARD self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.CCovSqexpARD_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(CCovSqexpARD self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CCovSqexpARD_Kdiag_grad_X(self, d)


    def getName(self):
        """
        getName(CCovSqexpARD self) -> std::string

        Parameters
        ----------
        self: limix::CCovSqexpARD const *

        """
        return _core.CCovSqexpARD_getName(self)

CCovSqexpARD_swigregister = _core.CCovSqexpARD_swigregister
CCovSqexpARD_swigregister(CCovSqexpARD)

class AMultiCF(ACovarianceFunction):
    """Proxy of C++ limix::AMultiCF class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _core.delete_AMultiCF
    __del__ = lambda self: None

    def Kdim(self):
        """
        Kdim(AMultiCF self) -> limix::muint_t

        Parameters
        ----------
        self: limix::AMultiCF const *

        """
        return _core.AMultiCF_Kdim(self)


    def addSyncChild(self, l):
        """
        addSyncChild(AMultiCF self, limix::Pbool l)

        Parameters
        ----------
        l: limix::Pbool

        """
        return _core.AMultiCF_addSyncChild(self, l)


    def delSyncChild(self, l):
        """
        delSyncChild(AMultiCF self, limix::Pbool l)

        Parameters
        ----------
        l: limix::Pbool

        """
        return _core.AMultiCF_delSyncChild(self, l)


    def addCovariance(self, covar):
        """
        addCovariance(AMultiCF self, limix::PCovarianceFunction covar)

        Parameters
        ----------
        covar: limix::PCovarianceFunction

        """
        return _core.AMultiCF_addCovariance(self, covar)


    def setCovariance(self, i, covar):
        """
        setCovariance(AMultiCF self, limix::muint_t i, limix::PCovarianceFunction covar)

        Parameters
        ----------
        i: limix::muint_t
        covar: limix::PCovarianceFunction

        """
        return _core.AMultiCF_setCovariance(self, i, covar)


    def getCovariance(self, i):
        """
        getCovariance(AMultiCF self, limix::muint_t i) -> limix::PCovarianceFunction

        Parameters
        ----------
        i: limix::muint_t

        """
        return _core.AMultiCF_getCovariance(self, i)


    def getNumberDimensions(self):
        """
        getNumberDimensions(AMultiCF self) -> limix::muint_t

        Parameters
        ----------
        self: limix::AMultiCF const *

        """
        return _core.AMultiCF_getNumberDimensions(self)


    def setNumberDimensions(self, numberDimensions):
        """
        setNumberDimensions(AMultiCF self, limix::muint_t numberDimensions)

        Parameters
        ----------
        numberDimensions: limix::muint_t

        """
        return _core.AMultiCF_setNumberDimensions(self, numberDimensions)


    def getNumberParams(self):
        """
        getNumberParams(AMultiCF self) -> limix::muint_t

        Parameters
        ----------
        self: limix::AMultiCF const *

        """
        return _core.AMultiCF_getNumberParams(self)


    def setX(self, X):
        """
        setX(AMultiCF self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.AMultiCF_setX(self, X)


    def getX(self):
        """
        getX(AMultiCF self)

        Parameters
        ----------
        self: limix::AMultiCF const *

        """
        return _core.AMultiCF_getX(self)


    def setXcol(self, X, col):
        """
        setXcol(AMultiCF self, limix::CovarInput const & X, limix::muint_t col)

        Parameters
        ----------
        X: limix::CovarInput const &
        col: limix::muint_t

        """
        return _core.AMultiCF_setXcol(self, X, col)


    def setParams(self, params):
        """
        setParams(AMultiCF self, limix::CovarParams const & params)

        Parameters
        ----------
        params: limix::CovarParams const &

        """
        return _core.AMultiCF_setParams(self, params)


    def getParams(self):
        """
        getParams(AMultiCF self)

        Parameters
        ----------
        self: limix::AMultiCF const *

        """
        return _core.AMultiCF_getParams(self)


    def getParamMask(self):
        """
        getParamMask(AMultiCF self)

        Parameters
        ----------
        self: limix::AMultiCF const *

        """
        return _core.AMultiCF_getParamMask(self)


    def setParamMask(self, params):
        """
        setParamMask(AMultiCF self, limix::CovarParams const & params)

        Parameters
        ----------
        params: limix::CovarParams const &

        """
        return _core.AMultiCF_setParamMask(self, params)


    def getParamBounds0(self):
        """
        getParamBounds0(AMultiCF self)

        Parameters
        ----------
        self: limix::AMultiCF const *

        """
        return _core.AMultiCF_getParamBounds0(self)


    def getParamBounds(self):
        """
        getParamBounds(AMultiCF self)

        Parameters
        ----------
        self: limix::AMultiCF const *

        """
        return _core.AMultiCF_getParamBounds(self)


    def setParamBounds(self, lower, upper):
        """
        setParamBounds(AMultiCF self, limix::CovarParams const & lower, limix::CovarParams const & upper)

        Parameters
        ----------
        lower: limix::CovarParams const &
        upper: limix::CovarParams const &

        """
        return _core.AMultiCF_setParamBounds(self, lower, upper)

AMultiCF_swigregister = _core.AMultiCF_swigregister
AMultiCF_swigregister(AMultiCF)

class CSumCF(AMultiCF):
    """Proxy of C++ limix::CSumCF class."""

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

    def __init__(self, *args):
        """
        __init__(limix::CSumCF self, limix::ACovarVec const & covariances) -> CSumCF

        Parameters
        ----------
        covariances: limix::ACovarVec const &

        __init__(limix::CSumCF self, limix::muint_t const numCovariances=0) -> CSumCF

        Parameters
        ----------
        numCovariances: limix::muint_t const

        __init__(limix::CSumCF self) -> CSumCF
        """
        this = _core.new_CSumCF(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CSumCF
    __del__ = lambda self: None

    def Kcross(self, Xstar):
        """
        Kcross(CSumCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CSumCF_Kcross(self, Xstar)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CSumCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CSumCF_Kcross_diag(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(CSumCF self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CSumCF_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(CSumCF self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CSumCF_Khess_param(self, i, j)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(CSumCF self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.CSumCF_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(CSumCF self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CSumCF_Kdiag_grad_X(self, d)


    def K(self):
        """
        K(CSumCF self)

        Parameters
        ----------
        self: limix::CSumCF const *

        """
        return _core.CSumCF_K(self)


    def Kdiag(self):
        """
        Kdiag(CSumCF self)

        Parameters
        ----------
        self: limix::CSumCF const *

        """
        return _core.CSumCF_Kdiag(self)


    def Kgrad_X(self, d):
        """
        Kgrad_X(CSumCF self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CSumCF_Kgrad_X(self, d)


    def getName(self):
        """
        getName(CSumCF self) -> std::string

        Parameters
        ----------
        self: limix::CSumCF const *

        """
        return _core.CSumCF_getName(self)

CSumCF_swigregister = _core.CSumCF_swigregister
CSumCF_swigregister(CSumCF)

class CLinCombCF(AMultiCF):
    """Proxy of C++ limix::CLinCombCF class."""

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

    def __init__(self, *args):
        """
        __init__(limix::CLinCombCF self, limix::ACovarVec const & covariances) -> CLinCombCF

        Parameters
        ----------
        covariances: limix::ACovarVec const &

        __init__(limix::CLinCombCF self, limix::muint_t const numCovariances=0) -> CLinCombCF

        Parameters
        ----------
        numCovariances: limix::muint_t const

        __init__(limix::CLinCombCF self) -> CLinCombCF
        """
        this = _core.new_CLinCombCF(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CLinCombCF
    __del__ = lambda self: None

    def setCoeff(self, coeff):
        """
        setCoeff(CLinCombCF self, VectorXd const & coeff)

        Parameters
        ----------
        coeff: VectorXd const &

        """
        return _core.CLinCombCF_setCoeff(self, coeff)


    def agetCoeff(self):
        """
        agetCoeff(CLinCombCF self)

        Parameters
        ----------
        self: limix::CLinCombCF const *

        """
        return _core.CLinCombCF_agetCoeff(self)


    def Kcross(self, Xstar):
        """
        Kcross(CLinCombCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CLinCombCF_Kcross(self, Xstar)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CLinCombCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CLinCombCF_Kcross_diag(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(CLinCombCF self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CLinCombCF_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(CLinCombCF self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CLinCombCF_Khess_param(self, i, j)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(CLinCombCF self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.CLinCombCF_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(CLinCombCF self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CLinCombCF_Kdiag_grad_X(self, d)


    def K(self):
        """
        K(CLinCombCF self)

        Parameters
        ----------
        self: limix::CLinCombCF const *

        """
        return _core.CLinCombCF_K(self)


    def Kdiag(self):
        """
        Kdiag(CLinCombCF self)

        Parameters
        ----------
        self: limix::CLinCombCF const *

        """
        return _core.CLinCombCF_Kdiag(self)


    def Kgrad_X(self, d):
        """
        Kgrad_X(CLinCombCF self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CLinCombCF_Kgrad_X(self, d)


    def getName(self):
        """
        getName(CLinCombCF self) -> std::string

        Parameters
        ----------
        self: limix::CLinCombCF const *

        """
        return _core.CLinCombCF_getName(self)

CLinCombCF_swigregister = _core.CLinCombCF_swigregister
CLinCombCF_swigregister(CLinCombCF)

class CProductCF(AMultiCF):
    """Proxy of C++ limix::CProductCF class."""

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

    def __init__(self, *args):
        """
        __init__(limix::CProductCF self, limix::ACovarVec const & covariances) -> CProductCF

        Parameters
        ----------
        covariances: limix::ACovarVec const &

        __init__(limix::CProductCF self, limix::muint_t const numCovariances=0) -> CProductCF

        Parameters
        ----------
        numCovariances: limix::muint_t const

        __init__(limix::CProductCF self) -> CProductCF
        """
        this = _core.new_CProductCF(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CProductCF
    __del__ = lambda self: None

    def Kcross(self, Xstar):
        """
        Kcross(CProductCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CProductCF_Kcross(self, Xstar)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CProductCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CProductCF_Kcross_diag(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(CProductCF self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CProductCF_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(CProductCF self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CProductCF_Khess_param(self, i, j)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(CProductCF self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.CProductCF_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(CProductCF self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CProductCF_Kdiag_grad_X(self, d)


    def K(self):
        """
        K(CProductCF self)

        Parameters
        ----------
        self: limix::CProductCF const *

        """
        return _core.CProductCF_K(self)


    def Kdiag(self):
        """
        Kdiag(CProductCF self)

        Parameters
        ----------
        self: limix::CProductCF const *

        """
        return _core.CProductCF_Kdiag(self)


    def Kgrad_X(self, d):
        """
        Kgrad_X(CProductCF self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CProductCF_Kgrad_X(self, d)


    def getName(self):
        """
        getName(CProductCF self) -> std::string

        Parameters
        ----------
        self: limix::CProductCF const *

        """
        return _core.CProductCF_getName(self)

CProductCF_swigregister = _core.CProductCF_swigregister
CProductCF_swigregister(CProductCF)

class CKroneckerCF(AMultiCF):
    """Proxy of C++ limix::CKroneckerCF class."""

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

    def __init__(self, *args):
        """
        __init__(limix::CKroneckerCF self) -> CKroneckerCF
        __init__(limix::CKroneckerCF self, limix::PCovarianceFunction col, limix::PCovarianceFunction row) -> CKroneckerCF

        Parameters
        ----------
        col: limix::PCovarianceFunction
        row: limix::PCovarianceFunction

        """
        this = _core.new_CKroneckerCF(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CKroneckerCF
    __del__ = lambda self: None

    def Kdim(self):
        """
        Kdim(CKroneckerCF self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CKroneckerCF const *

        """
        return _core.CKroneckerCF_Kdim(self)


    def setRowCovariance(self, cov):
        """
        setRowCovariance(CKroneckerCF self, limix::PCovarianceFunction cov)

        Parameters
        ----------
        cov: limix::PCovarianceFunction

        """
        return _core.CKroneckerCF_setRowCovariance(self, cov)


    def setColCovariance(self, cov):
        """
        setColCovariance(CKroneckerCF self, limix::PCovarianceFunction cov)

        Parameters
        ----------
        cov: limix::PCovarianceFunction

        """
        return _core.CKroneckerCF_setColCovariance(self, cov)


    def getRowCovariance(self):
        """
        getRowCovariance(CKroneckerCF self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::CKroneckerCF *

        """
        return _core.CKroneckerCF_getRowCovariance(self)


    def getColCovariance(self):
        """
        getColCovariance(CKroneckerCF self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::CKroneckerCF *

        """
        return _core.CKroneckerCF_getColCovariance(self)


    def setKroneckerIndicator(self, kroneckerIndicator):
        """
        setKroneckerIndicator(CKroneckerCF self, MatrixXi const & kroneckerIndicator)

        Parameters
        ----------
        kroneckerIndicator: MatrixXi const &

        """
        return _core.CKroneckerCF_setKroneckerIndicator(self, kroneckerIndicator)


    def getKroneckerIndicator(self):
        """
        getKroneckerIndicator(CKroneckerCF self)

        Parameters
        ----------
        self: limix::CKroneckerCF const *

        """
        return _core.CKroneckerCF_getKroneckerIndicator(self)


    def isKronecker(self):
        """
        isKronecker(CKroneckerCF self) -> bool

        Parameters
        ----------
        self: limix::CKroneckerCF const *

        """
        return _core.CKroneckerCF_isKronecker(self)


    def setX(self, X):
        """
        setX(CKroneckerCF self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.CKroneckerCF_setX(self, X)


    def getX(self):
        """
        getX(CKroneckerCF self)

        Parameters
        ----------
        self: limix::CKroneckerCF const *

        """
        return _core.CKroneckerCF_getX(self)


    def setXcol(self, X, col):
        """
        setXcol(CKroneckerCF self, limix::CovarInput const & X, limix::muint_t col)

        Parameters
        ----------
        X: limix::CovarInput const &
        col: limix::muint_t

        """
        return _core.CKroneckerCF_setXcol(self, X, col)


    def setXr(self, Xr):
        """
        setXr(CKroneckerCF self, limix::CovarInput const & Xr)

        Parameters
        ----------
        Xr: limix::CovarInput const &

        """
        return _core.CKroneckerCF_setXr(self, Xr)


    def setXc(self, Xc):
        """
        setXc(CKroneckerCF self, limix::CovarInput const & Xc)

        Parameters
        ----------
        Xc: limix::CovarInput const &

        """
        return _core.CKroneckerCF_setXc(self, Xc)


    def Kcross(self, Xstar):
        """
        Kcross(CKroneckerCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CKroneckerCF_Kcross(self, Xstar)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CKroneckerCF self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CKroneckerCF_Kcross_diag(self, Xstar)


    def Kgrad_param(self, i):
        """
        Kgrad_param(CKroneckerCF self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CKroneckerCF_Kgrad_param(self, i)


    def Khess_param(self, i, j):
        """
        Khess_param(CKroneckerCF self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CKroneckerCF_Khess_param(self, i, j)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(CKroneckerCF self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.CKroneckerCF_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(CKroneckerCF self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CKroneckerCF_Kdiag_grad_X(self, d)


    def K(self):
        """
        K(CKroneckerCF self)

        Parameters
        ----------
        self: limix::CKroneckerCF const *

        """
        return _core.CKroneckerCF_K(self)


    def Kdiag(self):
        """
        Kdiag(CKroneckerCF self)

        Parameters
        ----------
        self: limix::CKroneckerCF const *

        """
        return _core.CKroneckerCF_Kdiag(self)


    def Kgrad_X(self, d):
        """
        Kgrad_X(CKroneckerCF self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.CKroneckerCF_Kgrad_X(self, d)


    def getName(self):
        """
        getName(CKroneckerCF self) -> std::string

        Parameters
        ----------
        self: limix::CKroneckerCF const *

        """
        return _core.CKroneckerCF_getName(self)


    def createKroneckerIndex(Ncols, Nrows):
        """
        createKroneckerIndex(limix::muint_t Ncols, limix::muint_t Nrows)

        Parameters
        ----------
        Ncols: limix::muint_t
        Nrows: limix::muint_t

        """
        return _core.CKroneckerCF_createKroneckerIndex(Ncols, Nrows)

    if _newclass:
        createKroneckerIndex = staticmethod(createKroneckerIndex)
    __swig_getmethods__["createKroneckerIndex"] = lambda x: createKroneckerIndex
CKroneckerCF_swigregister = _core.CKroneckerCF_swigregister
CKroneckerCF_swigregister(CKroneckerCF)

def CKroneckerCF_createKroneckerIndex(Ncols, Nrows):
    """
    CKroneckerCF_createKroneckerIndex(limix::muint_t Ncols, limix::muint_t Nrows)

    Parameters
    ----------
    Ncols: limix::muint_t
    Nrows: limix::muint_t

    """
    return _core.CKroneckerCF_createKroneckerIndex(Ncols, Nrows)

class ALikelihood(ACovarianceFunction):
    """Proxy of C++ limix::ALikelihood class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _core.delete_ALikelihood
    __del__ = lambda self: None

    def Kcross(self, Xstar):
        """
        Kcross(ALikelihood self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.ALikelihood_Kcross(self, Xstar)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(ALikelihood self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.ALikelihood_Kcross_diag(self, Xstar)


    def Kcross_grad_X(self, Xstar, d):
        """
        Kcross_grad_X(ALikelihood self, limix::CovarInput const & Xstar, limix::muint_t const d)

        Parameters
        ----------
        Xstar: limix::CovarInput const &
        d: limix::muint_t const

        """
        return _core.ALikelihood_Kcross_grad_X(self, Xstar, d)


    def Kdiag_grad_X(self, d):
        """
        Kdiag_grad_X(ALikelihood self, limix::muint_t const d)

        Parameters
        ----------
        d: limix::muint_t const

        """
        return _core.ALikelihood_Kdiag_grad_X(self, d)

ALikelihood_swigregister = _core.ALikelihood_swigregister
ALikelihood_swigregister(ALikelihood)

class CLikNormalNULL(ALikelihood):
    """Proxy of C++ limix::CLikNormalNULL class."""

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

    def __init__(self):
        """__init__(limix::CLikNormalNULL self) -> CLikNormalNULL"""
        this = _core.new_CLikNormalNULL()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CLikNormalNULL
    __del__ = lambda self: None

    def K(self):
        """
        K(CLikNormalNULL self)

        Parameters
        ----------
        self: limix::CLikNormalNULL const *

        """
        return _core.CLikNormalNULL_K(self)


    def Kdiag(self):
        """
        Kdiag(CLikNormalNULL self)

        Parameters
        ----------
        self: limix::CLikNormalNULL const *

        """
        return _core.CLikNormalNULL_Kdiag(self)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CLikNormalNULL self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CLikNormalNULL_Kcross_diag(self, Xstar)


    def Kgrad_param(self, row):
        """
        Kgrad_param(CLikNormalNULL self, limix::muint_t const row)

        Parameters
        ----------
        row: limix::muint_t const

        """
        return _core.CLikNormalNULL_Kgrad_param(self, row)


    def Khess_param(self, i, j):
        """
        Khess_param(CLikNormalNULL self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CLikNormalNULL_Khess_param(self, i, j)


    def setX(self, X):
        """
        setX(CLikNormalNULL self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.CLikNormalNULL_setX(self, X)


    def getName(self):
        """
        getName(CLikNormalNULL self) -> std::string

        Parameters
        ----------
        self: limix::CLikNormalNULL const *

        """
        return _core.CLikNormalNULL_getName(self)

CLikNormalNULL_swigregister = _core.CLikNormalNULL_swigregister
CLikNormalNULL_swigregister(CLikNormalNULL)

class CLikNormalIso(ALikelihood):
    """Proxy of C++ limix::CLikNormalIso class."""

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

    def __init__(self):
        """__init__(limix::CLikNormalIso self) -> CLikNormalIso"""
        this = _core.new_CLikNormalIso()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CLikNormalIso
    __del__ = lambda self: None

    def K(self):
        """
        K(CLikNormalIso self)

        Parameters
        ----------
        self: limix::CLikNormalIso const *

        """
        return _core.CLikNormalIso_K(self)


    def Kdiag(self):
        """
        Kdiag(CLikNormalIso self)

        Parameters
        ----------
        self: limix::CLikNormalIso const *

        """
        return _core.CLikNormalIso_Kdiag(self)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CLikNormalIso self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CLikNormalIso_Kcross_diag(self, Xstar)


    def Kgrad_param(self, row):
        """
        Kgrad_param(CLikNormalIso self, limix::muint_t const row)

        Parameters
        ----------
        row: limix::muint_t const

        """
        return _core.CLikNormalIso_Kgrad_param(self, row)


    def Khess_param(self, i, j):
        """
        Khess_param(CLikNormalIso self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CLikNormalIso_Khess_param(self, i, j)


    def setX(self, X):
        """
        setX(CLikNormalIso self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.CLikNormalIso_setX(self, X)


    def getName(self):
        """
        getName(CLikNormalIso self) -> std::string

        Parameters
        ----------
        self: limix::CLikNormalIso const *

        """
        return _core.CLikNormalIso_getName(self)

CLikNormalIso_swigregister = _core.CLikNormalIso_swigregister
CLikNormalIso_swigregister(CLikNormalIso)

class CLikNormalSVD(ALikelihood):
    """Proxy of C++ limix::CLikNormalSVD class."""

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

    def __init__(self):
        """__init__(limix::CLikNormalSVD self) -> CLikNormalSVD"""
        this = _core.new_CLikNormalSVD()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CLikNormalSVD
    __del__ = lambda self: None

    def K(self):
        """
        K(CLikNormalSVD self)

        Parameters
        ----------
        self: limix::CLikNormalSVD const *

        """
        return _core.CLikNormalSVD_K(self)


    def Kdiag(self):
        """
        Kdiag(CLikNormalSVD self)

        Parameters
        ----------
        self: limix::CLikNormalSVD const *

        """
        return _core.CLikNormalSVD_Kdiag(self)


    def Kcross_diag(self, Xstar):
        """
        Kcross_diag(CLikNormalSVD self, limix::CovarInput const & Xstar)

        Parameters
        ----------
        Xstar: limix::CovarInput const &

        """
        return _core.CLikNormalSVD_Kcross_diag(self, Xstar)


    def Kgrad_param(self, row):
        """
        Kgrad_param(CLikNormalSVD self, limix::muint_t const row)

        Parameters
        ----------
        row: limix::muint_t const

        """
        return _core.CLikNormalSVD_Kgrad_param(self, row)


    def Khess_param(self, i, j):
        """
        Khess_param(CLikNormalSVD self, limix::muint_t const i, limix::muint_t const j)

        Parameters
        ----------
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CLikNormalSVD_Khess_param(self, i, j)


    def setX(self, X):
        """
        setX(CLikNormalSVD self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.CLikNormalSVD_setX(self, X)


    def getSigmaK2(self):
        """
        getSigmaK2(CLikNormalSVD self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CLikNormalSVD *

        """
        return _core.CLikNormalSVD_getSigmaK2(self)


    def getDelta(self):
        """
        getDelta(CLikNormalSVD self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CLikNormalSVD *

        """
        return _core.CLikNormalSVD_getDelta(self)


    def getSigmaK2grad(self):
        """
        getSigmaK2grad(CLikNormalSVD self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CLikNormalSVD *

        """
        return _core.CLikNormalSVD_getSigmaK2grad(self)


    def getDeltagrad(self):
        """
        getDeltagrad(CLikNormalSVD self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CLikNormalSVD *

        """
        return _core.CLikNormalSVD_getDeltagrad(self)


    def getName(self):
        """
        getName(CLikNormalSVD self) -> std::string

        Parameters
        ----------
        self: limix::CLikNormalSVD const *

        """
        return _core.CLikNormalSVD_getName(self)

CLikNormalSVD_swigregister = _core.CLikNormalSVD_swigregister
CLikNormalSVD_swigregister(CLikNormalSVD)

class ADataTerm(CParamObject):
    """Proxy of C++ limix::ADataTerm class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _core.delete_ADataTerm
    __del__ = lambda self: None

    def setParams(self, params):
        """
        setParams(ADataTerm self, MatrixXd const & params)

        Parameters
        ----------
        params: MatrixXd const &

        """
        return _core.ADataTerm_setParams(self, params)


    def aGetParams(self):
        """
        aGetParams(ADataTerm self)

        Parameters
        ----------
        self: limix::ADataTerm *

        """
        return _core.ADataTerm_aGetParams(self)


    def getParams(self):
        """
        getParams(ADataTerm self) -> MatrixXd

        Parameters
        ----------
        self: limix::ADataTerm *

        """
        return _core.ADataTerm_getParams(self)


    def setY(self, Y):
        """
        setY(ADataTerm self, MatrixXd const & Y)

        Parameters
        ----------
        Y: MatrixXd const &

        """
        return _core.ADataTerm_setY(self, Y)


    def getRowsParams(self):
        """
        getRowsParams(ADataTerm self) -> limix::muint_t

        Parameters
        ----------
        self: limix::ADataTerm *

        """
        return _core.ADataTerm_getRowsParams(self)


    def getColsParams(self):
        """
        getColsParams(ADataTerm self) -> limix::muint_t

        Parameters
        ----------
        self: limix::ADataTerm *

        """
        return _core.ADataTerm_getColsParams(self)


    def evaluate(self):
        """
        evaluate(ADataTerm self)

        Parameters
        ----------
        self: limix::ADataTerm *

        """
        return _core.ADataTerm_evaluate(self)


    def gradY(self):
        """
        gradY(ADataTerm self)

        Parameters
        ----------
        self: limix::ADataTerm *

        """
        return _core.ADataTerm_gradY(self)


    def aGradParams(self):
        """
        aGradParams(ADataTerm self)

        Parameters
        ----------
        self: limix::ADataTerm *

        """
        return _core.ADataTerm_aGradParams(self)


    def sumJacobianGradParams(self):
        """
        sumJacobianGradParams(ADataTerm self)

        Parameters
        ----------
        self: limix::ADataTerm *

        """
        return _core.ADataTerm_sumJacobianGradParams(self)


    def sumLogJacobian(self):
        """
        sumLogJacobian(ADataTerm self)

        Parameters
        ----------
        self: limix::ADataTerm *

        """
        return _core.ADataTerm_sumLogJacobian(self)


    def getY(self):
        """
        getY(ADataTerm self) -> MatrixXd

        Parameters
        ----------
        self: limix::ADataTerm *

        """
        return _core.ADataTerm_getY(self)


    def gradParams(self, KinvY):
        """
        gradParams(ADataTerm self, MatrixXd const & KinvY) -> MatrixXd

        Parameters
        ----------
        KinvY: MatrixXd const &

        """
        return _core.ADataTerm_gradParams(self, KinvY)


    def getName(self):
        """
        getName(ADataTerm self) -> std::string

        Parameters
        ----------
        self: limix::ADataTerm const *

        """
        return _core.ADataTerm_getName(self)


    def checkDimensions(self, Y):
        """
        checkDimensions(ADataTerm self, MatrixXd const & Y)

        Parameters
        ----------
        Y: MatrixXd const &

        """
        return _core.ADataTerm_checkDimensions(self, Y)

ADataTerm_swigregister = _core.ADataTerm_swigregister
ADataTerm_swigregister(ADataTerm)

class CData(ADataTerm):
    """Proxy of C++ limix::CData class."""

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

    def __init__(self, *args):
        """
        __init__(limix::CData self) -> CData
        __init__(limix::CData self, MatrixXd & Y) -> CData

        Parameters
        ----------
        Y: MatrixXd &

        """
        this = _core.new_CData(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CData
    __del__ = lambda self: None

    def getName(self):
        """
        getName(CData self) -> std::string

        Parameters
        ----------
        self: limix::CData const *

        """
        return _core.CData_getName(self)


    def getRowsParams(self):
        """
        getRowsParams(CData self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CData *

        """
        return _core.CData_getRowsParams(self)


    def getColsParams(self):
        """
        getColsParams(CData self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CData *

        """
        return _core.CData_getColsParams(self)

CData_swigregister = _core.CData_swigregister
CData_swigregister(CData)

class CLinearMean(ADataTerm):
    """Proxy of C++ limix::CLinearMean class."""

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

    def __init__(self, *args):
        """
        __init__(limix::CLinearMean self) -> CLinearMean
        __init__(limix::CLinearMean self, limix::muint_t nTargets) -> CLinearMean

        Parameters
        ----------
        nTargets: limix::muint_t

        __init__(limix::CLinearMean self, MatrixXd const & Y, MatrixXd const & weights, MatrixXd const & fixedEffects) -> CLinearMean

        Parameters
        ----------
        Y: MatrixXd const &
        weights: MatrixXd const &
        fixedEffects: MatrixXd const &

        __init__(limix::CLinearMean self, MatrixXd const & Y, MatrixXd const & fixedEffects) -> CLinearMean

        Parameters
        ----------
        Y: MatrixXd const &
        fixedEffects: MatrixXd const &

        """
        this = _core.new_CLinearMean(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CLinearMean
    __del__ = lambda self: None

    def agetA(self):
        """
        agetA(CLinearMean self)

        Parameters
        ----------
        self: limix::CLinearMean *

        """
        return _core.CLinearMean_agetA(self)


    def getA(self):
        """
        getA(CLinearMean self) -> MatrixXd

        Parameters
        ----------
        self: limix::CLinearMean *

        """
        return _core.CLinearMean_getA(self)


    def evaluate(self):
        """
        evaluate(CLinearMean self)

        Parameters
        ----------
        self: limix::CLinearMean *

        """
        return _core.CLinearMean_evaluate(self)


    def aGradParams(self):
        """
        aGradParams(CLinearMean self)

        Parameters
        ----------
        self: limix::CLinearMean *

        """
        return _core.CLinearMean_aGradParams(self)


    def setParams(self, weightMatrix):
        """
        setParams(CLinearMean self, MatrixXd const & weightMatrix)

        Parameters
        ----------
        weightMatrix: MatrixXd const &

        """
        return _core.CLinearMean_setParams(self, weightMatrix)


    def setFixedEffects(self, fixedEffects):
        """
        setFixedEffects(CLinearMean self, MatrixXd const & fixedEffects)

        Parameters
        ----------
        fixedEffects: MatrixXd const &

        """
        return _core.CLinearMean_setFixedEffects(self, fixedEffects)


    def aGetParams(self):
        """
        aGetParams(CLinearMean self)

        Parameters
        ----------
        self: limix::CLinearMean *

        """
        return _core.CLinearMean_aGetParams(self)


    def aGetFixedEffects(self):
        """
        aGetFixedEffects(CLinearMean self)

        Parameters
        ----------
        self: limix::CLinearMean *

        """
        return _core.CLinearMean_aGetFixedEffects(self)


    def aPredictY(self):
        """
        aPredictY(CLinearMean self)

        Parameters
        ----------
        self: limix::CLinearMean const *

        """
        return _core.CLinearMean_aPredictY(self)


    def aPredictYstar(self):
        """
        aPredictYstar(CLinearMean self)

        Parameters
        ----------
        self: limix::CLinearMean const *

        """
        return _core.CLinearMean_aPredictYstar(self)


    def getRowsParams(self):
        """
        getRowsParams(CLinearMean self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CLinearMean *

        """
        return _core.CLinearMean_getRowsParams(self)


    def getColsParams(self):
        """
        getColsParams(CLinearMean self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CLinearMean *

        """
        return _core.CLinearMean_getColsParams(self)


    def getFixedEffects(self):
        """
        getFixedEffects(CLinearMean self) -> MatrixXd

        Parameters
        ----------
        self: limix::CLinearMean *

        """
        return _core.CLinearMean_getFixedEffects(self)


    def getName(self):
        """
        getName(CLinearMean self) -> std::string

        Parameters
        ----------
        self: limix::CLinearMean const *

        """
        return _core.CLinearMean_getName(self)


    def checkDimensions(self, *args):
        """
        checkDimensions(CLinearMean self, MatrixXd const & Y)

        Parameters
        ----------
        Y: MatrixXd const &

        checkDimensions(CLinearMean self, MatrixXd const & weights, MatrixXd const & fixedEffects, MatrixXd const & Y, bool const checkStrictWeights=False, bool const checkStrictFixedEffects=False, bool const checkStrictY=False)

        Parameters
        ----------
        weights: MatrixXd const &
        fixedEffects: MatrixXd const &
        Y: MatrixXd const &
        checkStrictWeights: bool const
        checkStrictFixedEffects: bool const
        checkStrictY: bool const

        checkDimensions(CLinearMean self, MatrixXd const & weights, MatrixXd const & fixedEffects, MatrixXd const & Y, bool const checkStrictWeights=False, bool const checkStrictFixedEffects=False)

        Parameters
        ----------
        weights: MatrixXd const &
        fixedEffects: MatrixXd const &
        Y: MatrixXd const &
        checkStrictWeights: bool const
        checkStrictFixedEffects: bool const

        checkDimensions(CLinearMean self, MatrixXd const & weights, MatrixXd const & fixedEffects, MatrixXd const & Y, bool const checkStrictWeights=False)

        Parameters
        ----------
        weights: MatrixXd const &
        fixedEffects: MatrixXd const &
        Y: MatrixXd const &
        checkStrictWeights: bool const

        checkDimensions(CLinearMean self, MatrixXd const & weights, MatrixXd const & fixedEffects, MatrixXd const & Y)

        Parameters
        ----------
        weights: MatrixXd const &
        fixedEffects: MatrixXd const &
        Y: MatrixXd const &

        """
        return _core.CLinearMean_checkDimensions(self, *args)


    def predictY(self, *args):
        """
        predictY(CLinearMean self) -> MatrixXd
        predictY(CLinearMean self, MatrixXd const & fixedEffects) -> MatrixXd

        Parameters
        ----------
        fixedEffects: MatrixXd const &

        """
        return _core.CLinearMean_predictY(self, *args)


    def setWeightsOLS(self, *args):
        """
        setWeightsOLS(CLinearMean self)
        setWeightsOLS(CLinearMean self, MatrixXd const & Y)

        Parameters
        ----------
        Y: MatrixXd const &

        """
        return _core.CLinearMean_setWeightsOLS(self, *args)


    def getNTargets(self):
        """
        getNTargets(CLinearMean self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CLinearMean const *

        """
        return _core.CLinearMean_getNTargets(self)

CLinearMean_swigregister = _core.CLinearMean_swigregister
CLinearMean_swigregister(CLinearMean)

class CSumLinear(ADataTerm):
    """Proxy of C++ limix::CSumLinear class."""

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

    def __init__(self):
        """__init__(limix::CSumLinear self) -> CSumLinear"""
        this = _core.new_CSumLinear()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CSumLinear
    __del__ = lambda self: None

    def aGetParams(self):
        """
        aGetParams(CSumLinear self)

        Parameters
        ----------
        self: limix::CSumLinear *

        """
        return _core.CSumLinear_aGetParams(self)


    def setParams(self, params):
        """
        setParams(CSumLinear self, MatrixXd const & params)

        Parameters
        ----------
        params: MatrixXd const &

        """
        return _core.CSumLinear_setParams(self, params)


    def evaluate(self):
        """
        evaluate(CSumLinear self)

        Parameters
        ----------
        self: limix::CSumLinear *

        """
        return _core.CSumLinear_evaluate(self)


    def aGradParams(self):
        """
        aGradParams(CSumLinear self)

        Parameters
        ----------
        self: limix::CSumLinear *

        """
        return _core.CSumLinear_aGradParams(self)


    def appendTerm(self, term):
        """
        appendTerm(CSumLinear self, limix::PLinearMean term)

        Parameters
        ----------
        term: limix::PLinearMean

        """
        return _core.CSumLinear_appendTerm(self, term)


    def getTerm(self, ind):
        """
        getTerm(CSumLinear self, limix::muint_t ind) -> limix::PLinearMean

        Parameters
        ----------
        ind: limix::muint_t

        """
        return _core.CSumLinear_getTerm(self, ind)


    def getNterms(self):
        """
        getNterms(CSumLinear self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CSumLinear const *

        """
        return _core.CSumLinear_getNterms(self)


    def getTerms(self):
        """
        getTerms(CSumLinear self) -> limix::VecLinearMean &

        Parameters
        ----------
        self: limix::CSumLinear *

        """
        return _core.CSumLinear_getTerms(self)


    def getRowsParams(self):
        """
        getRowsParams(CSumLinear self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CSumLinear *

        """
        return _core.CSumLinear_getRowsParams(self)


    def getColsParams(self):
        """
        getColsParams(CSumLinear self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CSumLinear *

        """
        return _core.CSumLinear_getColsParams(self)

CSumLinear_swigregister = _core.CSumLinear_swigregister
CSumLinear_swigregister(CSumLinear)

class CKroneckerMean(CLinearMean):
    """Proxy of C++ limix::CKroneckerMean class."""

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

    def __init__(self, *args):
        """
        __init__(limix::CKroneckerMean self) -> CKroneckerMean
        __init__(limix::CKroneckerMean self, MatrixXd & Y, MatrixXd & fixedEffects, MatrixXd & A) -> CKroneckerMean

        Parameters
        ----------
        Y: MatrixXd &
        fixedEffects: MatrixXd &
        A: MatrixXd &

        __init__(limix::CKroneckerMean self, MatrixXd & Y, MatrixXd & weights, MatrixXd & fixedEffects, MatrixXd & A) -> CKroneckerMean

        Parameters
        ----------
        Y: MatrixXd &
        weights: MatrixXd &
        fixedEffects: MatrixXd &
        A: MatrixXd &

        """
        this = _core.new_CKroneckerMean(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CKroneckerMean
    __del__ = lambda self: None

    def setA(self, A):
        """
        setA(CKroneckerMean self, MatrixXd const & A)

        Parameters
        ----------
        A: MatrixXd const &

        """
        return _core.CKroneckerMean_setA(self, A)


    def agetA(self):
        """
        agetA(CKroneckerMean self)

        Parameters
        ----------
        self: limix::CKroneckerMean *

        """
        return _core.CKroneckerMean_agetA(self)


    def evaluate(self):
        """
        evaluate(CKroneckerMean self)

        Parameters
        ----------
        self: limix::CKroneckerMean *

        """
        return _core.CKroneckerMean_evaluate(self)


    def aPredictY(self):
        """
        aPredictY(CKroneckerMean self)

        Parameters
        ----------
        self: limix::CKroneckerMean const *

        """
        return _core.CKroneckerMean_aPredictY(self)


    def aGradParams(self):
        """
        aGradParams(CKroneckerMean self)

        Parameters
        ----------
        self: limix::CKroneckerMean *

        """
        return _core.CKroneckerMean_aGradParams(self)


    def setWeightsOLS(self, *args):
        """
        setWeightsOLS(CKroneckerMean self, MatrixXd const & Y)

        Parameters
        ----------
        Y: MatrixXd const &

        setWeightsOLS(CKroneckerMean self)

        Parameters
        ----------
        self: limix::CKroneckerMean *

        """
        return _core.CKroneckerMean_setWeightsOLS(self, *args)


    def checkDimensions(self, Y, checkStrictWeights):
        """
        checkDimensions(CKroneckerMean self, MatrixXd const & Y, bool const checkStrictWeights)

        Parameters
        ----------
        Y: MatrixXd const &
        checkStrictWeights: bool const

        """
        return _core.CKroneckerMean_checkDimensions(self, Y, checkStrictWeights)


    def getName(self):
        """
        getName(CKroneckerMean self) -> std::string

        Parameters
        ----------
        self: limix::CKroneckerMean const *

        """
        return _core.CKroneckerMean_getName(self)


    def getDimFixedEffects(self):
        """
        getDimFixedEffects(CKroneckerMean self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CKroneckerMean const *

        """
        return _core.CKroneckerMean_getDimFixedEffects(self)


    def getColsParams(self):
        """
        getColsParams(CKroneckerMean self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CKroneckerMean *

        """
        return _core.CKroneckerMean_getColsParams(self)

CKroneckerMean_swigregister = _core.CKroneckerMean_swigregister
CKroneckerMean_swigregister(CKroneckerMean)

class CGPHyperParams(StringMatrixMap):
    """Proxy of C++ limix::CGPHyperParams class."""

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

    def __init__(self, *args):
        """
        __init__(limix::CGPHyperParams self) -> CGPHyperParams
        __init__(limix::CGPHyperParams self, CGPHyperParams _param) -> CGPHyperParams

        Parameters
        ----------
        _param: limix::CGPHyperParams const &

        """
        this = _core.new_CGPHyperParams(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CGPHyperParams
    __del__ = lambda self: None

    def getParamArray(self, *args):
        """
        getParamArray(CGPHyperParams self)
        getParamArray(CGPHyperParams self, CGPHyperParams mask)

        Parameters
        ----------
        mask: limix::CGPHyperParams const &

        """
        return _core.CGPHyperParams_getParamArray(self, *args)


    def setParamArray(self, *args):
        """
        setParamArray(CGPHyperParams self, VectorXd const & param)

        Parameters
        ----------
        param: VectorXd const &

        setParamArray(CGPHyperParams self, VectorXd const & param, CGPHyperParams mask)

        Parameters
        ----------
        param: VectorXd const &
        mask: limix::CGPHyperParams const &

        """
        return _core.CGPHyperParams_setParamArray(self, *args)


    def getNumberParams(self, *args):
        """
        getNumberParams(CGPHyperParams self) -> limix::muint_t
        getNumberParams(CGPHyperParams self, CGPHyperParams mask) -> limix::muint_t

        Parameters
        ----------
        mask: limix::CGPHyperParams const &

        """
        return _core.CGPHyperParams_getNumberParams(self, *args)


    def __setitem__(self, name, value):
        """
        __setitem__(CGPHyperParams self, std::string const & name, MatrixXd const & value)

        Parameters
        ----------
        name: std::string const &
        value: MatrixXd const &

        """
        return _core.CGPHyperParams___setitem__(self, name, value)


    def __getitem__(self, name):
        """
        __getitem__(CGPHyperParams self, std::string const & name)

        Parameters
        ----------
        name: std::string const &

        """
        return _core.CGPHyperParams___getitem__(self, name)


    def getNames(self):
        """
        getNames(CGPHyperParams self) -> StringVec

        Parameters
        ----------
        self: limix::CGPHyperParams const *

        """
        return _core.CGPHyperParams_getNames(self)


    def exists(self, name):
        """
        exists(CGPHyperParams self, std::string name) -> bool

        Parameters
        ----------
        name: std::string

        """
        return _core.CGPHyperParams_exists(self, name)


    def __str__(self):
        """
        __str__(CGPHyperParams self) -> std::string

        Parameters
        ----------
        self: limix::CGPHyperParams const *

        """
        return _core.CGPHyperParams___str__(self)

CGPHyperParams_swigregister = _core.CGPHyperParams_swigregister
CGPHyperParams_swigregister(CGPHyperParams)

class CGPCholCache(CParamObject):
    """Proxy of C++ limix::CGPCholCache class."""

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

    def __init__(self, gp):
        """
        __init__(limix::CGPCholCache self, CGPbase gp) -> CGPCholCache

        Parameters
        ----------
        gp: limix::CGPbase *

        """
        this = _core.new_CGPCholCache(gp)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CGPCholCache
    __del__ = lambda self: None

    def getCovar(self):
        """
        getCovar(CGPCholCache self) -> limix::PCovarianceFunctionCacheOld

        Parameters
        ----------
        self: limix::CGPCholCache *

        """
        return _core.CGPCholCache_getCovar(self)


    def setCovar(self, covar):
        """
        setCovar(CGPCholCache self, limix::PCovarianceFunction covar)

        Parameters
        ----------
        covar: limix::PCovarianceFunction

        """
        return _core.CGPCholCache_setCovar(self, covar)


    def rgetKEff(self):
        """
        rgetKEff(CGPCholCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPCholCache *

        """
        return _core.CGPCholCache_rgetKEff(self)


    def rgetKEffChol(self):
        """
        rgetKEffChol(CGPCholCache self) -> MatrixXdChol &

        Parameters
        ----------
        self: limix::CGPCholCache *

        """
        return _core.CGPCholCache_rgetKEffChol(self)


    def rgetKEffInv(self):
        """
        rgetKEffInv(CGPCholCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPCholCache *

        """
        return _core.CGPCholCache_rgetKEffInv(self)


    def rgetYeffective(self):
        """
        rgetYeffective(CGPCholCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPCholCache *

        """
        return _core.CGPCholCache_rgetYeffective(self)


    def rgetKEffInvY(self):
        """
        rgetKEffInvY(CGPCholCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPCholCache *

        """
        return _core.CGPCholCache_rgetKEffInvY(self)


    def getDKEffInv_KEffInvYYKinv(self):
        """
        getDKEffInv_KEffInvYYKinv(CGPCholCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPCholCache *

        """
        return _core.CGPCholCache_getDKEffInv_KEffInvYYKinv(self)

CGPCholCache_swigregister = _core.CGPCholCache_swigregister
CGPCholCache_swigregister(CGPCholCache)

class CGPbase(_object):
    """Proxy of C++ limix::CGPbase class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CGPbase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CGPbase, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(limix::CGPbase self, limix::PCovarianceFunction covar, limix::PLikelihood lik, limix::PDataTerm data) -> CGPbase

        Parameters
        ----------
        covar: limix::PCovarianceFunction
        lik: limix::PLikelihood
        data: limix::PDataTerm

        __init__(limix::CGPbase self, limix::PCovarianceFunction covar, limix::PLikelihood lik) -> CGPbase

        Parameters
        ----------
        covar: limix::PCovarianceFunction
        lik: limix::PLikelihood

        __init__(limix::CGPbase self, limix::PCovarianceFunction covar) -> CGPbase

        Parameters
        ----------
        covar: limix::PCovarianceFunction

        """
        this = _core.new_CGPbase(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CGPbase
    __del__ = lambda self: None

    def set_data(self, Y):
        """
        set_data(CGPbase self, MatrixXd & Y)

        Parameters
        ----------
        Y: MatrixXd &

        """
        return _core.CGPbase_set_data(self, Y)


    def setCovar(self, covar):
        """
        setCovar(CGPbase self, limix::PCovarianceFunction covar)

        Parameters
        ----------
        covar: limix::PCovarianceFunction

        """
        return _core.CGPbase_setCovar(self, covar)


    def setLik(self, lik):
        """
        setLik(CGPbase self, limix::PLikelihood lik)

        Parameters
        ----------
        lik: limix::PLikelihood

        """
        return _core.CGPbase_setLik(self, lik)


    def setDataTerm(self, data):
        """
        setDataTerm(CGPbase self, limix::PDataTerm data)

        Parameters
        ----------
        data: limix::PDataTerm

        """
        return _core.CGPbase_setDataTerm(self, data)


    def setLambda(self, arg2):
        """
        setLambda(CGPbase self, limix::mfloat_t arg2)

        Parameters
        ----------
        lambda: limix::mfloat_t

        """
        return _core.CGPbase_setLambda(self, arg2)


    def setLambdaG(self, arg2):
        """
        setLambdaG(CGPbase self, limix::mfloat_t arg2)

        Parameters
        ----------
        lambda: limix::mfloat_t

        """
        return _core.CGPbase_setLambdaG(self, arg2)


    def setLambdaN(self, arg2):
        """
        setLambdaN(CGPbase self, limix::mfloat_t arg2)

        Parameters
        ----------
        lambda: limix::mfloat_t

        """
        return _core.CGPbase_setLambdaN(self, arg2)


    def setParams(self, *args):
        """
        setParams(CGPbase self, CGPHyperParams hyperparams)

        Parameters
        ----------
        hyperparams: limix::CGPHyperParams const &

        setParams(CGPbase self, CGPHyperParams hyperparams, CGPHyperParams mask)

        Parameters
        ----------
        hyperparams: limix::CGPHyperParams const &
        mask: limix::CGPHyperParams const &

        """
        return _core.CGPbase_setParams(self, *args)


    def getParams(self):
        """
        getParams(CGPbase self) -> CGPHyperParams

        Parameters
        ----------
        self: limix::CGPbase const *

        """
        return _core.CGPbase_getParams(self)


    def setParamArray(self, *args):
        """
        setParamArray(CGPbase self, VectorXd const & hyperparams)

        Parameters
        ----------
        hyperparams: VectorXd const &

        setParamArray(CGPbase self, VectorXd const & param, CGPHyperParams mask)

        Parameters
        ----------
        param: VectorXd const &
        mask: limix::CGPHyperParams const &

        """
        return _core.CGPbase_setParamArray(self, *args)


    def getParamArray(self):
        """
        getParamArray(CGPbase self)

        Parameters
        ----------
        self: limix::CGPbase const *

        """
        return _core.CGPbase_getParamArray(self)


    def getParamBounds(self, upper):
        """
        getParamBounds(CGPbase self, bool upper) -> CGPHyperParams

        Parameters
        ----------
        upper: bool

        """
        return _core.CGPbase_getParamBounds(self, upper)


    def getParamMask(self):
        """
        getParamMask(CGPbase self) -> CGPHyperParams

        Parameters
        ----------
        self: limix::CGPbase const *

        """
        return _core.CGPbase_getParamMask(self)


    def getY(self):
        """
        getY(CGPbase self)

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_getY(self)


    def setY(self, Y):
        """
        setY(CGPbase self, MatrixXd const & Y)

        Parameters
        ----------
        Y: MatrixXd const &

        """
        return _core.CGPbase_setY(self, Y)


    def getX(self):
        """
        getX(CGPbase self)

        Parameters
        ----------
        self: limix::CGPbase const *

        """
        return _core.CGPbase_getX(self)


    def setX(self, X):
        """
        setX(CGPbase self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.CGPbase_setX(self, X)


    def getNumberSamples(self):
        """
        getNumberSamples(CGPbase self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_getNumberSamples(self)


    def getNumberDimension(self):
        """
        getNumberDimension(CGPbase self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_getNumberDimension(self)


    def getCache(self):
        """
        getCache(CGPbase self) -> limix::PGPCholCache

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_getCache(self)


    def getCovar(self):
        """
        getCovar(CGPbase self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_getCovar(self)


    def getLik(self):
        """
        getLik(CGPbase self) -> limix::PLikelihood

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_getLik(self)


    def getDataTerm(self):
        """
        getDataTerm(CGPbase self) -> limix::PDataTerm

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_getDataTerm(self)


    def agetKEffInvYCache(self):
        """
        agetKEffInvYCache(CGPbase self)

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_agetKEffInvYCache(self)


    def LML(self, *args):
        """
        LML(CGPbase self) -> limix::mfloat_t
        LML(CGPbase self, CGPHyperParams params) -> limix::mfloat_t

        Parameters
        ----------
        params: limix::CGPHyperParams const &

        LML(CGPbase self, VectorXd const & params) -> limix::mfloat_t

        Parameters
        ----------
        params: VectorXd const &

        """
        return _core.CGPbase_LML(self, *args)


    def LMLgrad(self, *args):
        """
        LMLgrad(CGPbase self) -> CGPHyperParams
        LMLgrad(CGPbase self, CGPHyperParams params) -> CGPHyperParams

        Parameters
        ----------
        params: limix::CGPHyperParams const &

        LMLgrad(CGPbase self, VectorXd const & paramArray) -> CGPHyperParams

        Parameters
        ----------
        paramArray: VectorXd const &

        """
        return _core.CGPbase_LMLgrad(self, *args)


    def aLMLgrad(self, *args):
        """
        aLMLgrad(CGPbase self)
        aLMLgrad(CGPbase self, CGPHyperParams params)

        Parameters
        ----------
        params: limix::CGPHyperParams const &

        aLMLgrad(CGPbase self, VectorXd const & paramArray)

        Parameters
        ----------
        paramArray: VectorXd const &

        """
        return _core.CGPbase_aLMLgrad(self, *args)


    def LMLgrad_covar(self):
        """
        LMLgrad_covar(CGPbase self)

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_LMLgrad_covar(self)


    def LMLgrad_lik(self):
        """
        LMLgrad_lik(CGPbase self)

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_LMLgrad_lik(self)


    def aLMLgrad_X(self):
        """
        aLMLgrad_X(CGPbase self)

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_aLMLgrad_X(self)


    def aLMLgrad_dataTerm(self):
        """
        aLMLgrad_dataTerm(CGPbase self)

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_aLMLgrad_dataTerm(self)


    def LMLhess(self, vecLabels):
        """
        LMLhess(CGPbase self, StringVec vecLabels)

        Parameters
        ----------
        vecLabels: limix::stringVec

        """
        return _core.CGPbase_LMLhess(self, vecLabels)


    def LMLhess_covar(self):
        """
        LMLhess_covar(CGPbase self)

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_LMLhess_covar(self)


    def LMLhess_lik(self):
        """
        LMLhess_lik(CGPbase self)

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_LMLhess_lik(self)


    def LMLhess_covarlik(self):
        """
        LMLhess_covarlik(CGPbase self)

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_LMLhess_covarlik(self)


    def getCov_laplace(self, vecLabels):
        """
        getCov_laplace(CGPbase self, StringVec vecLabels)

        Parameters
        ----------
        vecLabels: limix::stringVec

        """
        return _core.CGPbase_getCov_laplace(self, vecLabels)


    def getStd_laplace(self):
        """
        getStd_laplace(CGPbase self) -> CGPHyperParams

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_getStd_laplace(self)


    def predictMean(self, Xstar):
        """
        predictMean(CGPbase self, MatrixXd const & Xstar)

        Parameters
        ----------
        Xstar: MatrixXd const &

        """
        return _core.CGPbase_predictMean(self, Xstar)


    def predictVar(self, Xstar):
        """
        predictVar(CGPbase self, MatrixXd const & Xstar)

        Parameters
        ----------
        Xstar: MatrixXd const &

        """
        return _core.CGPbase_predictVar(self, Xstar)


    def LMLgrad_X(self):
        """
        LMLgrad_X(CGPbase self) -> MatrixXd

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_LMLgrad_X(self)


    def LMLgrad_dataTerm(self):
        """
        LMLgrad_dataTerm(CGPbase self) -> MatrixXd

        Parameters
        ----------
        self: limix::CGPbase *

        """
        return _core.CGPbase_LMLgrad_dataTerm(self)


    def LMLgrad_num(gp, i):
        """
        LMLgrad_num(CGPbase gp, limix::muint_t const i) -> double

        Parameters
        ----------
        gp: limix::CGPbase &
        i: limix::muint_t const

        """
        return _core.CGPbase_LMLgrad_num(gp, i)

    if _newclass:
        LMLgrad_num = staticmethod(LMLgrad_num)
    __swig_getmethods__["LMLgrad_num"] = lambda x: LMLgrad_num

    def LMLhess_num(gp, i, j):
        """
        LMLhess_num(CGPbase gp, limix::muint_t const i, limix::muint_t const j) -> double

        Parameters
        ----------
        gp: limix::CGPbase &
        i: limix::muint_t const
        j: limix::muint_t const

        """
        return _core.CGPbase_LMLhess_num(gp, i, j)

    if _newclass:
        LMLhess_num = staticmethod(LMLhess_num)
    __swig_getmethods__["LMLhess_num"] = lambda x: LMLhess_num
CGPbase_swigregister = _core.CGPbase_swigregister
CGPbase_swigregister(CGPbase)

def CGPbase_LMLgrad_num(gp, i):
    """
    CGPbase_LMLgrad_num(CGPbase gp, limix::muint_t const i) -> double

    Parameters
    ----------
    gp: limix::CGPbase &
    i: limix::muint_t const

    """
    return _core.CGPbase_LMLgrad_num(gp, i)

def CGPbase_LMLhess_num(gp, i, j):
    """
    CGPbase_LMLhess_num(CGPbase gp, limix::muint_t const i, limix::muint_t const j) -> double

    Parameters
    ----------
    gp: limix::CGPbase &
    i: limix::muint_t const
    j: limix::muint_t const

    """
    return _core.CGPbase_LMLhess_num(gp, i, j)

class CGPKroneckerCache(CParamObject):
    """Proxy of C++ limix::CGPKroneckerCache class."""

    __swig_setmethods__ = {}
    for _s in [CParamObject]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CGPKroneckerCache, name, value)
    __swig_getmethods__ = {}
    for _s in [CParamObject]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CGPKroneckerCache, name)
    __repr__ = _swig_repr
    __swig_setmethods__["covar_r"] = _core.CGPKroneckerCache_covar_r_set
    __swig_getmethods__["covar_r"] = _core.CGPKroneckerCache_covar_r_get
    if _newclass:
        covar_r = _swig_property(_core.CGPKroneckerCache_covar_r_get, _core.CGPKroneckerCache_covar_r_set)
    __swig_setmethods__["covar_c"] = _core.CGPKroneckerCache_covar_c_set
    __swig_getmethods__["covar_c"] = _core.CGPKroneckerCache_covar_c_get
    if _newclass:
        covar_c = _swig_property(_core.CGPKroneckerCache_covar_c_get, _core.CGPKroneckerCache_covar_c_set)

    def __init__(self, gp):
        """
        __init__(limix::CGPKroneckerCache self, CGPkronecker gp) -> CGPKroneckerCache

        Parameters
        ----------
        gp: limix::CGPkronecker *

        """
        this = _core.new_CGPKroneckerCache(gp)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CGPKroneckerCache
    __del__ = lambda self: None

    def rgetYrot(self):
        """
        rgetYrot(CGPKroneckerCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPKroneckerCache *

        """
        return _core.CGPKroneckerCache_rgetYrot(self)


    def rgetSi(self):
        """
        rgetSi(CGPKroneckerCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPKroneckerCache *

        """
        return _core.CGPKroneckerCache_rgetSi(self)


    def rgetYSi(self):
        """
        rgetYSi(CGPKroneckerCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPKroneckerCache *

        """
        return _core.CGPKroneckerCache_rgetYSi(self)


    def rgetKinvY(self):
        """
        rgetKinvY(CGPKroneckerCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPKroneckerCache *

        """
        return _core.CGPKroneckerCache_rgetKinvY(self)


    def agetSi(self):
        """
        agetSi(CGPKroneckerCache self)

        Parameters
        ----------
        self: limix::CGPKroneckerCache *

        """
        return _core.CGPKroneckerCache_agetSi(self)


    def agetYSi(self):
        """
        agetYSi(CGPKroneckerCache self)

        Parameters
        ----------
        self: limix::CGPKroneckerCache *

        """
        return _core.CGPKroneckerCache_agetYSi(self)


    def agetYrot(self):
        """
        agetYrot(CGPKroneckerCache self)

        Parameters
        ----------
        self: limix::CGPKroneckerCache *

        """
        return _core.CGPKroneckerCache_agetYrot(self)

CGPKroneckerCache_swigregister = _core.CGPKroneckerCache_swigregister
CGPKroneckerCache_swigregister(CGPKroneckerCache)

class CGPkronecker(CGPbase):
    """Proxy of C++ limix::CGPkronecker class."""

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

    def __init__(self, *args):
        """
        __init__(limix::CGPkronecker self, limix::PCovarianceFunction covar_r, limix::PCovarianceFunction covar_c, limix::PLikelihood lik, limix::PDataTerm mean) -> CGPkronecker

        Parameters
        ----------
        covar_r: limix::PCovarianceFunction
        covar_c: limix::PCovarianceFunction
        lik: limix::PLikelihood
        mean: limix::PDataTerm

        __init__(limix::CGPkronecker self, limix::PCovarianceFunction covar_r, limix::PCovarianceFunction covar_c, limix::PLikelihood lik) -> CGPkronecker

        Parameters
        ----------
        covar_r: limix::PCovarianceFunction
        covar_c: limix::PCovarianceFunction
        lik: limix::PLikelihood

        __init__(limix::CGPkronecker self, limix::PCovarianceFunction covar_r, limix::PCovarianceFunction covar_c) -> CGPkronecker

        Parameters
        ----------
        covar_r: limix::PCovarianceFunction
        covar_c: limix::PCovarianceFunction

        """
        this = _core.new_CGPkronecker(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CGPkronecker
    __del__ = lambda self: None

    def setX_r(self, X):
        """
        setX_r(CGPkronecker self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.CGPkronecker_setX_r(self, X)


    def setX_c(self, X):
        """
        setX_c(CGPkronecker self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.CGPkronecker_setX_c(self, X)


    def setY(self, Y):
        """
        setY(CGPkronecker self, MatrixXd const & Y)

        Parameters
        ----------
        Y: MatrixXd const &

        """
        return _core.CGPkronecker_setY(self, Y)


    def setCovar_r(self, covar):
        """
        setCovar_r(CGPkronecker self, limix::PCovarianceFunction covar)

        Parameters
        ----------
        covar: limix::PCovarianceFunction

        """
        return _core.CGPkronecker_setCovar_r(self, covar)


    def setCovar_c(self, covar):
        """
        setCovar_c(CGPkronecker self, limix::PCovarianceFunction covar)

        Parameters
        ----------
        covar: limix::PCovarianceFunction

        """
        return _core.CGPkronecker_setCovar_c(self, covar)


    def LML(self, *args):
        """
        LML(CGPkronecker self) -> limix::mfloat_t
        LML(CGPkronecker self, CGPHyperParams params) -> limix::mfloat_t

        Parameters
        ----------
        params: limix::CGPHyperParams const &

        LML(CGPkronecker self, VectorXd const & params) -> limix::mfloat_t

        Parameters
        ----------
        params: VectorXd const &

        """
        return _core.CGPkronecker_LML(self, *args)


    def getLik(self):
        """
        getLik(CGPkronecker self) -> limix::PLikNormalSVD

        Parameters
        ----------
        self: limix::CGPkronecker *

        """
        return _core.CGPkronecker_getLik(self)


    def predictMean(self, Xstar_r, Xstar_c):
        """
        predictMean(CGPkronecker self, MatrixXd const & Xstar_r, MatrixXd const & Xstar_c)

        Parameters
        ----------
        Xstar_r: MatrixXd const &
        Xstar_c: MatrixXd const &

        """
        return _core.CGPkronecker_predictMean(self, Xstar_r, Xstar_c)


    def predictVar(self, Xstar_r, Xstar_c):
        """
        predictVar(CGPkronecker self, MatrixXd const & Xstar_r, MatrixXd const & Xstar_c)

        Parameters
        ----------
        Xstar_r: MatrixXd const &
        Xstar_c: MatrixXd const &

        """
        return _core.CGPkronecker_predictVar(self, Xstar_r, Xstar_c)


    def LMLgrad(self):
        """
        LMLgrad(CGPkronecker self) -> CGPHyperParams

        Parameters
        ----------
        self: limix::CGPkronecker *

        """
        return _core.CGPkronecker_LMLgrad(self)


    def LMLgrad_covar(self, columns):
        """
        LMLgrad_covar(CGPkronecker self, bool columns)

        Parameters
        ----------
        columns: bool

        """
        return _core.CGPkronecker_LMLgrad_covar(self, columns)


    def aLMLgrad_covar_r(self):
        """
        aLMLgrad_covar_r(CGPkronecker self)

        Parameters
        ----------
        self: limix::CGPkronecker *

        """
        return _core.CGPkronecker_aLMLgrad_covar_r(self)


    def aLMLgrad_covar_c(self):
        """
        aLMLgrad_covar_c(CGPkronecker self)

        Parameters
        ----------
        self: limix::CGPkronecker *

        """
        return _core.CGPkronecker_aLMLgrad_covar_c(self)


    def LMLgrad_lik(self):
        """
        LMLgrad_lik(CGPkronecker self)

        Parameters
        ----------
        self: limix::CGPkronecker *

        """
        return _core.CGPkronecker_LMLgrad_lik(self)


    def aLMLgrad_X_r(self):
        """
        aLMLgrad_X_r(CGPkronecker self)

        Parameters
        ----------
        self: limix::CGPkronecker *

        """
        return _core.CGPkronecker_aLMLgrad_X_r(self)


    def aLMLgrad_X_c(self):
        """
        aLMLgrad_X_c(CGPkronecker self)

        Parameters
        ----------
        self: limix::CGPkronecker *

        """
        return _core.CGPkronecker_aLMLgrad_X_c(self)


    def aLMLgrad_dataTerm(self):
        """
        aLMLgrad_dataTerm(CGPkronecker self)

        Parameters
        ----------
        self: limix::CGPkronecker *

        """
        return _core.CGPkronecker_aLMLgrad_dataTerm(self)


    def getCache(self):
        """
        getCache(CGPkronecker self) -> limix::PGPKroneckerCache

        Parameters
        ----------
        self: limix::CGPkronecker *

        """
        return _core.CGPkronecker_getCache(self)


    def getCovarC(self):
        """
        getCovarC(CGPkronecker self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::CGPkronecker const *

        """
        return _core.CGPkronecker_getCovarC(self)


    def getCovarR(self):
        """
        getCovarR(CGPkronecker self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::CGPkronecker const *

        """
        return _core.CGPkronecker_getCovarR(self)


    def getGplvmDimensionsC(self):
        """
        getGplvmDimensionsC(CGPkronecker self) -> VectorXi

        Parameters
        ----------
        self: limix::CGPkronecker const *

        """
        return _core.CGPkronecker_getGplvmDimensionsC(self)


    def getGplvmDimensionsR(self):
        """
        getGplvmDimensionsR(CGPkronecker self) -> VectorXi

        Parameters
        ----------
        self: limix::CGPkronecker const *

        """
        return _core.CGPkronecker_getGplvmDimensionsR(self)


    def setGplvmDimensionsC(self, gplvmDimensionsC):
        """
        setGplvmDimensionsC(CGPkronecker self, VectorXi gplvmDimensionsC)

        Parameters
        ----------
        gplvmDimensionsC: VectorXi

        """
        return _core.CGPkronecker_setGplvmDimensionsC(self, gplvmDimensionsC)


    def setGplvmDimensionsR(self, gplvmDimensionsR):
        """
        setGplvmDimensionsR(CGPkronecker self, VectorXi gplvmDimensionsR)

        Parameters
        ----------
        gplvmDimensionsR: VectorXi

        """
        return _core.CGPkronecker_setGplvmDimensionsR(self, gplvmDimensionsR)

CGPkronecker_swigregister = _core.CGPkronecker_swigregister
CGPkronecker_swigregister(CGPkronecker)

class CGPkronSumCache(CParamObject):
    """Proxy of C++ limix::CGPkronSumCache class."""

    __swig_setmethods__ = {}
    for _s in [CParamObject]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CGPkronSumCache, name, value)
    __swig_getmethods__ = {}
    for _s in [CParamObject]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CGPkronSumCache, name)
    __repr__ = _swig_repr
    __swig_setmethods__["covarc1"] = _core.CGPkronSumCache_covarc1_set
    __swig_getmethods__["covarc1"] = _core.CGPkronSumCache_covarc1_get
    if _newclass:
        covarc1 = _swig_property(_core.CGPkronSumCache_covarc1_get, _core.CGPkronSumCache_covarc1_set)
    __swig_setmethods__["covarc2"] = _core.CGPkronSumCache_covarc2_set
    __swig_getmethods__["covarc2"] = _core.CGPkronSumCache_covarc2_get
    if _newclass:
        covarc2 = _swig_property(_core.CGPkronSumCache_covarc2_get, _core.CGPkronSumCache_covarc2_set)
    __swig_setmethods__["covarr1"] = _core.CGPkronSumCache_covarr1_set
    __swig_getmethods__["covarr1"] = _core.CGPkronSumCache_covarr1_get
    if _newclass:
        covarr1 = _swig_property(_core.CGPkronSumCache_covarr1_get, _core.CGPkronSumCache_covarr1_set)
    __swig_setmethods__["covarr2"] = _core.CGPkronSumCache_covarr2_set
    __swig_getmethods__["covarr2"] = _core.CGPkronSumCache_covarr2_get
    if _newclass:
        covarr2 = _swig_property(_core.CGPkronSumCache_covarr2_get, _core.CGPkronSumCache_covarr2_set)

    def __init__(self, gp):
        """
        __init__(limix::CGPkronSumCache self, CGPkronSum gp) -> CGPkronSumCache

        Parameters
        ----------
        gp: limix::CGPkronSum *

        """
        this = _core.new_CGPkronSumCache(gp)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CGPkronSumCache
    __del__ = lambda self: None

    def rgetSsigma(self):
        """
        rgetSsigma(CGPkronSumCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_rgetSsigma(self)


    def rgetScstar(self):
        """
        rgetScstar(CGPkronSumCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_rgetScstar(self)


    def rgetUcstar(self):
        """
        rgetUcstar(CGPkronSumCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_rgetUcstar(self)


    def rgetLambdac(self):
        """
        rgetLambdac(CGPkronSumCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_rgetLambdac(self)


    def rgetSomega(self):
        """
        rgetSomega(CGPkronSumCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_rgetSomega(self)


    def rgetSrstar(self):
        """
        rgetSrstar(CGPkronSumCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_rgetSrstar(self)


    def rgetUrstar(self):
        """
        rgetUrstar(CGPkronSumCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_rgetUrstar(self)


    def rgetLambdar(self):
        """
        rgetLambdar(CGPkronSumCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_rgetLambdar(self)


    def rgetD(self):
        """
        rgetD(CGPkronSumCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_rgetD(self)


    def rgetYrotPart(self):
        """
        rgetYrotPart(CGPkronSumCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_rgetYrotPart(self)


    def rgetYrot(self):
        """
        rgetYrot(CGPkronSumCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_rgetYrot(self)


    def rgetYtilde(self):
        """
        rgetYtilde(CGPkronSumCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_rgetYtilde(self)


    def argetSsigma(self):
        """
        argetSsigma(CGPkronSumCache self)

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_argetSsigma(self)


    def argetScstar(self):
        """
        argetScstar(CGPkronSumCache self)

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_argetScstar(self)


    def argetUcstar(self):
        """
        argetUcstar(CGPkronSumCache self)

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_argetUcstar(self)


    def argetLambdac(self):
        """
        argetLambdac(CGPkronSumCache self)

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_argetLambdac(self)


    def argetSomega(self):
        """
        argetSomega(CGPkronSumCache self)

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_argetSomega(self)


    def argetSrstar(self):
        """
        argetSrstar(CGPkronSumCache self)

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_argetSrstar(self)


    def argetUrstar(self):
        """
        argetUrstar(CGPkronSumCache self)

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_argetUrstar(self)


    def argetLambdar(self):
        """
        argetLambdar(CGPkronSumCache self)

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_argetLambdar(self)


    def argetD(self):
        """
        argetD(CGPkronSumCache self)

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_argetD(self)


    def argetYrotPart(self):
        """
        argetYrotPart(CGPkronSumCache self)

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_argetYrotPart(self)


    def argetYrot(self):
        """
        argetYrot(CGPkronSumCache self)

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_argetYrot(self)


    def argetYtilde(self):
        """
        argetYtilde(CGPkronSumCache self)

        Parameters
        ----------
        self: limix::CGPkronSumCache *

        """
        return _core.CGPkronSumCache_argetYtilde(self)

CGPkronSumCache_swigregister = _core.CGPkronSumCache_swigregister
CGPkronSumCache_swigregister(CGPkronSumCache)

class CGPkronSum(CGPbase):
    """Proxy of C++ limix::CGPkronSum class."""

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

    def __init__(self, Y, covarr1, covarc1, covarr2, covarc2, lik, dataTerm):
        """
        __init__(limix::CGPkronSum self, MatrixXd const & Y, limix::PCovarianceFunction covarr1, limix::PCovarianceFunction covarc1, limix::PCovarianceFunction covarr2, limix::PCovarianceFunction covarc2, limix::PLikelihood lik, limix::PDataTerm dataTerm) -> CGPkronSum

        Parameters
        ----------
        Y: MatrixXd const &
        covarr1: limix::PCovarianceFunction
        covarc1: limix::PCovarianceFunction
        covarr2: limix::PCovarianceFunction
        covarc2: limix::PCovarianceFunction
        lik: limix::PLikelihood
        dataTerm: limix::PDataTerm

        """
        this = _core.new_CGPkronSum(Y, covarr1, covarc1, covarr2, covarc2, lik, dataTerm)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CGPkronSum
    __del__ = lambda self: None

    def setLambda(self, arg2):
        """
        setLambda(CGPkronSum self, limix::mfloat_t arg2)

        Parameters
        ----------
        lambda: limix::mfloat_t

        """
        return _core.CGPkronSum_setLambda(self, arg2)


    def setLambdaG(self, arg2):
        """
        setLambdaG(CGPkronSum self, limix::mfloat_t arg2)

        Parameters
        ----------
        lambda: limix::mfloat_t

        """
        return _core.CGPkronSum_setLambdaG(self, arg2)


    def setLambdaN(self, arg2):
        """
        setLambdaN(CGPkronSum self, limix::mfloat_t arg2)

        Parameters
        ----------
        lambda: limix::mfloat_t

        """
        return _core.CGPkronSum_setLambdaN(self, arg2)


    def getParamBounds(self, upper):
        """
        getParamBounds(CGPkronSum self, bool upper) -> CGPHyperParams

        Parameters
        ----------
        upper: bool

        """
        return _core.CGPkronSum_getParamBounds(self, upper)


    def getParamMask(self):
        """
        getParamMask(CGPkronSum self) -> CGPHyperParams

        Parameters
        ----------
        self: limix::CGPkronSum const *

        """
        return _core.CGPkronSum_getParamMask(self)


    def getCovarr1(self):
        """
        getCovarr1(CGPkronSum self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getCovarr1(self)


    def getCovarr2(self):
        """
        getCovarr2(CGPkronSum self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getCovarr2(self)


    def getCovarc1(self):
        """
        getCovarc1(CGPkronSum self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getCovarc1(self)


    def getCovarc2(self):
        """
        getCovarc2(CGPkronSum self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getCovarc2(self)


    def agetKEffInvYCache(self):
        """
        agetKEffInvYCache(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetKEffInvYCache(self)


    def LML(self):
        """
        LML(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_LML(self)


    def LMLgrad(self):
        """
        LMLgrad(CGPkronSum self) -> CGPHyperParams

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_LMLgrad(self)


    def aLMLgrad_covarc1(self):
        """
        aLMLgrad_covarc1(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_aLMLgrad_covarc1(self)


    def aLMLgrad_covarc2(self):
        """
        aLMLgrad_covarc2(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_aLMLgrad_covarc2(self)


    def aLMLgrad_covarr1(self):
        """
        aLMLgrad_covarr1(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_aLMLgrad_covarr1(self)


    def aLMLgrad_covarr2(self):
        """
        aLMLgrad_covarr2(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_aLMLgrad_covarr2(self)


    def aLMLgrad_dataTerm(self):
        """
        aLMLgrad_dataTerm(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_aLMLgrad_dataTerm(self)


    def aLMLhess_c1c1(self):
        """
        aLMLhess_c1c1(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_aLMLhess_c1c1(self)


    def agetSc(self):
        """
        agetSc(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetSc(self)


    def agetUc(self):
        """
        agetUc(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetUc(self)


    def agetSr(self):
        """
        agetSr(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetSr(self)


    def agetUr(self):
        """
        agetUr(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetUr(self)


    def agetSsigma(self):
        """
        agetSsigma(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetSsigma(self)


    def agetUsigma(self):
        """
        agetUsigma(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetUsigma(self)


    def agetSomega(self):
        """
        agetSomega(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetSomega(self)


    def agetUomega(self):
        """
        agetUomega(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetUomega(self)


    def agetScstar(self):
        """
        agetScstar(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetScstar(self)


    def agetUcstar(self):
        """
        agetUcstar(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetUcstar(self)


    def agetSrstar(self):
        """
        agetSrstar(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetSrstar(self)


    def agetUrstar(self):
        """
        agetUrstar(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetUrstar(self)


    def agetLambdac(self):
        """
        agetLambdac(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetLambdac(self)


    def agetLambdar(self):
        """
        agetLambdar(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetLambdar(self)


    def agetYrotPart(self):
        """
        agetYrotPart(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetYrotPart(self)


    def agetYrot(self):
        """
        agetYrot(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetYrot(self)


    def agetCstar(self):
        """
        agetCstar(CGPkronSum self)

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_agetCstar(self)


    def getN(self):
        """
        getN(CGPkronSum self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getN(self)


    def getP(self):
        """
        getP(CGPkronSum self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getP(self)


    def setDebugMode(self, debug):
        """
        setDebugMode(CGPkronSum self, bool debug)

        Parameters
        ----------
        debug: bool

        """
        return _core.CGPkronSum_setDebugMode(self, debug)


    def getRtSVDcols(self):
        """
        getRtSVDcols(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtSVDcols(self)


    def getRtSVDrows(self):
        """
        getRtSVDrows(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtSVDrows(self)


    def getRtLambdac(self):
        """
        getRtLambdac(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtLambdac(self)


    def getRtLambdar(self):
        """
        getRtLambdar(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtLambdar(self)


    def getRtD(self):
        """
        getRtD(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtD(self)


    def getRtYrotPart(self):
        """
        getRtYrotPart(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtYrotPart(self)


    def getRtYrot(self):
        """
        getRtYrot(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtYrot(self)


    def getRtYtilde(self):
        """
        getRtYtilde(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtYtilde(self)


    def getRtCC1part1a(self):
        """
        getRtCC1part1a(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtCC1part1a(self)


    def getRtCC1part1b(self):
        """
        getRtCC1part1b(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtCC1part1b(self)


    def getRtCC1part1c(self):
        """
        getRtCC1part1c(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtCC1part1c(self)


    def getRtCC1part1d(self):
        """
        getRtCC1part1d(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtCC1part1d(self)


    def getRtCC1part1e(self):
        """
        getRtCC1part1e(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtCC1part1e(self)


    def getRtCC1part1f(self):
        """
        getRtCC1part1f(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtCC1part1f(self)


    def getRtCC1part2(self):
        """
        getRtCC1part2(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtCC1part2(self)


    def getRtCC2part1(self):
        """
        getRtCC2part1(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtCC2part1(self)


    def getRtCC2part2(self):
        """
        getRtCC2part2(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtCC2part2(self)


    def getRtCR1part1a(self):
        """
        getRtCR1part1a(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtCR1part1a(self)


    def getRtCR1part1b(self):
        """
        getRtCR1part1b(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtCR1part1b(self)


    def getRtCR1part2(self):
        """
        getRtCR1part2(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtCR1part2(self)


    def getRtCR2part1a(self):
        """
        getRtCR2part1a(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtCR2part1a(self)


    def getRtCR2part1b(self):
        """
        getRtCR2part1b(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtCR2part1b(self)


    def getRtCR2part2(self):
        """
        getRtCR2part2(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtCR2part2(self)


    def getRtLMLgradCovar(self):
        """
        getRtLMLgradCovar(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtLMLgradCovar(self)


    def getRtLMLgradDataTerm(self):
        """
        getRtLMLgradDataTerm(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtLMLgradDataTerm(self)


    def getIs_it(self):
        """
        getIs_it(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getIs_it(self)


    def getRtGrad(self):
        """
        getRtGrad(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtGrad(self)


    def getRtLML1a(self):
        """
        getRtLML1a(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtLML1a(self)


    def getRtLML1b(self):
        """
        getRtLML1b(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtLML1b(self)


    def getRtLML1c(self):
        """
        getRtLML1c(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtLML1c(self)


    def getRtLML1d(self):
        """
        getRtLML1d(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtLML1d(self)


    def getRtLML1e(self):
        """
        getRtLML1e(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtLML1e(self)


    def getRtLML2(self):
        """
        getRtLML2(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtLML2(self)


    def getRtLML3(self):
        """
        getRtLML3(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtLML3(self)


    def getRtLML4(self):
        """
        getRtLML4(CGPkronSum self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CGPkronSum *

        """
        return _core.CGPkronSum_getRtLML4(self)

CGPkronSum_swigregister = _core.CGPkronSum_swigregister
CGPkronSum_swigregister(CGPkronSum)

class CGPSumCache(CParamObject):
    """Proxy of C++ limix::CGPSumCache class."""

    __swig_setmethods__ = {}
    for _s in [CParamObject]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CGPSumCache, name, value)
    __swig_getmethods__ = {}
    for _s in [CParamObject]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CGPSumCache, name)
    __repr__ = _swig_repr
    __swig_setmethods__["covar1"] = _core.CGPSumCache_covar1_set
    __swig_getmethods__["covar1"] = _core.CGPSumCache_covar1_get
    if _newclass:
        covar1 = _swig_property(_core.CGPSumCache_covar1_get, _core.CGPSumCache_covar1_set)
    __swig_setmethods__["covar2"] = _core.CGPSumCache_covar2_set
    __swig_getmethods__["covar2"] = _core.CGPSumCache_covar2_get
    if _newclass:
        covar2 = _swig_property(_core.CGPSumCache_covar2_get, _core.CGPSumCache_covar2_set)

    def __init__(self, gp):
        """
        __init__(limix::CGPSumCache self, CGPSum gp) -> CGPSumCache

        Parameters
        ----------
        gp: limix::CGPSum *

        """
        this = _core.new_CGPSumCache(gp)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CGPSumCache
    __del__ = lambda self: None

    def rgetScstar(self):
        """
        rgetScstar(CGPSumCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPSumCache *

        """
        return _core.CGPSumCache_rgetScstar(self)


    def rgetUcstar(self):
        """
        rgetUcstar(CGPSumCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPSumCache *

        """
        return _core.CGPSumCache_rgetUcstar(self)


    def rgetLambda(self):
        """
        rgetLambda(CGPSumCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPSumCache *

        """
        return _core.CGPSumCache_rgetLambda(self)


    def rgetYrot(self):
        """
        rgetYrot(CGPSumCache self) -> MatrixXd &

        Parameters
        ----------
        self: limix::CGPSumCache *

        """
        return _core.CGPSumCache_rgetYrot(self)


    def argetScstar(self):
        """
        argetScstar(CGPSumCache self)

        Parameters
        ----------
        self: limix::CGPSumCache *

        """
        return _core.CGPSumCache_argetScstar(self)


    def argetUcstar(self):
        """
        argetUcstar(CGPSumCache self)

        Parameters
        ----------
        self: limix::CGPSumCache *

        """
        return _core.CGPSumCache_argetUcstar(self)


    def argetLambda(self):
        """
        argetLambda(CGPSumCache self)

        Parameters
        ----------
        self: limix::CGPSumCache *

        """
        return _core.CGPSumCache_argetLambda(self)


    def argetYrot(self):
        """
        argetYrot(CGPSumCache self)

        Parameters
        ----------
        self: limix::CGPSumCache *

        """
        return _core.CGPSumCache_argetYrot(self)

CGPSumCache_swigregister = _core.CGPSumCache_swigregister
CGPSumCache_swigregister(CGPSumCache)

class CGPSum(CGPbase):
    """Proxy of C++ limix::CGPSum class."""

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

    def __init__(self, Y, covar1, covar2, lik, dataTerm):
        """
        __init__(limix::CGPSum self, MatrixXd const & Y, limix::PCovarianceFunction covar1, limix::PCovarianceFunction covar2, limix::PLikelihood lik, limix::PDataTerm dataTerm) -> CGPSum

        Parameters
        ----------
        Y: MatrixXd const &
        covar1: limix::PCovarianceFunction
        covar2: limix::PCovarianceFunction
        lik: limix::PLikelihood
        dataTerm: limix::PDataTerm

        """
        this = _core.new_CGPSum(Y, covar1, covar2, lik, dataTerm)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CGPSum
    __del__ = lambda self: None

    def setX1(self, X):
        """
        setX1(CGPSum self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.CGPSum_setX1(self, X)


    def setX2(self, X):
        """
        setX2(CGPSum self, limix::CovarInput const & X)

        Parameters
        ----------
        X: limix::CovarInput const &

        """
        return _core.CGPSum_setX2(self, X)


    def setY(self, Y):
        """
        setY(CGPSum self, MatrixXd const & Y)

        Parameters
        ----------
        Y: MatrixXd const &

        """
        return _core.CGPSum_setY(self, Y)


    def setCovar1(self, covar):
        """
        setCovar1(CGPSum self, limix::PCovarianceFunction covar)

        Parameters
        ----------
        covar: limix::PCovarianceFunction

        """
        return _core.CGPSum_setCovar1(self, covar)


    def setCovar2(self, covar):
        """
        setCovar2(CGPSum self, limix::PCovarianceFunction covar)

        Parameters
        ----------
        covar: limix::PCovarianceFunction

        """
        return _core.CGPSum_setCovar2(self, covar)


    def getCovar1(self):
        """
        getCovar1(CGPSum self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::CGPSum *

        """
        return _core.CGPSum_getCovar1(self)


    def getCovar2(self):
        """
        getCovar2(CGPSum self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::CGPSum *

        """
        return _core.CGPSum_getCovar2(self)


    def agetScstar(self):
        """
        agetScstar(CGPSum self)

        Parameters
        ----------
        self: limix::CGPSum *

        """
        return _core.CGPSum_agetScstar(self)


    def agetLambda(self):
        """
        agetLambda(CGPSum self)

        Parameters
        ----------
        self: limix::CGPSum *

        """
        return _core.CGPSum_agetLambda(self)


    def agetYrot(self):
        """
        agetYrot(CGPSum self)

        Parameters
        ----------
        self: limix::CGPSum *

        """
        return _core.CGPSum_agetYrot(self)


    def debugCache(self):
        """
        debugCache(CGPSum self)

        Parameters
        ----------
        self: limix::CGPSum *

        """
        return _core.CGPSum_debugCache(self)


    def agetCache(self):
        """
        agetCache(CGPSum self) -> limix::PGPSumCache

        Parameters
        ----------
        self: limix::CGPSum *

        """
        return _core.CGPSum_agetCache(self)


    def LML(self, *args):
        """
        LML(CGPSum self) -> limix::mfloat_t
        LML(CGPSum self, CGPHyperParams params) -> limix::mfloat_t

        Parameters
        ----------
        params: limix::CGPHyperParams const &

        LML(CGPSum self, VectorXd const & params) -> limix::mfloat_t

        Parameters
        ----------
        params: VectorXd const &

        """
        return _core.CGPSum_LML(self, *args)


    def LMLgrad(self):
        """
        LMLgrad(CGPSum self) -> CGPHyperParams

        Parameters
        ----------
        self: limix::CGPSum *

        """
        return _core.CGPSum_LMLgrad(self)


    def LMLgrad_covar(self, cov1):
        """
        LMLgrad_covar(CGPSum self, bool cov1)

        Parameters
        ----------
        cov1: bool

        """
        return _core.CGPSum_LMLgrad_covar(self, cov1)


    def aLMLgrad_covar1(self):
        """
        aLMLgrad_covar1(CGPSum self)

        Parameters
        ----------
        self: limix::CGPSum *

        """
        return _core.CGPSum_aLMLgrad_covar1(self)


    def aLMLgrad_covar2(self):
        """
        aLMLgrad_covar2(CGPSum self)

        Parameters
        ----------
        self: limix::CGPSum *

        """
        return _core.CGPSum_aLMLgrad_covar2(self)


    def aLMLgrad_dataTerm(self):
        """
        aLMLgrad_dataTerm(CGPSum self)

        Parameters
        ----------
        self: limix::CGPSum *

        """
        return _core.CGPSum_aLMLgrad_dataTerm(self)

CGPSum_swigregister = _core.CGPSum_swigregister
CGPSum_swigregister(CGPSum)


_core.DEFAULT_TOL_swigconstant(_core)
DEFAULT_TOL = _core.DEFAULT_TOL
class CGPopt(_object):
    """Proxy of C++ limix::CGPopt class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CGPopt, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CGPopt, name)
    __repr__ = _swig_repr

    def __init__(self, gp):
        """
        __init__(limix::CGPopt self, limix::PGPbase gp) -> CGPopt

        Parameters
        ----------
        gp: limix::PGPbase

        """
        this = _core.new_CGPopt(gp)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CGPopt
    __del__ = lambda self: None

    def gradCheck(self, relchange=1E-5, threshold=1E-2):
        """
        gradCheck(CGPopt self, limix::mfloat_t relchange=1E-5, limix::mfloat_t threshold=1E-2) -> bool

        Parameters
        ----------
        relchange: limix::mfloat_t
        threshold: limix::mfloat_t

        gradCheck(CGPopt self, limix::mfloat_t relchange=1E-5) -> bool

        Parameters
        ----------
        relchange: limix::mfloat_t

        gradCheck(CGPopt self) -> bool

        Parameters
        ----------
        self: limix::CGPopt *

        """
        return _core.CGPopt_gradCheck(self, relchange, threshold)


    def opt(self):
        """
        opt(CGPopt self) -> bool

        Parameters
        ----------
        self: limix::CGPopt *

        """
        return _core.CGPopt_opt(self)


    def getParamMask(self):
        """
        getParamMask(CGPopt self) -> CGPHyperParams

        Parameters
        ----------
        self: limix::CGPopt const *

        """
        return _core.CGPopt_getParamMask(self)


    def setParamMask(self, filter):
        """
        setParamMask(CGPopt self, CGPHyperParams filter)

        Parameters
        ----------
        filter: limix::CGPHyperParams

        """
        return _core.CGPopt_setParamMask(self, filter)


    def getTolerance(self):
        """
        getTolerance(CGPopt self) -> double

        Parameters
        ----------
        self: limix::CGPopt const *

        """
        return _core.CGPopt_getTolerance(self)


    def setTolerance(self, tol=1E-4):
        """
        setTolerance(CGPopt self, double tol=1E-4)

        Parameters
        ----------
        tol: double

        setTolerance(CGPopt self)

        Parameters
        ----------
        self: limix::CGPopt *

        """
        return _core.CGPopt_setTolerance(self, tol)


    def getNumEvaluations(self):
        """
        getNumEvaluations(CGPopt self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CGPopt *

        """
        return _core.CGPopt_getNumEvaluations(self)


    def getOptBoundLower(self):
        """
        getOptBoundLower(CGPopt self) -> CGPHyperParams

        Parameters
        ----------
        self: limix::CGPopt const *

        """
        return _core.CGPopt_getOptBoundLower(self)


    def setOptBoundLower(self, optBoundLower):
        """
        setOptBoundLower(CGPopt self, CGPHyperParams optBoundLower)

        Parameters
        ----------
        optBoundLower: limix::CGPHyperParams

        """
        return _core.CGPopt_setOptBoundLower(self, optBoundLower)


    def getOptBoundUpper(self):
        """
        getOptBoundUpper(CGPopt self) -> CGPHyperParams

        Parameters
        ----------
        self: limix::CGPopt const *

        """
        return _core.CGPopt_getOptBoundUpper(self)


    def setOptBoundUpper(self, optBoundUpper):
        """
        setOptBoundUpper(CGPopt self, CGPHyperParams optBoundUpper)

        Parameters
        ----------
        optBoundUpper: limix::CGPHyperParams

        """
        return _core.CGPopt_setOptBoundUpper(self, optBoundUpper)


    def getOptStartParams(self):
        """
        getOptStartParams(CGPopt self) -> std::vector< limix::CGPHyperParams,std::allocator< limix::CGPHyperParams > >

        Parameters
        ----------
        self: limix::CGPopt const *

        """
        return _core.CGPopt_getOptStartParams(self)


    def setOptStartParams(self, optStartParams):
        """
        setOptStartParams(CGPopt self, std::vector< limix::CGPHyperParams,std::allocator< limix::CGPHyperParams > > const & optStartParams)

        Parameters
        ----------
        optStartParams: std::vector< limix::CGPHyperParams,std::allocator< limix::CGPHyperParams > > const &

        """
        return _core.CGPopt_setOptStartParams(self, optStartParams)


    def addOptStartParams(self, *args):
        """
        addOptStartParams(CGPopt self, CGPHyperParams params)

        Parameters
        ----------
        params: limix::CGPHyperParams const &

        addOptStartParams(CGPopt self, VectorXd const & paramArray)

        Parameters
        ----------
        paramArray: VectorXd const &

        """
        return _core.CGPopt_addOptStartParams(self, *args)


    def getOptParams(self):
        """
        getOptParams(CGPopt self) -> CGPHyperParams

        Parameters
        ----------
        self: limix::CGPopt *

        """
        return _core.CGPopt_getOptParams(self)

CGPopt_swigregister = _core.CGPopt_swigregister
CGPopt_swigregister(CGPopt)

class ALMM(_object):
    """Proxy of C++ limix::ALMM class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ALMM, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ALMM, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _core.delete_ALMM
    __del__ = lambda self: None
    TEST_LRT = _core.ALMM_TEST_LRT
    TEST_F = _core.ALMM_TEST_F

    def getNumIntervals0(self):
        """
        getNumIntervals0(ALMM self) -> limix::muint_t

        Parameters
        ----------
        self: limix::ALMM const *

        """
        return _core.ALMM_getNumIntervals0(self)


    def setNumIntervals0(self, num_intervals0):
        """
        setNumIntervals0(ALMM self, limix::muint_t num_intervals0)

        Parameters
        ----------
        num_intervals0: limix::muint_t

        """
        return _core.ALMM_setNumIntervals0(self, num_intervals0)


    def setNumIntervalsAlt(self, num_intervalsAlt):
        """
        setNumIntervalsAlt(ALMM self, limix::muint_t num_intervalsAlt)

        Parameters
        ----------
        num_intervalsAlt: limix::muint_t

        """
        return _core.ALMM_setNumIntervalsAlt(self, num_intervalsAlt)


    def getNumIntervalsAlt(self):
        """
        getNumIntervalsAlt(ALMM self) -> limix::muint_t

        Parameters
        ----------
        self: limix::ALMM const *

        """
        return _core.ALMM_getNumIntervalsAlt(self)


    def getLdeltamin0(self):
        """
        getLdeltamin0(ALMM self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::ALMM const *

        """
        return _core.ALMM_getLdeltamin0(self)


    def setLdeltamin0(self, ldeltamin0):
        """
        setLdeltamin0(ALMM self, limix::mfloat_t ldeltamin0)

        Parameters
        ----------
        ldeltamin0: limix::mfloat_t

        """
        return _core.ALMM_setLdeltamin0(self, ldeltamin0)


    def setLdeltaminAlt(self, ldeltaminAlt):
        """
        setLdeltaminAlt(ALMM self, limix::mfloat_t ldeltaminAlt)

        Parameters
        ----------
        ldeltaminAlt: limix::mfloat_t

        """
        return _core.ALMM_setLdeltaminAlt(self, ldeltaminAlt)


    def getLdeltaminAlt(self):
        """
        getLdeltaminAlt(ALMM self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::ALMM const *

        """
        return _core.ALMM_getLdeltaminAlt(self)


    def getLdeltamaxAlt(self):
        """
        getLdeltamaxAlt(ALMM self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::ALMM const *

        """
        return _core.ALMM_getLdeltamaxAlt(self)


    def setLdeltamaxAlt(self, ldeltamaxAlt):
        """
        setLdeltamaxAlt(ALMM self, limix::mfloat_t ldeltamaxAlt)

        Parameters
        ----------
        ldeltamaxAlt: limix::mfloat_t

        """
        return _core.ALMM_setLdeltamaxAlt(self, ldeltamaxAlt)


    def getLdeltamax0(self):
        """
        getLdeltamax0(ALMM self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::ALMM const *

        """
        return _core.ALMM_getLdeltamax0(self)


    def setLdeltamax0(self, ldeltamax0):
        """
        setLdeltamax0(ALMM self, limix::mfloat_t ldeltamax0)

        Parameters
        ----------
        ldeltamax0: limix::mfloat_t

        """
        return _core.ALMM_setLdeltamax0(self, ldeltamax0)


    def setLdeltaInit(self, logdelta):
        """
        setLdeltaInit(ALMM self, limix::mfloat_t logdelta)

        Parameters
        ----------
        logdelta: limix::mfloat_t

        """
        return _core.ALMM_setLdeltaInit(self, logdelta)


    def getLdeltaInit(self):
        """
        getLdeltaInit(ALMM self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::ALMM const *

        """
        return _core.ALMM_getLdeltaInit(self)


    def getNumSamples(self):
        """
        getNumSamples(ALMM self) -> limix::muint_t

        Parameters
        ----------
        self: limix::ALMM const *

        """
        return _core.ALMM_getNumSamples(self)


    def getPheno(self):
        """
        getPheno(ALMM self)

        Parameters
        ----------
        self: limix::ALMM const *

        """
        return _core.ALMM_getPheno(self)


    def getPv(self):
        """
        getPv(ALMM self)

        Parameters
        ----------
        self: limix::ALMM const *

        """
        return _core.ALMM_getPv(self)


    def getSnps(self):
        """
        getSnps(ALMM self)

        Parameters
        ----------
        self: limix::ALMM const *

        """
        return _core.ALMM_getSnps(self)


    def getCovs(self):
        """
        getCovs(ALMM self)

        Parameters
        ----------
        self: limix::ALMM const *

        """
        return _core.ALMM_getCovs(self)


    def setCovs(self, covs):
        """
        setCovs(ALMM self, MatrixXd const & covs)

        Parameters
        ----------
        covs: MatrixXd const &

        """
        return _core.ALMM_setCovs(self, covs)


    def setPheno(self, pheno):
        """
        setPheno(ALMM self, MatrixXd const & pheno)

        Parameters
        ----------
        pheno: MatrixXd const &

        """
        return _core.ALMM_setPheno(self, pheno)


    def setSNPs(self, snps):
        """
        setSNPs(ALMM self, MatrixXd const & snps)

        Parameters
        ----------
        snps: MatrixXd const &

        """
        return _core.ALMM_setSNPs(self, snps)


    def process(self):
        """
        process(ALMM self)

        Parameters
        ----------
        self: limix::ALMM *

        """
        return _core.ALMM_process(self)


    def getK(self):
        """
        getK(ALMM self)

        Parameters
        ----------
        self: limix::ALMM const *

        """
        return _core.ALMM_getK(self)


    def setK(self, K):
        """
        setK(ALMM self, MatrixXd const & K)

        Parameters
        ----------
        K: MatrixXd const &

        """
        return _core.ALMM_setK(self, K)


    def setPermutation(self, perm):
        """
        setPermutation(ALMM self, VectorXi const & perm)

        Parameters
        ----------
        perm: VectorXi const &

        """
        return _core.ALMM_setPermutation(self, perm)


    def getPermutation(self):
        """
        getPermutation(ALMM self)

        Parameters
        ----------
        self: limix::ALMM const *

        """
        return _core.ALMM_getPermutation(self)


    def setVarcompApprox0(self, ldeltamin0=-5, ldeltamax0=5, num_intervals0=100):
        """
        setVarcompApprox0(ALMM self, limix::mfloat_t ldeltamin0=-5, limix::mfloat_t ldeltamax0=5, limix::muint_t num_intervals0=100)

        Parameters
        ----------
        ldeltamin0: limix::mfloat_t
        ldeltamax0: limix::mfloat_t
        num_intervals0: limix::muint_t

        setVarcompApprox0(ALMM self, limix::mfloat_t ldeltamin0=-5, limix::mfloat_t ldeltamax0=5)

        Parameters
        ----------
        ldeltamin0: limix::mfloat_t
        ldeltamax0: limix::mfloat_t

        setVarcompApprox0(ALMM self, limix::mfloat_t ldeltamin0=-5)

        Parameters
        ----------
        ldeltamin0: limix::mfloat_t

        setVarcompApprox0(ALMM self)

        Parameters
        ----------
        self: limix::ALMM *

        """
        return _core.ALMM_setVarcompApprox0(self, ldeltamin0, ldeltamax0, num_intervals0)


    def setVarcompExact(self, ldeltamin=-5, ldeltamax=5, num_intervals=100):
        """
        setVarcompExact(ALMM self, limix::mfloat_t ldeltamin=-5, limix::mfloat_t ldeltamax=5, limix::muint_t num_intervals=100)

        Parameters
        ----------
        ldeltamin: limix::mfloat_t
        ldeltamax: limix::mfloat_t
        num_intervals: limix::muint_t

        setVarcompExact(ALMM self, limix::mfloat_t ldeltamin=-5, limix::mfloat_t ldeltamax=5)

        Parameters
        ----------
        ldeltamin: limix::mfloat_t
        ldeltamax: limix::mfloat_t

        setVarcompExact(ALMM self, limix::mfloat_t ldeltamin=-5)

        Parameters
        ----------
        ldeltamin: limix::mfloat_t

        setVarcompExact(ALMM self)

        Parameters
        ----------
        self: limix::ALMM *

        """
        return _core.ALMM_setVarcompExact(self, ldeltamin, ldeltamax, num_intervals)


    def getTestStatistics(self):
        """
        getTestStatistics(ALMM self) -> int

        Parameters
        ----------
        self: limix::ALMM const *

        """
        return _core.ALMM_getTestStatistics(self)


    def setTestStatistics(self, testStatistics):
        """
        setTestStatistics(ALMM self, int testStatistics)

        Parameters
        ----------
        testStatistics: int

        """
        return _core.ALMM_setTestStatistics(self, testStatistics)

ALMM_swigregister = _core.ALMM_swigregister
ALMM_swigregister(ALMM)

class CLMM(ALMM):
    """Proxy of C++ limix::CLMM class."""

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

    def __init__(self):
        """__init__(limix::CLMM self) -> CLMM"""
        this = _core.new_CLMM()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CLMM
    __del__ = lambda self: None

    def process(self):
        """
        process(CLMM self)

        Parameters
        ----------
        self: limix::CLMM *

        """
        return _core.CLMM_process(self)


    def updateDecomposition(self):
        """
        updateDecomposition(CLMM self)

        Parameters
        ----------
        self: limix::CLMM *

        """
        return _core.CLMM_updateDecomposition(self)


    def setKUS(self, K, U, S):
        """
        setKUS(CLMM self, MatrixXd const & K, MatrixXd const & U, VectorXd const & S)

        Parameters
        ----------
        K: MatrixXd const &
        U: MatrixXd const &
        S: VectorXd const &

        """
        return _core.CLMM_setKUS(self, K, U, S)


    def setK(self, *args):
        """
        setK(CLMM self, MatrixXd const & K, MatrixXd const & U, VectorXd const & S)

        Parameters
        ----------
        K: MatrixXd const &
        U: MatrixXd const &
        S: VectorXd const &

        setK(CLMM self, MatrixXd const & K)

        Parameters
        ----------
        K: MatrixXd const &

        """
        return _core.CLMM_setK(self, *args)


    def getNLL0(self):
        """
        getNLL0(CLMM self)

        Parameters
        ----------
        self: limix::CLMM *

        """
        return _core.CLMM_getNLL0(self)


    def getNLLAlt(self):
        """
        getNLLAlt(CLMM self)

        Parameters
        ----------
        self: limix::CLMM *

        """
        return _core.CLMM_getNLLAlt(self)


    def getFtests(self):
        """
        getFtests(CLMM self)

        Parameters
        ----------
        self: limix::CLMM *

        """
        return _core.CLMM_getFtests(self)


    def getLdeltaAlt(self):
        """
        getLdeltaAlt(CLMM self)

        Parameters
        ----------
        self: limix::CLMM *

        """
        return _core.CLMM_getLdeltaAlt(self)


    def getLdelta0(self):
        """
        getLdelta0(CLMM self)

        Parameters
        ----------
        self: limix::CLMM *

        """
        return _core.CLMM_getLdelta0(self)


    def getLSigma(self):
        """
        getLSigma(CLMM self)

        Parameters
        ----------
        self: limix::CLMM *

        """
        return _core.CLMM_getLSigma(self)


    def getBetaSNP(self):
        """
        getBetaSNP(CLMM self)

        Parameters
        ----------
        self: limix::CLMM *

        """
        return _core.CLMM_getBetaSNP(self)


    def getBetaSNPste(self):
        """
        getBetaSNPste(CLMM self)

        Parameters
        ----------
        self: limix::CLMM *

        """
        return _core.CLMM_getBetaSNPste(self)


    def setLdeltaInit(self, logdelta):
        """
        setLdeltaInit(CLMM self, limix::mfloat_t logdelta)

        Parameters
        ----------
        logdelta: limix::mfloat_t

        """
        return _core.CLMM_setLdeltaInit(self, logdelta)


    def getLdeltaInit(self):
        """
        getLdeltaInit(CLMM self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CLMM *

        """
        return _core.CLMM_getLdeltaInit(self)


    def isCalcStes(self):
        """
        isCalcStes(CLMM self) -> bool

        Parameters
        ----------
        self: limix::CLMM const *

        """
        return _core.CLMM_isCalcStes(self)


    def setCalcStes(self, calcStes):
        """
        setCalcStes(CLMM self, bool calcStes)

        Parameters
        ----------
        calcStes: bool

        """
        return _core.CLMM_setCalcStes(self, calcStes)

CLMM_swigregister = _core.CLMM_swigregister
CLMM_swigregister(CLMM)

class CInteractLMM(CLMM):
    """Proxy of C++ limix::CInteractLMM class."""

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

    def __init__(self):
        """__init__(limix::CInteractLMM self) -> CInteractLMM"""
        this = _core.new_CInteractLMM()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CInteractLMM
    __del__ = lambda self: None

    def setInter(self, Inter):
        """
        setInter(CInteractLMM self, MatrixXd const & Inter)

        Parameters
        ----------
        Inter: MatrixXd const &

        """
        return _core.CInteractLMM_setInter(self, Inter)


    def getInter(self):
        """
        getInter(CInteractLMM self)

        Parameters
        ----------
        self: limix::CInteractLMM const *

        """
        return _core.CInteractLMM_getInter(self)


    def setInter0(self, Inter):
        """
        setInter0(CInteractLMM self, MatrixXd const & Inter)

        Parameters
        ----------
        Inter: MatrixXd const &

        """
        return _core.CInteractLMM_setInter0(self, Inter)


    def agetInter0(self):
        """
        agetInter0(CInteractLMM self)

        Parameters
        ----------
        self: limix::CInteractLMM const *

        """
        return _core.CInteractLMM_agetInter0(self)


    def process(self):
        """
        process(CInteractLMM self)

        Parameters
        ----------
        self: limix::CInteractLMM *

        """
        return _core.CInteractLMM_process(self)


    def updateDecomposition(self):
        """
        updateDecomposition(CInteractLMM self)

        Parameters
        ----------
        self: limix::CInteractLMM *

        """
        return _core.CInteractLMM_updateDecomposition(self)


    def getInter0(self):
        """
        getInter0(CInteractLMM self) -> MatrixXd

        Parameters
        ----------
        self: limix::CInteractLMM const *

        """
        return _core.CInteractLMM_getInter0(self)


    def isRefitDelta0Pheno(self):
        """
        isRefitDelta0Pheno(CInteractLMM self) -> bool

        Parameters
        ----------
        self: limix::CInteractLMM const *

        """
        return _core.CInteractLMM_isRefitDelta0Pheno(self)


    def setRefitDelta0Pheno(self, refitDelta0Pheno):
        """
        setRefitDelta0Pheno(CInteractLMM self, bool refitDelta0Pheno)

        Parameters
        ----------
        refitDelta0Pheno: bool

        """
        return _core.CInteractLMM_setRefitDelta0Pheno(self, refitDelta0Pheno)

CInteractLMM_swigregister = _core.CInteractLMM_swigregister
CInteractLMM_swigregister(CInteractLMM)


def train_associations_SingleSNP(X, Y, U, S, C, numintervals, ldeltamin, ldeltamax):
    """
    train_associations_SingleSNP(MatrixXd const & X, MatrixXd const & Y, MatrixXd const & U, MatrixXd const & S, MatrixXd const & C, int numintervals, double ldeltamin, double ldeltamax)

    Parameters
    ----------
    X: MatrixXd const &
    Y: MatrixXd const &
    U: MatrixXd const &
    S: MatrixXd const &
    C: MatrixXd const &
    numintervals: int
    ldeltamin: double
    ldeltamax: double

    """
    return _core.train_associations_SingleSNP(X, Y, U, S, C, numintervals, ldeltamin, ldeltamax)

def optdelta(UY, UX, S, numintervals, ldeltamin, ldeltamax, REML=False):
    """
    optdelta(MatrixXd const & UY, MatrixXd const & UX, MatrixXd const & S, int numintervals, double ldeltamin, double ldeltamax, bool REML=False) -> double

    Parameters
    ----------
    UY: MatrixXd const &
    UX: MatrixXd const &
    S: MatrixXd const &
    numintervals: int
    ldeltamin: double
    ldeltamax: double
    REML: bool

    optdelta(MatrixXd const & UY, MatrixXd const & UX, MatrixXd const & S, int numintervals, double ldeltamin, double ldeltamax) -> double

    Parameters
    ----------
    UY: MatrixXd const &
    UX: MatrixXd const &
    S: MatrixXd const &
    numintervals: int
    ldeltamin: double
    ldeltamax: double

    """
    return _core.optdelta(UY, UX, S, numintervals, ldeltamin, ldeltamax, REML)

def optdeltaAllY(UY, UX, S, ldeltagrid):
    """
    optdeltaAllY(MatrixXd const & UY, MatrixXd const & UX, MatrixXd const & S, MatrixXd const & ldeltagrid)

    Parameters
    ----------
    UY: MatrixXd const &
    UX: MatrixXd const &
    S: MatrixXd const &
    ldeltagrid: MatrixXd const &

    """
    return _core.optdeltaAllY(UY, UX, S, ldeltagrid)

def nLLeval(ldelta, UY, UX, S, REML=False):
    """
    nLLeval(double ldelta, MatrixXd const & UY, MatrixXd const & UX, MatrixXd const & S, bool REML=False) -> double

    Parameters
    ----------
    ldelta: double
    UY: MatrixXd const &
    UX: MatrixXd const &
    S: MatrixXd const &
    REML: bool

    nLLeval(double ldelta, MatrixXd const & UY, MatrixXd const & UX, MatrixXd const & S) -> double

    Parameters
    ----------
    ldelta: double
    UY: MatrixXd const &
    UX: MatrixXd const &
    S: MatrixXd const &

    """
    return _core.nLLeval(ldelta, UY, UX, S, REML)

def nLLevalAllY(ldelta, UY, UX, S):
    """
    nLLevalAllY(double ldelta, MatrixXd const & UY, MatrixXd const & UX, VectorXd const & S)

    Parameters
    ----------
    ldelta: double
    UY: MatrixXd const &
    UX: MatrixXd const &
    S: VectorXd const &

    """
    return _core.nLLevalAllY(ldelta, UY, UX, S)
class nLLevalFunctor(_object):
    """Proxy of C++ limix::nLLevalFunctor class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, nLLevalFunctor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, nLLevalFunctor, name)
    __repr__ = _swig_repr

    def __init__(self, Y, X, S, REML):
        """
        __init__(limix::nLLevalFunctor self, MatrixXd const Y, MatrixXd const X, MatrixXd const S, bool const REML) -> nLLevalFunctor

        Parameters
        ----------
        Y: MatrixXd const
        X: MatrixXd const
        S: MatrixXd const
        REML: bool const

        """
        this = _core.new_nLLevalFunctor(Y, X, S, REML)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_nLLevalFunctor
    __del__ = lambda self: None

    def __call__(self, logdelta):
        """
        __call__(nLLevalFunctor self, limix::mfloat_t const logdelta) -> limix::mfloat_t

        Parameters
        ----------
        logdelta: limix::mfloat_t const

        """
        return _core.nLLevalFunctor___call__(self, logdelta)

nLLevalFunctor_swigregister = _core.nLLevalFunctor_swigregister
nLLevalFunctor_swigregister(nLLevalFunctor)

class CKroneckerLMM(ALMM):
    """Proxy of C++ limix::CKroneckerLMM class."""

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

    def __init__(self):
        """__init__(limix::CKroneckerLMM self) -> CKroneckerLMM"""
        this = _core.new_CKroneckerLMM()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CKroneckerLMM
    __del__ = lambda self: None

    def process(self):
        """
        process(CKroneckerLMM self)

        Parameters
        ----------
        self: limix::CKroneckerLMM *

        """
        return _core.CKroneckerLMM_process(self)


    def updateDecomposition(self):
        """
        updateDecomposition(CKroneckerLMM self)

        Parameters
        ----------
        self: limix::CKroneckerLMM *

        """
        return _core.CKroneckerLMM_updateDecomposition(self)


    def setK1r(self, K1r):
        """
        setK1r(CKroneckerLMM self, MatrixXd const & K1r)

        Parameters
        ----------
        K1r: MatrixXd const &

        """
        return _core.CKroneckerLMM_setK1r(self, K1r)


    def setK1c(self, K1c):
        """
        setK1c(CKroneckerLMM self, MatrixXd const & K1c)

        Parameters
        ----------
        K1c: MatrixXd const &

        """
        return _core.CKroneckerLMM_setK1c(self, K1c)


    def setK2r(self, K2r):
        """
        setK2r(CKroneckerLMM self, MatrixXd const & K2r)

        Parameters
        ----------
        K2r: MatrixXd const &

        """
        return _core.CKroneckerLMM_setK2r(self, K2r)


    def setK2c(self, K2c):
        """
        setK2c(CKroneckerLMM self, MatrixXd const & K2c)

        Parameters
        ----------
        K2c: MatrixXd const &

        """
        return _core.CKroneckerLMM_setK2c(self, K2c)


    def setPheno(self, Y):
        """
        setPheno(CKroneckerLMM self, MatrixXd const & Y)

        Parameters
        ----------
        Y: MatrixXd const &

        """
        return _core.CKroneckerLMM_setPheno(self, Y)


    def setSNPs(self, snps):
        """
        setSNPs(CKroneckerLMM self, MatrixXd const & snps)

        Parameters
        ----------
        snps: MatrixXd const &

        """
        return _core.CKroneckerLMM_setSNPs(self, snps)


    def setSNPcoldesign(self, design):
        """
        setSNPcoldesign(CKroneckerLMM self, MatrixXd const & design)

        Parameters
        ----------
        design: MatrixXd const &

        """
        return _core.CKroneckerLMM_setSNPcoldesign(self, design)


    def setSNPcoldesign0_inter(self, design):
        """
        setSNPcoldesign0_inter(CKroneckerLMM self, MatrixXd const & design)

        Parameters
        ----------
        design: MatrixXd const &

        """
        return _core.CKroneckerLMM_setSNPcoldesign0_inter(self, design)


    def setNumIntervals0_inter(self, num_intervals0_inter):
        """
        setNumIntervals0_inter(CKroneckerLMM self, limix::muint_t num_intervals0_inter)

        Parameters
        ----------
        num_intervals0_inter: limix::muint_t

        """
        return _core.CKroneckerLMM_setNumIntervals0_inter(self, num_intervals0_inter)


    def getNumIntervals0_inter(self):
        """
        getNumIntervals0_inter(CKroneckerLMM self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CKroneckerLMM *

        """
        return _core.CKroneckerLMM_getNumIntervals0_inter(self)


    def getNLL0(self):
        """
        getNLL0(CKroneckerLMM self)

        Parameters
        ----------
        self: limix::CKroneckerLMM *

        """
        return _core.CKroneckerLMM_getNLL0(self)


    def agetNLL0_inter(self):
        """
        agetNLL0_inter(CKroneckerLMM self)

        Parameters
        ----------
        self: limix::CKroneckerLMM *

        """
        return _core.CKroneckerLMM_agetNLL0_inter(self)


    def getNLLAlt(self):
        """
        getNLLAlt(CKroneckerLMM self)

        Parameters
        ----------
        self: limix::CKroneckerLMM *

        """
        return _core.CKroneckerLMM_getNLLAlt(self)


    def getLdeltaAlt(self):
        """
        getLdeltaAlt(CKroneckerLMM self)

        Parameters
        ----------
        self: limix::CKroneckerLMM *

        """
        return _core.CKroneckerLMM_getLdeltaAlt(self)


    def getLdelta0(self):
        """
        getLdelta0(CKroneckerLMM self)

        Parameters
        ----------
        self: limix::CKroneckerLMM *

        """
        return _core.CKroneckerLMM_getLdelta0(self)


    def agetLdelta0_inter(self):
        """
        agetLdelta0_inter(CKroneckerLMM self)

        Parameters
        ----------
        self: limix::CKroneckerLMM *

        """
        return _core.CKroneckerLMM_agetLdelta0_inter(self)


    def getBetaSNP(self):
        """
        getBetaSNP(CKroneckerLMM self)

        Parameters
        ----------
        self: limix::CKroneckerLMM *

        """
        return _core.CKroneckerLMM_getBetaSNP(self)


    def addCovariates(self, covR, covCol):
        """
        addCovariates(CKroneckerLMM self, MatrixXd const & covR, MatrixXd const & covCol)

        Parameters
        ----------
        covR: MatrixXd const &
        covCol: MatrixXd const &

        """
        return _core.CKroneckerLMM_addCovariates(self, covR, covCol)


    def setCovariates(self, *args):
        """
        setCovariates(CKroneckerLMM self, MatrixXdVec covsR, MatrixXdVec covsCol)

        Parameters
        ----------
        covsR: limix::MatrixXdVec const &
        covsCol: limix::MatrixXdVec const &

        setCovariates(CKroneckerLMM self, limix::muint_t index, MatrixXd const & covR, MatrixXd const & covC)

        Parameters
        ----------
        index: limix::muint_t
        covR: MatrixXd const &
        covC: MatrixXd const &

        """
        return _core.CKroneckerLMM_setCovariates(self, *args)


    def nLLeval(ldelta, A, X, Y, S_C1, S_R1, S_C2, S_R2, W):
        """
        nLLeval(limix::mfloat_t ldelta, MatrixXdVec A, MatrixXdVec X, MatrixXd const & Y, VectorXd const & S_C1, VectorXd const & S_R1, VectorXd const & S_C2, VectorXd const & S_R2, MatrixXd & W) -> limix::mfloat_t

        Parameters
        ----------
        ldelta: limix::mfloat_t
        A: limix::MatrixXdVec const &
        X: limix::MatrixXdVec const &
        Y: MatrixXd const &
        S_C1: VectorXd const &
        S_R1: VectorXd const &
        S_C2: VectorXd const &
        S_R2: VectorXd const &
        W: MatrixXd &

        """
        return _core.CKroneckerLMM_nLLeval(ldelta, A, X, Y, S_C1, S_R1, S_C2, S_R2, W)

    if _newclass:
        nLLeval = staticmethod(nLLeval)
    __swig_getmethods__["nLLeval"] = lambda x: nLLeval

    def optdelta(ldelta_opt, A, X, Y, S_C1, S_R1, S_C2, S_R2, ldeltamin, ldeltamax, numintervals):
        """
        optdelta(limix::mfloat_t & ldelta_opt, MatrixXdVec A, MatrixXdVec X, MatrixXd const & Y, VectorXd const & S_C1, VectorXd const & S_R1, VectorXd const & S_C2, VectorXd const & S_R2, limix::mfloat_t ldeltamin, limix::mfloat_t ldeltamax, limix::muint_t numintervals) -> limix::mfloat_t

        Parameters
        ----------
        ldelta_opt: limix::mfloat_t &
        A: limix::MatrixXdVec const &
        X: limix::MatrixXdVec const &
        Y: MatrixXd const &
        S_C1: VectorXd const &
        S_R1: VectorXd const &
        S_C2: VectorXd const &
        S_R2: VectorXd const &
        ldeltamin: limix::mfloat_t
        ldeltamax: limix::mfloat_t
        numintervals: limix::muint_t

        """
        return _core.CKroneckerLMM_optdelta(ldelta_opt, A, X, Y, S_C1, S_R1, S_C2, S_R2, ldeltamin, ldeltamax, numintervals)

    if _newclass:
        optdelta = staticmethod(optdelta)
    __swig_getmethods__["optdelta"] = lambda x: optdelta
CKroneckerLMM_swigregister = _core.CKroneckerLMM_swigregister
CKroneckerLMM_swigregister(CKroneckerLMM)

def CKroneckerLMM_nLLeval(ldelta, A, X, Y, S_C1, S_R1, S_C2, S_R2, W):
    """
    CKroneckerLMM_nLLeval(limix::mfloat_t ldelta, MatrixXdVec A, MatrixXdVec X, MatrixXd const & Y, VectorXd const & S_C1, VectorXd const & S_R1, VectorXd const & S_C2, VectorXd const & S_R2, MatrixXd & W) -> limix::mfloat_t

    Parameters
    ----------
    ldelta: limix::mfloat_t
    A: limix::MatrixXdVec const &
    X: limix::MatrixXdVec const &
    Y: MatrixXd const &
    S_C1: VectorXd const &
    S_R1: VectorXd const &
    S_C2: VectorXd const &
    S_R2: VectorXd const &
    W: MatrixXd &

    """
    return _core.CKroneckerLMM_nLLeval(ldelta, A, X, Y, S_C1, S_R1, S_C2, S_R2, W)

def CKroneckerLMM_optdelta(ldelta_opt, A, X, Y, S_C1, S_R1, S_C2, S_R2, ldeltamin, ldeltamax, numintervals):
    """
    CKroneckerLMM_optdelta(limix::mfloat_t & ldelta_opt, MatrixXdVec A, MatrixXdVec X, MatrixXd const & Y, VectorXd const & S_C1, VectorXd const & S_R1, VectorXd const & S_C2, VectorXd const & S_R2, limix::mfloat_t ldeltamin, limix::mfloat_t ldeltamax, limix::muint_t numintervals) -> limix::mfloat_t

    Parameters
    ----------
    ldelta_opt: limix::mfloat_t &
    A: limix::MatrixXdVec const &
    X: limix::MatrixXdVec const &
    Y: MatrixXd const &
    S_C1: VectorXd const &
    S_R1: VectorXd const &
    S_C2: VectorXd const &
    S_R2: VectorXd const &
    ldeltamin: limix::mfloat_t
    ldeltamax: limix::mfloat_t
    numintervals: limix::muint_t

    """
    return _core.CKroneckerLMM_optdelta(ldelta_opt, A, X, Y, S_C1, S_R1, S_C2, S_R2, ldeltamin, ldeltamax, numintervals)

class nLLevalKronFunctor(_object):
    """Proxy of C++ limix::nLLevalKronFunctor class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, nLLevalKronFunctor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, nLLevalKronFunctor, name)
    __repr__ = _swig_repr

    def __init__(self, A, X, Y, S_C1, S_R1, S_C2, S_R2, W):
        """
        __init__(limix::nLLevalKronFunctor self, MatrixXdVec A, MatrixXdVec X, MatrixXd const Y, MatrixXd const S_C1, MatrixXd const S_R1, MatrixXd const S_C2, MatrixXd const S_R2, MatrixXd W) -> nLLevalKronFunctor

        Parameters
        ----------
        A: limix::MatrixXdVec const
        X: limix::MatrixXdVec const
        Y: MatrixXd const
        S_C1: MatrixXd const
        S_R1: MatrixXd const
        S_C2: MatrixXd const
        S_R2: MatrixXd const
        W: MatrixXd

        """
        this = _core.new_nLLevalKronFunctor(A, X, Y, S_C1, S_R1, S_C2, S_R2, W)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_nLLevalKronFunctor
    __del__ = lambda self: None

    def __call__(self, logdelta):
        """
        __call__(nLLevalKronFunctor self, limix::mfloat_t const logdelta) -> limix::mfloat_t

        Parameters
        ----------
        logdelta: limix::mfloat_t const

        """
        return _core.nLLevalKronFunctor___call__(self, logdelta)

nLLevalKronFunctor_swigregister = _core.nLLevalKronFunctor_swigregister
nLLevalKronFunctor_swigregister(nLLevalKronFunctor)

class AVarianceTerm(_object):
    """Proxy of C++ limix::AVarianceTerm class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AVarianceTerm, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AVarianceTerm, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _core.delete_AVarianceTerm
    __del__ = lambda self: None

    def getName(self):
        """
        getName(AVarianceTerm self) -> std::string

        Parameters
        ----------
        self: limix::AVarianceTerm *

        """
        return _core.AVarianceTerm_getName(self)


    def getInfo(self):
        """
        getInfo(AVarianceTerm self) -> std::string

        Parameters
        ----------
        self: limix::AVarianceTerm *

        """
        return _core.AVarianceTerm_getInfo(self)


    def setSampleFilter(self, filter):
        """
        setSampleFilter(AVarianceTerm self, MatrixXb const & filter)

        Parameters
        ----------
        filter: MatrixXb const &

        """
        return _core.AVarianceTerm_setSampleFilter(self, filter)


    def getNumberTraits(self):
        """
        getNumberTraits(AVarianceTerm self) -> limix::muint_t

        Parameters
        ----------
        self: limix::AVarianceTerm *

        """
        return _core.AVarianceTerm_getNumberTraits(self)


    def getNumberIndividuals(self):
        """
        getNumberIndividuals(AVarianceTerm self) -> limix::muint_t

        Parameters
        ----------
        self: limix::AVarianceTerm const *

        """
        return _core.AVarianceTerm_getNumberIndividuals(self)


    def setK(self, K):
        """
        setK(AVarianceTerm self, MatrixXd const & K)

        Parameters
        ----------
        K: MatrixXd const &

        """
        return _core.AVarianceTerm_setK(self, K)


    def getK(self):
        """
        getK(AVarianceTerm self)

        Parameters
        ----------
        self: limix::AVarianceTerm const *

        """
        return _core.AVarianceTerm_getK(self)


    def getKcf(self):
        """
        getKcf(AVarianceTerm self) -> limix::PFixedCF

        Parameters
        ----------
        self: limix::AVarianceTerm *

        """
        return _core.AVarianceTerm_getKcf(self)


    def getTraitCovar(self):
        """
        getTraitCovar(AVarianceTerm self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::AVarianceTerm const *

        """
        return _core.AVarianceTerm_getTraitCovar(self)


    def setScales(self, scales):
        """
        setScales(AVarianceTerm self, VectorXd const & scales)

        Parameters
        ----------
        scales: VectorXd const &

        """
        return _core.AVarianceTerm_setScales(self, scales)


    def getScales(self):
        """
        getScales(AVarianceTerm self)

        Parameters
        ----------
        self: limix::AVarianceTerm const *

        """
        return _core.AVarianceTerm_getScales(self)


    def getNumberScales(self):
        """
        getNumberScales(AVarianceTerm self) -> limix::muint_t

        Parameters
        ----------
        self: limix::AVarianceTerm const *

        """
        return _core.AVarianceTerm_getNumberScales(self)


    def initTerm(self):
        """
        initTerm(AVarianceTerm self)

        Parameters
        ----------
        self: limix::AVarianceTerm *

        """
        return _core.AVarianceTerm_initTerm(self)


    def getCovariance(self):
        """
        getCovariance(AVarianceTerm self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::AVarianceTerm const *

        """
        return _core.AVarianceTerm_getCovariance(self)

AVarianceTerm_swigregister = _core.AVarianceTerm_swigregister
AVarianceTerm_swigregister(AVarianceTerm)

class CSingleTraitTerm(AVarianceTerm):
    """Proxy of C++ limix::CSingleTraitTerm class."""

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

    def __init__(self, *args):
        """
        __init__(limix::CSingleTraitTerm self) -> CSingleTraitTerm
        __init__(limix::CSingleTraitTerm self, MatrixXd const & K) -> CSingleTraitTerm

        Parameters
        ----------
        K: MatrixXd const &

        """
        this = _core.new_CSingleTraitTerm(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CSingleTraitTerm
    __del__ = lambda self: None

    def getName(self):
        """
        getName(CSingleTraitTerm self) -> std::string

        Parameters
        ----------
        self: limix::CSingleTraitTerm *

        """
        return _core.CSingleTraitTerm_getName(self)


    def getInfo(self):
        """
        getInfo(CSingleTraitTerm self) -> std::string

        Parameters
        ----------
        self: limix::CSingleTraitTerm *

        """
        return _core.CSingleTraitTerm_getInfo(self)


    def setSampleFilter(self, filter):
        """
        setSampleFilter(CSingleTraitTerm self, MatrixXb const & filter)

        Parameters
        ----------
        filter: MatrixXb const &

        """
        return _core.CSingleTraitTerm_setSampleFilter(self, filter)


    def getNumberTraits(self):
        """
        getNumberTraits(CSingleTraitTerm self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CSingleTraitTerm *

        """
        return _core.CSingleTraitTerm_getNumberTraits(self)


    def getTraitCovar(self):
        """
        getTraitCovar(CSingleTraitTerm self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::CSingleTraitTerm const *

        """
        return _core.CSingleTraitTerm_getTraitCovar(self)


    def setScales(self, scales):
        """
        setScales(CSingleTraitTerm self, VectorXd const & scales)

        Parameters
        ----------
        scales: VectorXd const &

        """
        return _core.CSingleTraitTerm_setScales(self, scales)


    def getScales(self):
        """
        getScales(CSingleTraitTerm self)

        Parameters
        ----------
        self: limix::CSingleTraitTerm const *

        """
        return _core.CSingleTraitTerm_getScales(self)


    def getNumberScales(self):
        """
        getNumberScales(CSingleTraitTerm self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CSingleTraitTerm const *

        """
        return _core.CSingleTraitTerm_getNumberScales(self)


    def initTerm(self):
        """
        initTerm(CSingleTraitTerm self)

        Parameters
        ----------
        self: limix::CSingleTraitTerm *

        """
        return _core.CSingleTraitTerm_initTerm(self)


    def getCovariance(self):
        """
        getCovariance(CSingleTraitTerm self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::CSingleTraitTerm const *

        """
        return _core.CSingleTraitTerm_getCovariance(self)

CSingleTraitTerm_swigregister = _core.CSingleTraitTerm_swigregister
CSingleTraitTerm_swigregister(CSingleTraitTerm)

class CMultiTraitTerm(AVarianceTerm):
    """Proxy of C++ limix::CMultiTraitTerm class."""

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

    def __init__(self, *args):
        """
        __init__(limix::CMultiTraitTerm self, limix::muint_t P) -> CMultiTraitTerm

        Parameters
        ----------
        P: limix::muint_t

        __init__(limix::CMultiTraitTerm self, limix::muint_t P, limix::PCovarianceFunction traitCovar, MatrixXd const & K) -> CMultiTraitTerm

        Parameters
        ----------
        P: limix::muint_t
        traitCovar: limix::PCovarianceFunction
        K: MatrixXd const &

        """
        this = _core.new_CMultiTraitTerm(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CMultiTraitTerm
    __del__ = lambda self: None

    def getName(self):
        """
        getName(CMultiTraitTerm self) -> std::string

        Parameters
        ----------
        self: limix::CMultiTraitTerm *

        """
        return _core.CMultiTraitTerm_getName(self)


    def getInfo(self):
        """
        getInfo(CMultiTraitTerm self) -> std::string

        Parameters
        ----------
        self: limix::CMultiTraitTerm *

        """
        return _core.CMultiTraitTerm_getInfo(self)


    def setSampleFilter(self, filter):
        """
        setSampleFilter(CMultiTraitTerm self, MatrixXb const & filter)

        Parameters
        ----------
        filter: MatrixXb const &

        """
        return _core.CMultiTraitTerm_setSampleFilter(self, filter)


    def getNumberTraits(self):
        """
        getNumberTraits(CMultiTraitTerm self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CMultiTraitTerm *

        """
        return _core.CMultiTraitTerm_getNumberTraits(self)


    def setTraitCovar(self, traitCovar):
        """
        setTraitCovar(CMultiTraitTerm self, limix::PCovarianceFunction traitCovar)

        Parameters
        ----------
        traitCovar: limix::PCovarianceFunction

        """
        return _core.CMultiTraitTerm_setTraitCovar(self, traitCovar)


    def getTraitCovar(self):
        """
        getTraitCovar(CMultiTraitTerm self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::CMultiTraitTerm const *

        """
        return _core.CMultiTraitTerm_getTraitCovar(self)


    def setScales(self, scales):
        """
        setScales(CMultiTraitTerm self, VectorXd const & scales)

        Parameters
        ----------
        scales: VectorXd const &

        """
        return _core.CMultiTraitTerm_setScales(self, scales)


    def getScales(self):
        """
        getScales(CMultiTraitTerm self)

        Parameters
        ----------
        self: limix::CMultiTraitTerm const *

        """
        return _core.CMultiTraitTerm_getScales(self)


    def getNumberScales(self):
        """
        getNumberScales(CMultiTraitTerm self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CMultiTraitTerm const *

        """
        return _core.CMultiTraitTerm_getNumberScales(self)


    def initTerm(self):
        """
        initTerm(CMultiTraitTerm self)

        Parameters
        ----------
        self: limix::CMultiTraitTerm *

        """
        return _core.CMultiTraitTerm_initTerm(self)


    def getCovariance(self):
        """
        getCovariance(CMultiTraitTerm self) -> limix::PCovarianceFunction

        Parameters
        ----------
        self: limix::CMultiTraitTerm const *

        """
        return _core.CMultiTraitTerm_getCovariance(self)

CMultiTraitTerm_swigregister = _core.CMultiTraitTerm_swigregister
CMultiTraitTerm_swigregister(CMultiTraitTerm)

class CVarianceDecomposition(_object):
    """Proxy of C++ limix::CVarianceDecomposition class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CVarianceDecomposition, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CVarianceDecomposition, name)
    __repr__ = _swig_repr

    def __init__(self, pheno):
        """
        __init__(limix::CVarianceDecomposition self, MatrixXd const & pheno) -> CVarianceDecomposition

        Parameters
        ----------
        pheno: MatrixXd const &

        """
        this = _core.new_CVarianceDecomposition(pheno)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CVarianceDecomposition
    __del__ = lambda self: None

    def clear(self):
        """
        clear(CVarianceDecomposition self)

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_clear(self)


    def setPheno(self, pheno):
        """
        setPheno(CVarianceDecomposition self, MatrixXd const & pheno)

        Parameters
        ----------
        pheno: MatrixXd const &

        """
        return _core.CVarianceDecomposition_setPheno(self, pheno)


    def getPheno(self):
        """
        getPheno(CVarianceDecomposition self)

        Parameters
        ----------
        self: limix::CVarianceDecomposition const *

        """
        return _core.CVarianceDecomposition_getPheno(self)


    def getNumberTraits(self):
        """
        getNumberTraits(CVarianceDecomposition self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CVarianceDecomposition const *

        """
        return _core.CVarianceDecomposition_getNumberTraits(self)


    def getNumberIndividuals(self):
        """
        getNumberIndividuals(CVarianceDecomposition self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CVarianceDecomposition const *

        """
        return _core.CVarianceDecomposition_getNumberIndividuals(self)


    def addFixedEffTerm(self, *args):
        """
        addFixedEffTerm(CVarianceDecomposition self, MatrixXd const & design, MatrixXd const & fixed)

        Parameters
        ----------
        design: MatrixXd const &
        fixed: MatrixXd const &

        addFixedEffTerm(CVarianceDecomposition self, MatrixXd const & F)

        Parameters
        ----------
        F: MatrixXd const &

        """
        return _core.CVarianceDecomposition_addFixedEffTerm(self, *args)


    def getFixed(self, i):
        """
        getFixed(CVarianceDecomposition self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CVarianceDecomposition_getFixed(self, i)


    def getDesign(self, i):
        """
        getDesign(CVarianceDecomposition self, limix::muint_t const i)

        Parameters
        ----------
        i: limix::muint_t const

        """
        return _core.CVarianceDecomposition_getDesign(self, i)


    def clearFixedEffs(self):
        """
        clearFixedEffs(CVarianceDecomposition self)

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_clearFixedEffs(self)


    def getNumberFixedEffs(self):
        """
        getNumberFixedEffs(CVarianceDecomposition self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CVarianceDecomposition const *

        """
        return _core.CVarianceDecomposition_getNumberFixedEffs(self)


    def addTerm(self, *args):
        """
        addTerm(CVarianceDecomposition self, limix::PVarianceTerm term)

        Parameters
        ----------
        term: limix::PVarianceTerm

        addTerm(CVarianceDecomposition self, MatrixXd const & K)

        Parameters
        ----------
        K: MatrixXd const &

        addTerm(CVarianceDecomposition self, limix::PCovarianceFunction traitCovar, MatrixXd const & K)

        Parameters
        ----------
        traitCovar: limix::PCovarianceFunction
        K: MatrixXd const &

        """
        return _core.CVarianceDecomposition_addTerm(self, *args)


    def getTerm(self, i):
        """
        getTerm(CVarianceDecomposition self, limix::muint_t i) -> limix::PVarianceTerm

        Parameters
        ----------
        i: limix::muint_t

        """
        return _core.CVarianceDecomposition_getTerm(self, i)


    def clearTerms(self):
        """
        clearTerms(CVarianceDecomposition self)

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_clearTerms(self)


    def getNumberTerms(self):
        """
        getNumberTerms(CVarianceDecomposition self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CVarianceDecomposition const *

        """
        return _core.CVarianceDecomposition_getNumberTerms(self)


    def setScales(self, *args):
        """
        setScales(CVarianceDecomposition self, VectorXd const & scales)

        Parameters
        ----------
        scales: VectorXd const &

        setScales(CVarianceDecomposition self, limix::muint_t i, VectorXd const & scales)

        Parameters
        ----------
        i: limix::muint_t
        scales: VectorXd const &

        """
        return _core.CVarianceDecomposition_setScales(self, *args)


    def getScales(self, *args):
        """
        getScales(CVarianceDecomposition self, limix::muint_t i)

        Parameters
        ----------
        i: limix::muint_t

        getScales(CVarianceDecomposition self)

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_getScales(self, *args)


    def getNumberScales(self):
        """
        getNumberScales(CVarianceDecomposition self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_getNumberScales(self)


    def getGP(self):
        """
        getGP(CVarianceDecomposition self) -> limix::PGPbase

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_getGP(self)


    def getCovar(self):
        """
        getCovar(CVarianceDecomposition self) -> limix::PSumCF

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_getCovar(self)


    def getMean(self):
        """
        getMean(CVarianceDecomposition self) -> limix::PLinearMean

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_getMean(self)


    def initGPparams(self):
        """
        initGPparams(CVarianceDecomposition self)

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_initGPparams(self)


    def initGP(self, fast=False):
        """
        initGP(CVarianceDecomposition self, bool fast=False)

        Parameters
        ----------
        fast: bool

        initGP(CVarianceDecomposition self)

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_initGP(self, fast)


    def initGPbase(self):
        """
        initGPbase(CVarianceDecomposition self)

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_initGPbase(self)


    def initGPkronSum(self):
        """
        initGPkronSum(CVarianceDecomposition self)

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_initGPkronSum(self)


    def trainGP(self):
        """
        trainGP(CVarianceDecomposition self) -> bool

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_trainGP(self)


    def getFixedEffects(self):
        """
        getFixedEffects(CVarianceDecomposition self)

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_getFixedEffects(self)


    def getLML(self):
        """
        getLML(CVarianceDecomposition self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_getLML(self)


    def getLMLgrad(self):
        """
        getLMLgrad(CVarianceDecomposition self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_getLMLgrad(self)


    def getLMLgradGPbase(self):
        """
        getLMLgradGPbase(CVarianceDecomposition self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_getLMLgradGPbase(self)


    def getLMLgradGPkronSum(self):
        """
        getLMLgradGPkronSum(CVarianceDecomposition self) -> limix::mfloat_t

        Parameters
        ----------
        self: limix::CVarianceDecomposition *

        """
        return _core.CVarianceDecomposition_getLMLgradGPkronSum(self)


    def aestimateHeritability(Y, fixed, K):
        """
        aestimateHeritability(MatrixXd const & Y, MatrixXd const & fixed, MatrixXd const & K)

        Parameters
        ----------
        Y: MatrixXd const &
        fixed: MatrixXd const &
        K: MatrixXd const &

        """
        return _core.CVarianceDecomposition_aestimateHeritability(Y, fixed, K)

    if _newclass:
        aestimateHeritability = staticmethod(aestimateHeritability)
    __swig_getmethods__["aestimateHeritability"] = lambda x: aestimateHeritability
CVarianceDecomposition_swigregister = _core.CVarianceDecomposition_swigregister
CVarianceDecomposition_swigregister(CVarianceDecomposition)

def CVarianceDecomposition_aestimateHeritability(Y, fixed, K):
    """
    CVarianceDecomposition_aestimateHeritability(MatrixXd const & Y, MatrixXd const & fixed, MatrixXd const & K)

    Parameters
    ----------
    Y: MatrixXd const &
    fixed: MatrixXd const &
    K: MatrixXd const &

    """
    return _core.CVarianceDecomposition_aestimateHeritability(Y, fixed, K)

class CHeaderMap(_object):
    """Proxy of C++ limix::CHeaderMap class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHeaderMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CHeaderMap, name)
    __repr__ = _swig_repr

    def resize(self, n):
        """
        resize(CHeaderMap self, limix::muint_t n)

        Parameters
        ----------
        n: limix::muint_t

        """
        return _core.CHeaderMap_resize(self, n)


    def setStr(self, name, n, value):
        """
        setStr(CHeaderMap self, std::string name, limix::muint_t n, std::string value)

        Parameters
        ----------
        name: std::string
        n: limix::muint_t
        value: std::string

        """
        return _core.CHeaderMap_setStr(self, name, n, value)


    def copy(self, *args):
        """
        copy(CHeaderMap self, limix::muint_t i_start, limix::muint_t n_elements) -> limix::PHeaderMap

        Parameters
        ----------
        i_start: limix::muint_t
        n_elements: limix::muint_t

        copy(CHeaderMap self, limix::muint_t n_elements) -> limix::PHeaderMap

        Parameters
        ----------
        n_elements: limix::muint_t

        """
        return _core.CHeaderMap_copy(self, *args)


    def __init__(self):
        """__init__(limix::CHeaderMap self) -> CHeaderMap"""
        this = _core.new_CHeaderMap()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CHeaderMap
    __del__ = lambda self: None
CHeaderMap_swigregister = _core.CHeaderMap_swigregister
CHeaderMap_swigregister(CHeaderMap)

class CRMemDataFrameXd(_object):
    """Proxy of C++ limix::CRMemDataFrame<(MatrixXd)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CRMemDataFrameXd, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CRMemDataFrameXd, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(limix::CRMemDataFrame<(MatrixXd)> self) -> CRMemDataFrameXd
        __init__(limix::CRMemDataFrame<(MatrixXd)> self, CRMemDataFrameXd copy) -> CRMemDataFrameXd

        Parameters
        ----------
        copy: limix::CRMemDataFrame< MatrixXd > const &

        __init__(limix::CRMemDataFrame<(MatrixXd)> self, std::shared_ptr< MatrixXd > M, limix::PHeaderMap rowHeader, limix::PHeaderMap colHeader) -> CRMemDataFrameXd

        Parameters
        ----------
        M: std::shared_ptr< MatrixXd >
        rowHeader: limix::PHeaderMap
        colHeader: limix::PHeaderMap

        """
        this = _core.new_CRMemDataFrameXd(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CRMemDataFrameXd
    __del__ = lambda self: None

    def getMatrix(self):
        """
        getMatrix(CRMemDataFrameXd self)

        Parameters
        ----------
        self: limix::CRMemDataFrame< MatrixXd > const *

        """
        return _core.CRMemDataFrameXd_getMatrix(self)

CRMemDataFrameXd_swigregister = _core.CRMemDataFrameXd_swigregister
CRMemDataFrameXd_swigregister(CRMemDataFrameXd)

class CRWMemDataFrameXd(CRMemDataFrameXd):
    """Proxy of C++ limix::CRWMemDataFrame<(MatrixXd)> class."""

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

    def __init__(self, *args):
        """
        __init__(limix::CRWMemDataFrame<(MatrixXd)> self) -> CRWMemDataFrameXd
        __init__(limix::CRWMemDataFrame<(MatrixXd)> self, CRMemDataFrameXd copy) -> CRWMemDataFrameXd

        Parameters
        ----------
        copy: limix::CRMemDataFrame< MatrixXd > const &

        """
        this = _core.new_CRWMemDataFrameXd(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CRWMemDataFrameXd
    __del__ = lambda self: None

    def setRowHeader(self, arg2):
        """
        setRowHeader(CRWMemDataFrameXd self, limix::PHeaderMap arg2)

        Parameters
        ----------
        in: limix::PHeaderMap

        """
        return _core.CRWMemDataFrameXd_setRowHeader(self, arg2)


    def setColHeader(self, arg2):
        """
        setColHeader(CRWMemDataFrameXd self, limix::PHeaderMap arg2)

        Parameters
        ----------
        in: limix::PHeaderMap

        """
        return _core.CRWMemDataFrameXd_setColHeader(self, arg2)


    def setMatrix(self, *args):
        """
        setMatrix(CRWMemDataFrameXd self, MatrixXd const & arg2)

        Parameters
        ----------
        in: MatrixXd const &

        setMatrix(CRWMemDataFrameXd self, std::shared_ptr< MatrixXd > arg2)

        Parameters
        ----------
        in: std::shared_ptr< MatrixXd >

        """
        return _core.CRWMemDataFrameXd_setMatrix(self, *args)

CRWMemDataFrameXd_swigregister = _core.CRWMemDataFrameXd_swigregister
CRWMemDataFrameXd_swigregister(CRWMemDataFrameXd)

class ARDataFrameXd(_object):
    """Proxy of C++ limix::ARDataFrame<(MatrixXd)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ARDataFrameXd, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ARDataFrameXd, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _core.delete_ARDataFrameXd
    __del__ = lambda self: None

    def getMatrix(self):
        """
        getMatrix(ARDataFrameXd self)

        Parameters
        ----------
        self: limix::ARDataFrame< MatrixXd > const *

        """
        return _core.ARDataFrameXd_getMatrix(self)

ARDataFrameXd_swigregister = _core.ARDataFrameXd_swigregister
ARDataFrameXd_swigregister(ARDataFrameXd)

class AWDataFrameXd(_object):
    """Proxy of C++ limix::AWDataFrame<(MatrixXd)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AWDataFrameXd, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AWDataFrameXd, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _core.delete_AWDataFrameXd
    __del__ = lambda self: None

    def setRowHeader(self, arg2):
        """
        setRowHeader(AWDataFrameXd self, limix::PHeaderMap arg2)

        Parameters
        ----------
        in: limix::PHeaderMap

        """
        return _core.AWDataFrameXd_setRowHeader(self, arg2)


    def setColHeader(self, arg2):
        """
        setColHeader(AWDataFrameXd self, limix::PHeaderMap arg2)

        Parameters
        ----------
        in: limix::PHeaderMap

        """
        return _core.AWDataFrameXd_setColHeader(self, arg2)


    def setMatrix(self, *args):
        """
        setMatrix(AWDataFrameXd self, MatrixXd const & arg2)

        Parameters
        ----------
        in: MatrixXd const &

        setMatrix(AWDataFrameXd self, std::shared_ptr< MatrixXd > arg2)

        Parameters
        ----------
        in: std::shared_ptr< MatrixXd >

        """
        return _core.AWDataFrameXd_setMatrix(self, *args)

AWDataFrameXd_swigregister = _core.AWDataFrameXd_swigregister
AWDataFrameXd_swigregister(AWDataFrameXd)

class AGenotypeContainer(_object):
    """Proxy of C++ limix::AGenotypeContainer class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AGenotypeContainer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AGenotypeContainer, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _core.delete_AGenotypeContainer
    __del__ = lambda self: None

    def setSNPFilter(self, chrom, start, stop):
        """
        setSNPFilter(AGenotypeContainer self, std::string chrom, limix::muint_t start, limix::muint_t stop)

        Parameters
        ----------
        chrom: std::string
        start: limix::muint_t
        stop: limix::muint_t

        """
        return _core.AGenotypeContainer_setSNPFilter(self, chrom, start, stop)


    def read(self, num_snps=-1):
        """
        read(AGenotypeContainer self, limix::mint_t num_snps=-1) -> limix::PGenotypeBlock

        Parameters
        ----------
        num_snps: limix::mint_t

        read(AGenotypeContainer self) -> limix::PGenotypeBlock

        Parameters
        ----------
        self: limix::AGenotypeContainer *

        """
        return _core.AGenotypeContainer_read(self, num_snps)

AGenotypeContainer_swigregister = _core.AGenotypeContainer_swigregister
AGenotypeContainer_swigregister(AGenotypeContainer)

class CGenotypeBlock(CRMemDataFrameXd):
    """Proxy of C++ limix::CGenotypeBlock class."""

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

    def __init__(self, *args):
        """
        __init__(limix::CGenotypeBlock self) -> CGenotypeBlock
        __init__(limix::CGenotypeBlock self, StringVec row_header_names, StringVec col_header_names, limix::muint_t rows, limix::muint_t cols) -> CGenotypeBlock

        Parameters
        ----------
        row_header_names: limix::stringVec const &
        col_header_names: limix::stringVec const &
        rows: limix::muint_t
        cols: limix::muint_t

        __init__(limix::CGenotypeBlock self, CGenotypeBlock copy) -> CGenotypeBlock

        Parameters
        ----------
        copy: limix::CGenotypeBlock const &

        __init__(limix::CGenotypeBlock self, PMatrixXd geno, PVectorXi pos, limix::PHeaderMap row_header, limix::PHeaderMap col_header) -> CGenotypeBlock

        Parameters
        ----------
        geno: PMatrixXd
        pos: PVectorXi
        row_header: limix::PHeaderMap
        col_header: limix::PHeaderMap

        """
        this = _core.new_CGenotypeBlock(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CGenotypeBlock
    __del__ = lambda self: None

    def numSample(self):
        """
        numSample(CGenotypeBlock self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CGenotypeBlock *

        """
        return _core.CGenotypeBlock_numSample(self)


    def numSNPs(self):
        """
        numSNPs(CGenotypeBlock self) -> limix::muint_t

        Parameters
        ----------
        self: limix::CGenotypeBlock *

        """
        return _core.CGenotypeBlock_numSNPs(self)


    def getPosition(self):
        """
        getPosition(CGenotypeBlock self)

        Parameters
        ----------
        self: limix::CGenotypeBlock const *

        """
        return _core.CGenotypeBlock_getPosition(self)


    def read(self, num_snps=-1):
        """
        read(CGenotypeBlock self, limix::mint_t num_snps=-1) -> limix::PGenotypeBlock

        Parameters
        ----------
        num_snps: limix::mint_t

        read(CGenotypeBlock self) -> limix::PGenotypeBlock

        Parameters
        ----------
        self: limix::CGenotypeBlock *

        """
        return _core.CGenotypeBlock_read(self, num_snps)

CGenotypeBlock_swigregister = _core.CGenotypeBlock_swigregister
CGenotypeBlock_swigregister(CGenotypeBlock)

class CTextfileGenotypeContainer(AGenotypeContainer):
    """Proxy of C++ limix::CTextfileGenotypeContainer class."""

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

    def __init__(self, filename):
        """
        __init__(limix::CTextfileGenotypeContainer self, std::string const & filename) -> CTextfileGenotypeContainer

        Parameters
        ----------
        filename: std::string const &

        """
        this = _core.new_CTextfileGenotypeContainer(filename)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CTextfileGenotypeContainer
    __del__ = lambda self: None

    def read(self, num_snps=-1):
        """
        read(CTextfileGenotypeContainer self, limix::mint_t num_snps=-1) -> limix::PGenotypeBlock

        Parameters
        ----------
        num_snps: limix::mint_t

        read(CTextfileGenotypeContainer self) -> limix::PGenotypeBlock

        Parameters
        ----------
        self: limix::CTextfileGenotypeContainer *

        """
        return _core.CTextfileGenotypeContainer_read(self, num_snps)

CTextfileGenotypeContainer_swigregister = _core.CTextfileGenotypeContainer_swigregister
CTextfileGenotypeContainer_swigregister(CTextfileGenotypeContainer)

class CMemGenotypeContainer(AGenotypeContainer):
    """Proxy of C++ limix::CMemGenotypeContainer class."""

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

    def __init__(self, block):
        """
        __init__(limix::CMemGenotypeContainer self, limix::PGenotypeBlock block) -> CMemGenotypeContainer

        Parameters
        ----------
        block: limix::PGenotypeBlock

        """
        this = _core.new_CMemGenotypeContainer(block)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_CMemGenotypeContainer
    __del__ = lambda self: None

    def read(self, num_snps=-1):
        """
        read(CMemGenotypeContainer self, limix::mint_t num_snps=-1) -> limix::PGenotypeBlock

        Parameters
        ----------
        num_snps: limix::mint_t

        read(CMemGenotypeContainer self) -> limix::PGenotypeBlock

        Parameters
        ----------
        self: limix::CMemGenotypeContainer *

        """
        return _core.CMemGenotypeContainer_read(self, num_snps)

CMemGenotypeContainer_swigregister = _core.CMemGenotypeContainer_swigregister
CMemGenotypeContainer_swigregister(CMemGenotypeContainer)


def best_split_full_model(X, UTy, C, S, U, noderange, delta):
    """
    best_split_full_model(MatrixXd const & X, MatrixXd const & UTy, MatrixXd const & C, MatrixXd const & S, MatrixXd const & U, VectorXi const & noderange, limix::mfloat_t delta)

    Parameters
    ----------
    X: MatrixXd const &
    UTy: MatrixXd const &
    C: MatrixXd const &
    S: MatrixXd const &
    U: MatrixXd const &
    noderange: VectorXi const &
    delta: limix::mfloat_t

    """
    return _core.best_split_full_model(X, UTy, C, S, U, noderange, delta)

def predict_lmm_forest(tree_nodes, left_children, right_children, best_predictor, mean, splitting_value, X, depth):
    """
    predict_lmm_forest(VectorXi const & tree_nodes, VectorXi const & left_children, VectorXi const & right_children, VectorXi const & best_predictor, MatrixXd const & mean, MatrixXd const & splitting_value, MatrixXd const & X, limix::mfloat_t depth)

    Parameters
    ----------
    tree_nodes: VectorXi const &
    left_children: VectorXi const &
    right_children: VectorXi const &
    best_predictor: VectorXi const &
    mean: MatrixXd const &
    splitting_value: MatrixXd const &
    X: MatrixXd const &
    depth: limix::mfloat_t

    """
    return _core.predict_lmm_forest(tree_nodes, left_children, right_children, best_predictor, mean, splitting_value, X, depth)

def argOutSwigTest2(in1, in2):
    """
    argOutSwigTest2(limix::mint_t in1, limix::mint_t in2)

    Parameters
    ----------
    in1: limix::mint_t
    in2: limix::mint_t

    """
    return _core.argOutSwigTest2(in1, in2)

def argOutSwigTest3(in1, in2):
    """
    argOutSwigTest3(limix::mint_t in1, limix::mint_t in2)

    Parameters
    ----------
    in1: limix::mint_t
    in2: limix::mint_t

    """
    return _core.argOutSwigTest3(in1, in2)

def argOutSwigTest4(m):
    """
    argOutSwigTest4(MatrixXd const & m)

    Parameters
    ----------
    m: MatrixXd const &

    """
    return _core.argOutSwigTest4(m)
# This file is compatible with both classic and new-style classes.


