# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.2
#
# 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:
            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:
    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):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

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

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

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


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, *args):
        """
        distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t

        Parameters:
            x: swig::SwigPyIterator const &

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

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

        Parameters:
            x: swig::SwigPyIterator const &

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

    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, *args):
        """
        advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters:
            n: ptrdiff_t

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

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

        Parameters:
            x: swig::SwigPyIterator const &

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

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

        Parameters:
            x: swig::SwigPyIterator const &

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

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

        Parameters:
            n: ptrdiff_t

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

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

        Parameters:
            n: ptrdiff_t

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

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

        Parameters:
            n: ptrdiff_t

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

    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 __nonzero__(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 pop(self):
        """
        pop(MatrixXdVec self) -> std::vector< MatrixXd >::value_type

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

        """
        return _core.MatrixXdVec_pop(self)

    def __getslice__(self, *args):
        """
        __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, *args)

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

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

        __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

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

    def __delslice__(self, *args):
        """
        __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, *args)

    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 append(self, *args):
        """
        append(MatrixXdVec self, std::vector< MatrixXd >::value_type const & x)

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

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

    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 clear(self):
        """
        clear(MatrixXdVec self)

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

        """
        return _core.MatrixXdVec_clear(self)

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

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

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

    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 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 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: self.this = this
    def push_back(self, *args):
        """
        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, *args)

    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, *args):
        """
        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, *args)

    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, *args):
        """
        reserve(MatrixXdVec self, std::vector< MatrixXd >::size_type n)

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

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

    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 __nonzero__(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 pop(self):
        """
        pop(StringVec self) -> std::vector< std::string >::value_type

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

        """
        return _core.StringVec_pop(self)

    def __getslice__(self, *args):
        """
        __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, *args)

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

        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 &

        __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

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

    def __delslice__(self, *args):
        """
        __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, *args)

    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 append(self, *args):
        """
        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, *args)

    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 clear(self):
        """
        clear(StringVec self)

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

        """
        return _core.StringVec_clear(self)

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

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

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

    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 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 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: self.this = this
    def push_back(self, *args):
        """
        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, *args)

    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, *args):
        """
        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, *args)

    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, *args):
        """
        reserve(StringVec self, std::vector< std::string >::size_type n)

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

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

    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 __nonzero__(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, *args):
        """
        __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, *args)

    def __delitem__(self, *args):
        """
        __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, *args)

    def has_key(self, *args):
        """
        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, *args)

    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, *args):
        """
        __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, *args)

    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: 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 clear(self):
        """
        clear(StringMatrixMap self)

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

        """
        return _core.StringMatrixMap_clear(self)

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

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

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

    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 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 count(self, *args):
        """
        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, *args)

    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, *args):
        """
        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, *args)

    def lower_bound(self, *args):
        """
        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, *args)

    def upper_bound(self, *args):
        """
        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, *args)

    __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 __nonzero__(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 pop(self):
        """
        pop(VectorXiVec self) -> std::vector< VectorXi >::value_type

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

        """
        return _core.VectorXiVec_pop(self)

    def __getslice__(self, *args):
        """
        __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, *args)

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

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

        __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

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

    def __delslice__(self, *args):
        """
        __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, *args)

    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 append(self, *args):
        """
        append(VectorXiVec self, std::vector< VectorXi >::value_type const & x)

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

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

    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 clear(self):
        """
        clear(VectorXiVec self)

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

        """
        return _core.VectorXiVec_clear(self)

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

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

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

    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 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 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: self.this = this
    def push_back(self, *args):
        """
        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, *args)

    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, *args):
        """
        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, *args)

    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, *args):
        """
        reserve(VectorXiVec self, std::vector< VectorXi >::size_type n)

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

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

    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)

PI = _core.PI

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

    Parameters:
        val: limix::mfloat_t

    """
  return _core.isnan(*args)

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

    Parameters:
        value: limix::mfloat_t

    """
  return _core.isinf(*args)

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

    Parameters:
        x: limix::mfloat_t

    """
  return _core.exp(*args)

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

    Parameters:
        x: limix::mfloat_t

    """
  return _core.sqrt(*args)

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

    Parameters:
        x: limix::mfloat_t

    """
  return _core.log(*args)

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

    Parameters:
        x: limix::mfloat_t

    """
  return _core.inverse(*args)
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, str="Unlabeled exception"): 
        """
        __init__(limix::CLimixException self, std::string str="Unlabeled exception") -> CLimixException

        Parameters:
            str: std::string

        __init__(limix::CLimixException self) -> CLimixException
        """
        this = _core.new_CLimixException(str)
        try: self.this.append(this)
        except: 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: self.this = this
    def addSyncParent(self, *args):
        """
        addSyncParent(CParamObject self, limix::Pbool l)

        Parameters:
            l: limix::Pbool

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

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

        Parameters:
            l: limix::Pbool

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

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

        Parameters:
            l: limix::Pbool

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

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

        Parameters:
            l: limix::Pbool

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

    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: self.this = this
    __swig_destroy__ = _core.delete_CNamedCache
    __del__ = lambda self : None;
    def set(self, *args):
        """
        set(CNamedCache self, std::string name, PCVoid m)

        Parameters:
            name: std::string
            m: PCVoid

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

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

        Parameters:
            name: std::string const &

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

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, *args):
        """
        setParams(ACovarianceFunction self, limix::CovarParams const & params)

        Parameters:
            params: limix::CovarParams const &

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

    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, *args):
        """
        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, *args)

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

        Parameters:
            self: limix::ACovarianceFunction const *

        """
        return _core.ACovarianceFunction_getParamMask(self)

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

        Parameters:
            params: limix::CovarParams const &

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

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

        Parameters:
            X: limix::CovarInput const &

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

    def setXcol(self, *args):
        """
        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, *args)

    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, *args):
        """
        setNumberDimensions(ACovarianceFunction self, limix::muint_t numberDimensions)

        Parameters:
            numberDimensions: limix::muint_t

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

    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, *args):
        """
        Kgrad_X(ACovarianceFunction self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

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

        Parameters:
            Xstar: limix::CovarInput const &

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

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

        Parameters:
            Xstar: limix::CovarInput const &

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

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

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    def Kcross_grad_X(self, *args):
        """
        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, *args)

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

        Parameters:
            d: limix::muint_t const

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

    def check_covariance_Kgrad_theta(*args):
        """
        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(*args)

    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(*args):
        """
        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(*args)

    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(*args):
        """
        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(*args)

    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(*args):
  """
    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(*args)

def ACovarianceFunction_check_covariance_Kgrad_x(*args):
  """
    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(*args)

def ACovarianceFunction_Khess_param_num(*args):
  """
    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(*args)

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: self.this = this
    __swig_destroy__ = _core.delete_CCovarianceFunctionCacheOld
    __del__ = lambda self : None;
    def setCovar(self, *args):
        """
        setCovar(CCovarianceFunctionCacheOld self, limix::PCovarianceFunction covar)

        Parameters:
            covar: limix::PCovarianceFunction

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

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

        Parameters:
            l: limix::Pbool

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

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

        Parameters:
            l: limix::Pbool

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

    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: self.this = this
    __swig_destroy__ = _core.delete_CCovLinearISO
    __del__ = lambda self : None;
    def Kcross(self, *args):
        """
        Kcross(CCovLinearISO self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

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

        Parameters:
            Xstar: limix::CovarInput const &

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

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

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    def Kcross_grad_X(self, *args):
        """
        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, *args)

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

        Parameters:
            d: limix::muint_t const

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

    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: self.this = this
    __swig_destroy__ = _core.delete_CCovLinearARD
    __del__ = lambda self : None;
    def setNumberDimensions(self, *args):
        """
        setNumberDimensions(CCovLinearARD self, limix::muint_t numberDimensions)

        Parameters:
            numberDimensions: limix::muint_t

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

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

        Parameters:
            Xstar: limix::CovarInput const &

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

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

        Parameters:
            Xstar: limix::CovarInput const &

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

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

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    def Kcross_grad_X(self, *args):
        """
        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, *args)

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

        Parameters:
            d: limix::muint_t const

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

    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, *args):
        """
        Kcross(CCovLinearISODelta self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

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

        Parameters:
            Xstar: limix::CovarInput const &

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

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

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    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, *args): 
        """
        __init__(limix::CFreeFormCF self, limix::muint_t numberGroups) -> CFreeFormCF

        Parameters:
            numberGroups: limix::muint_t

        """
        this = _core.new_CFreeFormCF(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _core.delete_CFreeFormCF
    __del__ = lambda self : None;
    def setX(self, *args):
        """
        setX(CFreeFormCF self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    def setXcol(self, *args):
        """
        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, *args)

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

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kcross_grad_X(self, *args):
        """
        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, *args)

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

        Parameters:
            d: limix::muint_t const

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

    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, *args):
        """
        setParamsCovariance(CFreeFormCF self, MatrixXd const & K0)

        Parameters:
            K0: MatrixXd const &

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

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

        Parameters:
            Xstar: limix::CovarInput const &

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

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

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    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, *args):
        """
        setParamsVarCorr(CFreeFormCF self, limix::CovarParams const & paramsVC)

        Parameters:
            paramsVC: limix::CovarParams const &

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

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

        Parameters:
            self: limix::CFreeFormCF const *

        """
        return _core.CFreeFormCF_agetL0(self)

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

        Parameters:
            i: limix::muint_t

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

    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, *args): 
        """
        __init__(limix::CRankOneCF self, limix::muint_t numberGroups) -> CRankOneCF

        Parameters:
            numberGroups: limix::muint_t

        """
        this = _core.new_CRankOneCF(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _core.delete_CRankOneCF
    __del__ = lambda self : None;
    def setX(self, *args):
        """
        setX(CRankOneCF self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    def setXcol(self, *args):
        """
        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, *args)

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

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kcross_grad_X(self, *args):
        """
        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, *args)

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

        Parameters:
            d: limix::muint_t const

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

    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, *args):
        """
        setParamsCovariance(CRankOneCF self, MatrixXd const & K0)

        Parameters:
            K0: MatrixXd const &

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

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

        Parameters:
            Xstar: limix::CovarInput const &

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

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

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    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, *args): 
        """
        __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(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _core.delete_CLowRankCF
    __del__ = lambda self : None;
    def setX(self, *args):
        """
        setX(CLowRankCF self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    def setXcol(self, *args):
        """
        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, *args)

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

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kcross_grad_X(self, *args):
        """
        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, *args)

    def Kdiag_grad_X(self, *args):
        """
        Kdiag_grad_X(CLowRankCF self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

    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, *args):
        """
        setParamsCovariance(CLowRankCF self, MatrixXd const & K0)

        Parameters:
            K0: MatrixXd const &

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

    def Kcross(self, *args):
        """
        Kcross(CLowRankCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kgrad_param(self, *args):
        """
        Kgrad_param(CLowRankCF self, limix::muint_t const i)

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    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, *args): 
        """
        __init__(limix::CFixedCF self, MatrixXd const & K0) -> CFixedCF

        Parameters:
            K0: MatrixXd const &

        """
        this = _core.new_CFixedCF(*args)
        try: self.this.append(this)
        except: 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, *args):
        """
        setParamsCovariance(CFixedCF self, MatrixXd const & K0)

        Parameters:
            K0: MatrixXd const &

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

    def Kcross(self, *args):
        """
        Kcross(CFixedCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kcross_diag(self, *args):
        """
        Kcross_diag(CFixedCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kgrad_param(self, *args):
        """
        Kgrad_param(CFixedCF self, limix::muint_t const i)

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    def Kcross_grad_X(self, *args):
        """
        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, *args)

    def Kdiag_grad_X(self, *args):
        """
        Kdiag_grad_X(CFixedCF self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

    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, *args):
        """
        setK0(CFixedCF self, MatrixXd const & K0)

        Parameters:
            K0: MatrixXd const &

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

    def setK0cross(self, *args):
        """
        setK0cross(CFixedCF self, MatrixXd const & Kcross)

        Parameters:
            Kcross: MatrixXd const &

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

    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, *args):
        """
        setK0cross_diag(CFixedCF self, VectorXd const & Kcross_diag)

        Parameters:
            Kcross_diag: VectorXd const &

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

    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, *args): 
        """
        __init__(limix::CDiagonalCF self, limix::muint_t numberGroups) -> CDiagonalCF

        Parameters:
            numberGroups: limix::muint_t

        """
        this = _core.new_CDiagonalCF(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _core.delete_CDiagonalCF
    __del__ = lambda self : None;
    def setX(self, *args):
        """
        setX(CDiagonalCF self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    def setXcol(self, *args):
        """
        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, *args)

    def Kcross_diag(self, *args):
        """
        Kcross_diag(CDiagonalCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kcross_grad_X(self, *args):
        """
        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, *args)

    def Kdiag_grad_X(self, *args):
        """
        Kdiag_grad_X(CDiagonalCF self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

    def agetScales(self):
        """
        agetScales(CDiagonalCF self)

        Parameters:
            self: limix::CDiagonalCF *

        """
        return _core.CDiagonalCF_agetScales(self)

    def setParamsCovariance(self, *args):
        """
        setParamsCovariance(CDiagonalCF self, MatrixXd const & K0)

        Parameters:
            K0: MatrixXd const &

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

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

        Parameters:
            self: limix::CDiagonalCF const *

        """
        return _core.CDiagonalCF_Kdim(self)

    def Kcross(self, *args):
        """
        Kcross(CDiagonalCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kgrad_param(self, *args):
        """
        Kgrad_param(CDiagonalCF self, limix::muint_t const i)

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    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, *args): 
        """
        __init__(limix::CRank1diagCF self, limix::muint_t numberGroups) -> CRank1diagCF

        Parameters:
            numberGroups: limix::muint_t

        """
        this = _core.new_CRank1diagCF(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _core.delete_CRank1diagCF
    __del__ = lambda self : None;
    def setX(self, *args):
        """
        setX(CRank1diagCF self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    def setXcol(self, *args):
        """
        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, *args)

    def Kcross_diag(self, *args):
        """
        Kcross_diag(CRank1diagCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kcross_grad_X(self, *args):
        """
        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, *args)

    def Kdiag_grad_X(self, *args):
        """
        Kdiag_grad_X(CRank1diagCF self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

    def agetScales(self):
        """
        agetScales(CRank1diagCF self)

        Parameters:
            self: limix::CRank1diagCF *

        """
        return _core.CRank1diagCF_agetScales(self)

    def setParamsCovariance(self, *args):
        """
        setParamsCovariance(CRank1diagCF self, MatrixXd const & K0)

        Parameters:
            K0: MatrixXd const &

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

    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, *args):
        """
        Kcross(CRank1diagCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kgrad_param(self, *args):
        """
        Kgrad_param(CRank1diagCF self, limix::muint_t const i)

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    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, *args): 
        """
        __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(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _core.delete_CSqExpCF
    __del__ = lambda self : None;
    def setX(self, *args):
        """
        setX(CSqExpCF self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    def setXcol(self, *args):
        """
        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, *args)

    def Kcross_diag(self, *args):
        """
        Kcross_diag(CSqExpCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kcross_grad_X(self, *args):
        """
        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, *args)

    def Kdiag_grad_X(self, *args):
        """
        Kdiag_grad_X(CSqExpCF self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

    def agetScales(self):
        """
        agetScales(CSqExpCF self)

        Parameters:
            self: limix::CSqExpCF *

        """
        return _core.CSqExpCF_agetScales(self)

    def setParamsCovariance(self, *args):
        """
        setParamsCovariance(CSqExpCF self, MatrixXd const & K0)

        Parameters:
            K0: MatrixXd const &

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

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

        Parameters:
            self: limix::CSqExpCF const *

        """
        return _core.CSqExpCF_Kdim(self)

    def Kcross(self, *args):
        """
        Kcross(CSqExpCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kgrad_param(self, *args):
        """
        Kgrad_param(CSqExpCF self, limix::muint_t const i)

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    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, *args): 
        """
        __init__(limix::CFixedDiagonalCF self, limix::PCovarianceFunction covar, VectorXd const & d) -> CFixedDiagonalCF

        Parameters:
            covar: limix::PCovarianceFunction
            d: VectorXd const &

        """
        this = _core.new_CFixedDiagonalCF(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _core.delete_CFixedDiagonalCF
    __del__ = lambda self : None;
    def setParams(self, *args):
        """
        setParams(CFixedDiagonalCF self, limix::CovarParams const & params)

        Parameters:
            params: limix::CovarParams const &

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

    def getParams(self):
        """
        getParams(CFixedDiagonalCF self)

        Parameters:
            self: limix::CFixedDiagonalCF const *

        """
        return _core.CFixedDiagonalCF_getParams(self)

    def setX(self, *args):
        """
        setX(CFixedDiagonalCF self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    def setXcol(self, *args):
        """
        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, *args)

    def Kcross_diag(self, *args):
        """
        Kcross_diag(CFixedDiagonalCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kcross_grad_X(self, *args):
        """
        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, *args)

    def Kdiag_grad_X(self, *args):
        """
        Kdiag_grad_X(CFixedDiagonalCF self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

    def agetScales(self):
        """
        agetScales(CFixedDiagonalCF self)

        Parameters:
            self: limix::CFixedDiagonalCF *

        """
        return _core.CFixedDiagonalCF_agetScales(self)

    def setParamsCovariance(self, *args):
        """
        setParamsCovariance(CFixedDiagonalCF self, MatrixXd const & K0)

        Parameters:
            K0: MatrixXd const &

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

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

        Parameters:
            self: limix::CFixedDiagonalCF const *

        """
        return _core.CFixedDiagonalCF_Kdim(self)

    def Kcross(self, *args):
        """
        Kcross(CFixedDiagonalCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kgrad_param(self, *args):
        """
        Kgrad_param(CFixedDiagonalCF self, limix::muint_t const i)

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    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, *args): 
        """
        __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(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _core.delete_CPolyCF
    __del__ = lambda self : None;
    def setX(self, *args):
        """
        setX(CPolyCF self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    def setXcol(self, *args):
        """
        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, *args)

    def Kcross_diag(self, *args):
        """
        Kcross_diag(CPolyCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kcross_grad_X(self, *args):
        """
        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, *args)

    def Kdiag_grad_X(self, *args):
        """
        Kdiag_grad_X(CPolyCF self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

    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, *args):
        """
        setParamsCovariance(CPolyCF self, MatrixXd const & K0)

        Parameters:
            K0: MatrixXd const &

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

    def Kcross(self, *args):
        """
        Kcross(CPolyCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kgrad_param(self, *args):
        """
        Kgrad_param(CPolyCF self, limix::muint_t const i)

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    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: self.this = this
    __swig_destroy__ = _core.delete_CCovSqexpARD
    __del__ = lambda self : None;
    def setNumberDimensions(self, *args):
        """
        setNumberDimensions(CCovSqexpARD self, limix::muint_t numberDimensions)

        Parameters:
            numberDimensions: limix::muint_t

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

    def Kcross(self, *args):
        """
        Kcross(CCovSqexpARD self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kcross_diag(self, *args):
        """
        Kcross_diag(CCovSqexpARD self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kgrad_param(self, *args):
        """
        Kgrad_param(CCovSqexpARD self, limix::muint_t const i)

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    def Kcross_grad_X(self, *args):
        """
        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, *args)

    def Kdiag_grad_X(self, *args):
        """
        Kdiag_grad_X(CCovSqexpARD self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

    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, *args):
        """
        addSyncChild(AMultiCF self, limix::Pbool l)

        Parameters:
            l: limix::Pbool

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

    def delSyncChild(self, *args):
        """
        delSyncChild(AMultiCF self, limix::Pbool l)

        Parameters:
            l: limix::Pbool

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

    def addCovariance(self, *args):
        """
        addCovariance(AMultiCF self, limix::PCovarianceFunction covar)

        Parameters:
            covar: limix::PCovarianceFunction

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

    def setCovariance(self, *args):
        """
        setCovariance(AMultiCF self, limix::muint_t i, limix::PCovarianceFunction covar)

        Parameters:
            i: limix::muint_t
            covar: limix::PCovarianceFunction

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

    def getCovariance(self, *args):
        """
        getCovariance(AMultiCF self, limix::muint_t i) -> limix::PCovarianceFunction

        Parameters:
            i: limix::muint_t

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

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

        Parameters:
            self: limix::AMultiCF const *

        """
        return _core.AMultiCF_getNumberDimensions(self)

    def setNumberDimensions(self, *args):
        """
        setNumberDimensions(AMultiCF self, limix::muint_t numberDimensions)

        Parameters:
            numberDimensions: limix::muint_t

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

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

        Parameters:
            self: limix::AMultiCF const *

        """
        return _core.AMultiCF_getNumberParams(self)

    def setX(self, *args):
        """
        setX(AMultiCF self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    def getX(self):
        """
        getX(AMultiCF self)

        Parameters:
            self: limix::AMultiCF const *

        """
        return _core.AMultiCF_getX(self)

    def setXcol(self, *args):
        """
        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, *args)

    def setParams(self, *args):
        """
        setParams(AMultiCF self, limix::CovarParams const & params)

        Parameters:
            params: limix::CovarParams const &

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

    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, *args):
        """
        setParamMask(AMultiCF self, limix::CovarParams const & params)

        Parameters:
            params: limix::CovarParams const &

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

    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, *args):
        """
        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, *args)

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: self.this = this
    __swig_destroy__ = _core.delete_CSumCF
    __del__ = lambda self : None;
    def Kcross(self, *args):
        """
        Kcross(CSumCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kcross_diag(self, *args):
        """
        Kcross_diag(CSumCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kgrad_param(self, *args):
        """
        Kgrad_param(CSumCF self, limix::muint_t const i)

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    def Kcross_grad_X(self, *args):
        """
        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, *args)

    def Kdiag_grad_X(self, *args):
        """
        Kdiag_grad_X(CSumCF self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

    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, *args):
        """
        Kgrad_X(CSumCF self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

    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: self.this = this
    __swig_destroy__ = _core.delete_CLinCombCF
    __del__ = lambda self : None;
    def setCoeff(self, *args):
        """
        setCoeff(CLinCombCF self, VectorXd const & coeff)

        Parameters:
            coeff: VectorXd const &

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

    def agetCoeff(self):
        """
        agetCoeff(CLinCombCF self)

        Parameters:
            self: limix::CLinCombCF const *

        """
        return _core.CLinCombCF_agetCoeff(self)

    def Kcross(self, *args):
        """
        Kcross(CLinCombCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kcross_diag(self, *args):
        """
        Kcross_diag(CLinCombCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kgrad_param(self, *args):
        """
        Kgrad_param(CLinCombCF self, limix::muint_t const i)

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    def Kcross_grad_X(self, *args):
        """
        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, *args)

    def Kdiag_grad_X(self, *args):
        """
        Kdiag_grad_X(CLinCombCF self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

    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, *args):
        """
        Kgrad_X(CLinCombCF self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

    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: self.this = this
    __swig_destroy__ = _core.delete_CProductCF
    __del__ = lambda self : None;
    def Kcross(self, *args):
        """
        Kcross(CProductCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kcross_diag(self, *args):
        """
        Kcross_diag(CProductCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kgrad_param(self, *args):
        """
        Kgrad_param(CProductCF self, limix::muint_t const i)

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    def Kcross_grad_X(self, *args):
        """
        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, *args)

    def Kdiag_grad_X(self, *args):
        """
        Kdiag_grad_X(CProductCF self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

    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, *args):
        """
        Kgrad_X(CProductCF self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

    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: 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, *args):
        """
        setRowCovariance(CKroneckerCF self, limix::PCovarianceFunction cov)

        Parameters:
            cov: limix::PCovarianceFunction

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

    def setColCovariance(self, *args):
        """
        setColCovariance(CKroneckerCF self, limix::PCovarianceFunction cov)

        Parameters:
            cov: limix::PCovarianceFunction

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

    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, *args):
        """
        setKroneckerIndicator(CKroneckerCF self, MatrixXi const & kroneckerIndicator)

        Parameters:
            kroneckerIndicator: MatrixXi const &

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

    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, *args):
        """
        setX(CKroneckerCF self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    def getX(self):
        """
        getX(CKroneckerCF self)

        Parameters:
            self: limix::CKroneckerCF const *

        """
        return _core.CKroneckerCF_getX(self)

    def setXcol(self, *args):
        """
        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, *args)

    def setXr(self, *args):
        """
        setXr(CKroneckerCF self, limix::CovarInput const & Xr)

        Parameters:
            Xr: limix::CovarInput const &

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

    def setXc(self, *args):
        """
        setXc(CKroneckerCF self, limix::CovarInput const & Xc)

        Parameters:
            Xc: limix::CovarInput const &

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

    def Kcross(self, *args):
        """
        Kcross(CKroneckerCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kcross_diag(self, *args):
        """
        Kcross_diag(CKroneckerCF self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kgrad_param(self, *args):
        """
        Kgrad_param(CKroneckerCF self, limix::muint_t const i)

        Parameters:
            i: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    def Kcross_grad_X(self, *args):
        """
        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, *args)

    def Kdiag_grad_X(self, *args):
        """
        Kdiag_grad_X(CKroneckerCF self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

    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, *args):
        """
        Kgrad_X(CKroneckerCF self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

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

        Parameters:
            self: limix::CKroneckerCF const *

        """
        return _core.CKroneckerCF_getName(self)

    def createKroneckerIndex(*args):
        """
        createKroneckerIndex(limix::muint_t Ncols, limix::muint_t Nrows)

        Parameters:
            Ncols: limix::muint_t
            Nrows: limix::muint_t

        """
        return _core.CKroneckerCF_createKroneckerIndex(*args)

    if _newclass:createKroneckerIndex = staticmethod(createKroneckerIndex)
    __swig_getmethods__["createKroneckerIndex"] = lambda x: createKroneckerIndex
CKroneckerCF_swigregister = _core.CKroneckerCF_swigregister
CKroneckerCF_swigregister(CKroneckerCF)

def CKroneckerCF_createKroneckerIndex(*args):
  """
    CKroneckerCF_createKroneckerIndex(limix::muint_t Ncols, limix::muint_t Nrows)

    Parameters:
        Ncols: limix::muint_t
        Nrows: limix::muint_t

    """
  return _core.CKroneckerCF_createKroneckerIndex(*args)

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, *args):
        """
        Kcross(ALikelihood self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kcross_diag(self, *args):
        """
        Kcross_diag(ALikelihood self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kcross_grad_X(self, *args):
        """
        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, *args)

    def Kdiag_grad_X(self, *args):
        """
        Kdiag_grad_X(ALikelihood self, limix::muint_t const d)

        Parameters:
            d: limix::muint_t const

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

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: 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, *args):
        """
        Kcross_diag(CLikNormalNULL self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kgrad_param(self, *args):
        """
        Kgrad_param(CLikNormalNULL self, limix::muint_t const row)

        Parameters:
            row: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    def setX(self, *args):
        """
        setX(CLikNormalNULL self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    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: 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, *args):
        """
        Kcross_diag(CLikNormalIso self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kgrad_param(self, *args):
        """
        Kgrad_param(CLikNormalIso self, limix::muint_t const row)

        Parameters:
            row: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    def setX(self, *args):
        """
        setX(CLikNormalIso self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    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: 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, *args):
        """
        Kcross_diag(CLikNormalSVD self, limix::CovarInput const & Xstar)

        Parameters:
            Xstar: limix::CovarInput const &

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

    def Kgrad_param(self, *args):
        """
        Kgrad_param(CLikNormalSVD self, limix::muint_t const row)

        Parameters:
            row: limix::muint_t const

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

    def Khess_param(self, *args):
        """
        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, *args)

    def setX(self, *args):
        """
        setX(CLikNormalSVD self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    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, *args):
        """
        setParams(ADataTerm self, MatrixXd const & params)

        Parameters:
            params: MatrixXd const &

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

    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, *args):
        """
        setY(ADataTerm self, MatrixXd const & Y)

        Parameters:
            Y: MatrixXd const &

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

    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, *args):
        """
        gradParams(ADataTerm self, MatrixXd const & KinvY) -> MatrixXd

        Parameters:
            KinvY: MatrixXd const &

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

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

        Parameters:
            self: limix::ADataTerm const *

        """
        return _core.ADataTerm_getName(self)

    def checkDimensions(self, *args):
        """
        checkDimensions(ADataTerm self, MatrixXd const & Y)

        Parameters:
            Y: MatrixXd const &

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

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: 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: 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, *args):
        """
        setParams(CLinearMean self, MatrixXd const & weightMatrix)

        Parameters:
            weightMatrix: MatrixXd const &

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

    def setFixedEffects(self, *args):
        """
        setFixedEffects(CLinearMean self, MatrixXd const & fixedEffects)

        Parameters:
            fixedEffects: MatrixXd const &

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

    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: 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, *args):
        """
        setParams(CSumLinear self, MatrixXd const & params)

        Parameters:
            params: MatrixXd const &

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

    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, *args):
        """
        appendTerm(CSumLinear self, limix::PLinearMean term)

        Parameters:
            term: limix::PLinearMean

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

    def getTerm(self, *args):
        """
        getTerm(CSumLinear self, limix::muint_t ind) -> limix::PLinearMean

        Parameters:
            ind: limix::muint_t

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

    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: self.this = this
    __swig_destroy__ = _core.delete_CKroneckerMean
    __del__ = lambda self : None;
    def setA(self, *args):
        """
        setA(CKroneckerMean self, MatrixXd const & A)

        Parameters:
            A: MatrixXd const &

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

    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, *args):
        """
        checkDimensions(CKroneckerMean self, MatrixXd const & Y, bool const checkStrictWeights)

        Parameters:
            Y: MatrixXd const &
            checkStrictWeights: bool const

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

    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: 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, *args):
        """
        __setitem__(CGPHyperParams self, std::string const & name, MatrixXd const & value)

        Parameters:
            name: std::string const &
            value: MatrixXd const &

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

    def __getitem__(self, *args):
        """
        __getitem__(CGPHyperParams self, std::string const & name)

        Parameters:
            name: std::string const &

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

    def getNames(self):
        """
        getNames(CGPHyperParams self) -> StringVec

        Parameters:
            self: limix::CGPHyperParams const *

        """
        return _core.CGPHyperParams_getNames(self)

    def exists(self, *args):
        """
        exists(CGPHyperParams self, std::string name) -> bool

        Parameters:
            name: std::string

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

    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, *args): 
        """
        __init__(limix::CGPCholCache self, CGPbase gp) -> CGPCholCache

        Parameters:
            gp: limix::CGPbase *

        """
        this = _core.new_CGPCholCache(*args)
        try: self.this.append(this)
        except: 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, *args):
        """
        setCovar(CGPCholCache self, limix::PCovarianceFunction covar)

        Parameters:
            covar: limix::PCovarianceFunction

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

    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::PLikelihood(), limix::PDataTerm data=limix::PDataTerm()) -> CGPbase

        Parameters:
            covar: limix::PCovarianceFunction
            lik: limix::PLikelihood
            data: limix::PDataTerm

        __init__(limix::CGPbase self, limix::PCovarianceFunction covar, limix::PLikelihood lik=limix::PLikelihood()) -> 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: self.this = this
    __swig_destroy__ = _core.delete_CGPbase
    __del__ = lambda self : None;
    def set_data(self, *args):
        """
        set_data(CGPbase self, MatrixXd & Y)

        Parameters:
            Y: MatrixXd &

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

    def setCovar(self, *args):
        """
        setCovar(CGPbase self, limix::PCovarianceFunction covar)

        Parameters:
            covar: limix::PCovarianceFunction

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

    def setLik(self, *args):
        """
        setLik(CGPbase self, limix::PLikelihood lik)

        Parameters:
            lik: limix::PLikelihood

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

    def setDataTerm(self, *args):
        """
        setDataTerm(CGPbase self, limix::PDataTerm data)

        Parameters:
            data: limix::PDataTerm

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

    def setLambda(self, *args):
        """
        setLambda(CGPbase self, limix::mfloat_t _lambda)

        Parameters:
            lambda: limix::mfloat_t

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

    def setLambdaG(self, *args):
        """
        setLambdaG(CGPbase self, limix::mfloat_t _lambda)

        Parameters:
            lambda: limix::mfloat_t

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

    def setLambdaN(self, *args):
        """
        setLambdaN(CGPbase self, limix::mfloat_t _lambda)

        Parameters:
            lambda: limix::mfloat_t

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

    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, *args):
        """
        getParamBounds(CGPbase self, bool upper) -> CGPHyperParams

        Parameters:
            upper: bool

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

    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, *args):
        """
        setY(CGPbase self, MatrixXd const & Y)

        Parameters:
            Y: MatrixXd const &

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

    def getX(self):
        """
        getX(CGPbase self)

        Parameters:
            self: limix::CGPbase const *

        """
        return _core.CGPbase_getX(self)

    def setX(self, *args):
        """
        setX(CGPbase self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    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, *args):
        """
        LMLhess(CGPbase self, StringVec vecLabels)

        Parameters:
            vecLabels: limix::stringVec

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

    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, *args):
        """
        getCov_laplace(CGPbase self, StringVec vecLabels)

        Parameters:
            vecLabels: limix::stringVec

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

    def getStd_laplace(self):
        """
        getStd_laplace(CGPbase self) -> CGPHyperParams

        Parameters:
            self: limix::CGPbase *

        """
        return _core.CGPbase_getStd_laplace(self)

    def predictMean(self, *args):
        """
        predictMean(CGPbase self, MatrixXd const & Xstar)

        Parameters:
            Xstar: MatrixXd const &

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

    def predictVar(self, *args):
        """
        predictVar(CGPbase self, MatrixXd const & Xstar)

        Parameters:
            Xstar: MatrixXd const &

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

    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(*args):
        """
        LMLgrad_num(CGPbase gp, limix::muint_t const i) -> double

        Parameters:
            gp: limix::CGPbase &
            i: limix::muint_t const

        """
        return _core.CGPbase_LMLgrad_num(*args)

    if _newclass:LMLgrad_num = staticmethod(LMLgrad_num)
    __swig_getmethods__["LMLgrad_num"] = lambda x: LMLgrad_num
    def LMLhess_num(*args):
        """
        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(*args)

    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(*args):
  """
    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(*args)

def CGPbase_LMLhess_num(*args):
  """
    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(*args)

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, *args): 
        """
        __init__(limix::CGPKroneckerCache self, CGPkronecker gp) -> CGPKroneckerCache

        Parameters:
            gp: limix::CGPkronecker *

        """
        this = _core.new_CGPKroneckerCache(*args)
        try: self.this.append(this)
        except: 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::PLikelihood(), 
            limix::PDataTerm mean=limix::PDataTerm()) -> 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=limix::PLikelihood()) -> 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: self.this = this
    __swig_destroy__ = _core.delete_CGPkronecker
    __del__ = lambda self : None;
    def setX_r(self, *args):
        """
        setX_r(CGPkronecker self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    def setX_c(self, *args):
        """
        setX_c(CGPkronecker self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    def setY(self, *args):
        """
        setY(CGPkronecker self, MatrixXd const & Y)

        Parameters:
            Y: MatrixXd const &

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

    def setCovar_r(self, *args):
        """
        setCovar_r(CGPkronecker self, limix::PCovarianceFunction covar)

        Parameters:
            covar: limix::PCovarianceFunction

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

    def setCovar_c(self, *args):
        """
        setCovar_c(CGPkronecker self, limix::PCovarianceFunction covar)

        Parameters:
            covar: limix::PCovarianceFunction

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

    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, *args):
        """
        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, *args)

    def predictVar(self, *args):
        """
        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, *args)

    def LMLgrad(self):
        """
        LMLgrad(CGPkronecker self) -> CGPHyperParams

        Parameters:
            self: limix::CGPkronecker *

        """
        return _core.CGPkronecker_LMLgrad(self)

    def LMLgrad_covar(self, *args):
        """
        LMLgrad_covar(CGPkronecker self, bool columns)

        Parameters:
            columns: bool

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

    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, *args):
        """
        setGplvmDimensionsC(CGPkronecker self, VectorXi gplvmDimensionsC)

        Parameters:
            gplvmDimensionsC: VectorXi

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

    def setGplvmDimensionsR(self, *args):
        """
        setGplvmDimensionsR(CGPkronecker self, VectorXi gplvmDimensionsR)

        Parameters:
            gplvmDimensionsR: VectorXi

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

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, *args): 
        """
        __init__(limix::CGPkronSumCache self, CGPkronSum gp) -> CGPkronSumCache

        Parameters:
            gp: limix::CGPkronSum *

        """
        this = _core.new_CGPkronSumCache(*args)
        try: self.this.append(this)
        except: 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, *args): 
        """
        __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(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _core.delete_CGPkronSum
    __del__ = lambda self : None;
    def setLambda(self, *args):
        """
        setLambda(CGPkronSum self, limix::mfloat_t _lambda)

        Parameters:
            lambda: limix::mfloat_t

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

    def setLambdaG(self, *args):
        """
        setLambdaG(CGPkronSum self, limix::mfloat_t _lambda)

        Parameters:
            lambda: limix::mfloat_t

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

    def setLambdaN(self, *args):
        """
        setLambdaN(CGPkronSum self, limix::mfloat_t _lambda)

        Parameters:
            lambda: limix::mfloat_t

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

    def getParamBounds(self, *args):
        """
        getParamBounds(CGPkronSum self, bool upper) -> CGPHyperParams

        Parameters:
            upper: bool

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

    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, *args):
        """
        setDebugMode(CGPkronSum self, bool debug)

        Parameters:
            debug: bool

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

    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, *args): 
        """
        __init__(limix::CGPSumCache self, CGPSum gp) -> CGPSumCache

        Parameters:
            gp: limix::CGPSum *

        """
        this = _core.new_CGPSumCache(*args)
        try: self.this.append(this)
        except: 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, *args): 
        """
        __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(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _core.delete_CGPSum
    __del__ = lambda self : None;
    def setX1(self, *args):
        """
        setX1(CGPSum self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    def setX2(self, *args):
        """
        setX2(CGPSum self, limix::CovarInput const & X)

        Parameters:
            X: limix::CovarInput const &

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

    def setY(self, *args):
        """
        setY(CGPSum self, MatrixXd const & Y)

        Parameters:
            Y: MatrixXd const &

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

    def setCovar1(self, *args):
        """
        setCovar1(CGPSum self, limix::PCovarianceFunction covar)

        Parameters:
            covar: limix::PCovarianceFunction

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

    def setCovar2(self, *args):
        """
        setCovar2(CGPSum self, limix::PCovarianceFunction covar)

        Parameters:
            covar: limix::PCovarianceFunction

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

    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, *args):
        """
        LMLgrad_covar(CGPSum self, bool cov1)

        Parameters:
            cov1: bool

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

    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)

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, *args): 
        """
        __init__(limix::CGPopt self, limix::PGPbase gp) -> CGPopt

        Parameters:
            gp: limix::PGPbase

        """
        this = _core.new_CGPopt(*args)
        try: self.this.append(this)
        except: 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, *args):
        """
        setParamMask(CGPopt self, CGPHyperParams filter)

        Parameters:
            filter: limix::CGPHyperParams

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

    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, *args):
        """
        setOptBoundLower(CGPopt self, CGPHyperParams optBoundLower)

        Parameters:
            optBoundLower: limix::CGPHyperParams

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

    def getOptBoundUpper(self):
        """
        getOptBoundUpper(CGPopt self) -> CGPHyperParams

        Parameters:
            self: limix::CGPopt const *

        """
        return _core.CGPopt_getOptBoundUpper(self)

    def setOptBoundUpper(self, *args):
        """
        setOptBoundUpper(CGPopt self, CGPHyperParams optBoundUpper)

        Parameters:
            optBoundUpper: limix::CGPHyperParams

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

    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, *args):
        """
        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, *args)

    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, *args):
        """
        setNumIntervals0(ALMM self, limix::muint_t num_intervals0)

        Parameters:
            num_intervals0: limix::muint_t

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

    def setNumIntervalsAlt(self, *args):
        """
        setNumIntervalsAlt(ALMM self, limix::muint_t num_intervalsAlt)

        Parameters:
            num_intervalsAlt: limix::muint_t

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

    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, *args):
        """
        setLdeltamin0(ALMM self, limix::mfloat_t ldeltamin0)

        Parameters:
            ldeltamin0: limix::mfloat_t

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

    def setLdeltaminAlt(self, *args):
        """
        setLdeltaminAlt(ALMM self, limix::mfloat_t ldeltaminAlt)

        Parameters:
            ldeltaminAlt: limix::mfloat_t

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

    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, *args):
        """
        setLdeltamaxAlt(ALMM self, limix::mfloat_t ldeltamaxAlt)

        Parameters:
            ldeltamaxAlt: limix::mfloat_t

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

    def getLdeltamax0(self):
        """
        getLdeltamax0(ALMM self) -> limix::mfloat_t

        Parameters:
            self: limix::ALMM const *

        """
        return _core.ALMM_getLdeltamax0(self)

    def setLdeltamax0(self, *args):
        """
        setLdeltamax0(ALMM self, limix::mfloat_t ldeltamax0)

        Parameters:
            ldeltamax0: limix::mfloat_t

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

    def setLdeltaInit(self, *args):
        """
        setLdeltaInit(ALMM self, limix::mfloat_t logdelta)

        Parameters:
            logdelta: limix::mfloat_t

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

    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, *args):
        """
        setCovs(ALMM self, MatrixXd const & covs)

        Parameters:
            covs: MatrixXd const &

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

    def setPheno(self, *args):
        """
        setPheno(ALMM self, MatrixXd const & pheno)

        Parameters:
            pheno: MatrixXd const &

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

    def setSNPs(self, *args):
        """
        setSNPs(ALMM self, MatrixXd const & snps)

        Parameters:
            snps: MatrixXd const &

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

    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, *args):
        """
        setK(ALMM self, MatrixXd const & K)

        Parameters:
            K: MatrixXd const &

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

    def setPermutation(self, *args):
        """
        setPermutation(ALMM self, VectorXi const & perm)

        Parameters:
            perm: VectorXi const &

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

    def getPermutation(self):
        """
        getPermutation(ALMM self)

        Parameters:
            self: limix::ALMM const *

        """
        return _core.ALMM_getPermutation(self)

    def setVarcompApprox0(self, *args):
        """
        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, *args)

    def setVarcompExact(self, *args):
        """
        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, *args)

    def getTestStatistics(self):
        """
        getTestStatistics(ALMM self) -> int

        Parameters:
            self: limix::ALMM const *

        """
        return _core.ALMM_getTestStatistics(self)

    def setTestStatistics(self, *args):
        """
        setTestStatistics(ALMM self, int testStatistics)

        Parameters:
            testStatistics: int

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

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: 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, *args):
        """
        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, *args)

    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, *args):
        """
        setLdeltaInit(CLMM self, limix::mfloat_t logdelta)

        Parameters:
            logdelta: limix::mfloat_t

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

    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, *args):
        """
        setCalcStes(CLMM self, bool calcStes)

        Parameters:
            calcStes: bool

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

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: self.this = this
    __swig_destroy__ = _core.delete_CInteractLMM
    __del__ = lambda self : None;
    def setInter(self, *args):
        """
        setInter(CInteractLMM self, MatrixXd const & Inter)

        Parameters:
            Inter: MatrixXd const &

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

    def getInter(self):
        """
        getInter(CInteractLMM self)

        Parameters:
            self: limix::CInteractLMM const *

        """
        return _core.CInteractLMM_getInter(self)

    def setInter0(self, *args):
        """
        setInter0(CInteractLMM self, MatrixXd const & Inter)

        Parameters:
            Inter: MatrixXd const &

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

    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, *args):
        """
        setRefitDelta0Pheno(CInteractLMM self, bool refitDelta0Pheno)

        Parameters:
            refitDelta0Pheno: bool

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

CInteractLMM_swigregister = _core.CInteractLMM_swigregister
CInteractLMM_swigregister(CInteractLMM)


def train_associations_SingleSNP(*args):
  """
    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(*args)

def optdelta(*args):
  """
    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(*args)

def optdeltaAllY(*args):
  """
    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(*args)

def nLLeval(*args):
  """
    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(*args)

def nLLevalAllY(*args):
  """
    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(*args)
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, *args): 
        """
        __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(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _core.delete_nLLevalFunctor
    __del__ = lambda self : None;
    def __call__(self, *args):
        """
        __call__(nLLevalFunctor self, limix::mfloat_t const logdelta) -> limix::mfloat_t

        Parameters:
            logdelta: limix::mfloat_t const

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

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: 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, *args):
        """
        setK1r(CKroneckerLMM self, MatrixXd const & K1r)

        Parameters:
            K1r: MatrixXd const &

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

    def setK1c(self, *args):
        """
        setK1c(CKroneckerLMM self, MatrixXd const & K1c)

        Parameters:
            K1c: MatrixXd const &

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

    def setK2r(self, *args):
        """
        setK2r(CKroneckerLMM self, MatrixXd const & K2r)

        Parameters:
            K2r: MatrixXd const &

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

    def setK2c(self, *args):
        """
        setK2c(CKroneckerLMM self, MatrixXd const & K2c)

        Parameters:
            K2c: MatrixXd const &

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

    def setPheno(self, *args):
        """
        setPheno(CKroneckerLMM self, MatrixXd const & Y)

        Parameters:
            Y: MatrixXd const &

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

    def setSNPs(self, *args):
        """
        setSNPs(CKroneckerLMM self, MatrixXd const & snps)

        Parameters:
            snps: MatrixXd const &

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

    def setSNPcoldesign(self, *args):
        """
        setSNPcoldesign(CKroneckerLMM self, MatrixXd const & design)

        Parameters:
            design: MatrixXd const &

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

    def setSNPcoldesign0_inter(self, *args):
        """
        setSNPcoldesign0_inter(CKroneckerLMM self, MatrixXd const & design)

        Parameters:
            design: MatrixXd const &

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

    def setNumIntervals0_inter(self, *args):
        """
        setNumIntervals0_inter(CKroneckerLMM self, limix::muint_t num_intervals0_inter)

        Parameters:
            num_intervals0_inter: limix::muint_t

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

    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, *args):
        """
        addCovariates(CKroneckerLMM self, MatrixXd const & covR, MatrixXd const & covCol)

        Parameters:
            covR: MatrixXd const &
            covCol: MatrixXd const &

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

    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(*args):
        """
        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(*args)

    if _newclass:nLLeval = staticmethod(nLLeval)
    __swig_getmethods__["nLLeval"] = lambda x: nLLeval
    def optdelta(*args):
        """
        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(*args)

    if _newclass:optdelta = staticmethod(optdelta)
    __swig_getmethods__["optdelta"] = lambda x: optdelta
CKroneckerLMM_swigregister = _core.CKroneckerLMM_swigregister
CKroneckerLMM_swigregister(CKroneckerLMM)

def CKroneckerLMM_nLLeval(*args):
  """
    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(*args)

def CKroneckerLMM_optdelta(*args):
  """
    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(*args)

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, *args): 
        """
        __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(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _core.delete_nLLevalKronFunctor
    __del__ = lambda self : None;
    def __call__(self, *args):
        """
        __call__(nLLevalKronFunctor self, limix::mfloat_t const logdelta) -> limix::mfloat_t

        Parameters:
            logdelta: limix::mfloat_t const

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

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, *args):
        """
        setSampleFilter(AVarianceTerm self, MatrixXb const & filter)

        Parameters:
            filter: MatrixXb const &

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

    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, *args):
        """
        setK(AVarianceTerm self, MatrixXd const & K)

        Parameters:
            K: MatrixXd const &

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

    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, *args):
        """
        setScales(AVarianceTerm self, VectorXd const & scales)

        Parameters:
            scales: VectorXd const &

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

    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: 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, *args):
        """
        setSampleFilter(CSingleTraitTerm self, MatrixXb const & filter)

        Parameters:
            filter: MatrixXb const &

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

    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, *args):
        """
        setScales(CSingleTraitTerm self, VectorXd const & scales)

        Parameters:
            scales: VectorXd const &

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

    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: 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, *args):
        """
        setSampleFilter(CMultiTraitTerm self, MatrixXb const & filter)

        Parameters:
            filter: MatrixXb const &

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

    def getNumberTraits(self):
        """
        getNumberTraits(CMultiTraitTerm self) -> limix::muint_t

        Parameters:
            self: limix::CMultiTraitTerm *

        """
        return _core.CMultiTraitTerm_getNumberTraits(self)

    def setTraitCovar(self, *args):
        """
        setTraitCovar(CMultiTraitTerm self, limix::PCovarianceFunction traitCovar)

        Parameters:
            traitCovar: limix::PCovarianceFunction

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

    def getTraitCovar(self):
        """
        getTraitCovar(CMultiTraitTerm self) -> limix::PCovarianceFunction

        Parameters:
            self: limix::CMultiTraitTerm const *

        """
        return _core.CMultiTraitTerm_getTraitCovar(self)

    def setScales(self, *args):
        """
        setScales(CMultiTraitTerm self, VectorXd const & scales)

        Parameters:
            scales: VectorXd const &

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

    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, *args): 
        """
        __init__(limix::CVarianceDecomposition self, MatrixXd const & pheno) -> CVarianceDecomposition

        Parameters:
            pheno: MatrixXd const &

        """
        this = _core.new_CVarianceDecomposition(*args)
        try: self.this.append(this)
        except: 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, *args):
        """
        setPheno(CVarianceDecomposition self, MatrixXd const & pheno)

        Parameters:
            pheno: MatrixXd const &

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

    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, *args):
        """
        getFixed(CVarianceDecomposition self, limix::muint_t const i)

        Parameters:
            i: limix::muint_t const

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

    def getDesign(self, *args):
        """
        getDesign(CVarianceDecomposition self, limix::muint_t const i)

        Parameters:
            i: limix::muint_t const

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

    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, *args):
        """
        getTerm(CVarianceDecomposition self, limix::muint_t i) -> limix::PVarianceTerm

        Parameters:
            i: limix::muint_t

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

    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(*args):
        """
        aestimateHeritability(MatrixXd const & Y, MatrixXd const & fixed, MatrixXd const & K)

        Parameters:
            Y: MatrixXd const &
            fixed: MatrixXd const &
            K: MatrixXd const &

        """
        return _core.CVarianceDecomposition_aestimateHeritability(*args)

    if _newclass:aestimateHeritability = staticmethod(aestimateHeritability)
    __swig_getmethods__["aestimateHeritability"] = lambda x: aestimateHeritability
CVarianceDecomposition_swigregister = _core.CVarianceDecomposition_swigregister
CVarianceDecomposition_swigregister(CVarianceDecomposition)

def CVarianceDecomposition_aestimateHeritability(*args):
  """
    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(*args)

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, *args):
        """
        resize(CHeaderMap self, limix::muint_t n)

        Parameters:
            n: limix::muint_t

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

    def setStr(self, *args):
        """
        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, *args)

    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: 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: 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: self.this = this
    __swig_destroy__ = _core.delete_CRWMemDataFrameXd
    __del__ = lambda self : None;
    def setRowHeader(self, *args):
        """
        setRowHeader(CRWMemDataFrameXd self, limix::PHeaderMap _in)

        Parameters:
            in: limix::PHeaderMap

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

    def setColHeader(self, *args):
        """
        setColHeader(CRWMemDataFrameXd self, limix::PHeaderMap _in)

        Parameters:
            in: limix::PHeaderMap

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

    def setMatrix(self, *args):
        """
        setMatrix(CRWMemDataFrameXd self, MatrixXd const & _in)

        Parameters:
            in: MatrixXd const &

        setMatrix(CRWMemDataFrameXd self, std::shared_ptr< MatrixXd > _in)

        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, *args):
        """
        setRowHeader(AWDataFrameXd self, limix::PHeaderMap _in)

        Parameters:
            in: limix::PHeaderMap

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

    def setColHeader(self, *args):
        """
        setColHeader(AWDataFrameXd self, limix::PHeaderMap _in)

        Parameters:
            in: limix::PHeaderMap

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

    def setMatrix(self, *args):
        """
        setMatrix(AWDataFrameXd self, MatrixXd const & _in)

        Parameters:
            in: MatrixXd const &

        setMatrix(AWDataFrameXd self, std::shared_ptr< MatrixXd > _in)

        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, *args):
        """
        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, *args)

    def read(self, *args):
        """
        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, *args)

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: 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, *args):
        """
        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, *args)

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, *args): 
        """
        __init__(limix::CTextfileGenotypeContainer self, std::string const & filename) -> CTextfileGenotypeContainer

        Parameters:
            filename: std::string const &

        """
        this = _core.new_CTextfileGenotypeContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _core.delete_CTextfileGenotypeContainer
    __del__ = lambda self : None;
    def read(self, *args):
        """
        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, *args)

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, *args): 
        """
        __init__(limix::CMemGenotypeContainer self, limix::PGenotypeBlock block) -> CMemGenotypeContainer

        Parameters:
            block: limix::PGenotypeBlock

        """
        this = _core.new_CMemGenotypeContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _core.delete_CMemGenotypeContainer
    __del__ = lambda self : None;
    def read(self, *args):
        """
        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, *args)

CMemGenotypeContainer_swigregister = _core.CMemGenotypeContainer_swigregister
CMemGenotypeContainer_swigregister(CMemGenotypeContainer)


def best_split_full_model(*args):
  """
    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(*args)

def predict_lmm_forest(*args):
  """
    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(*args)

def argOutSwigTest2(*args):
  """
    argOutSwigTest2(limix::mint_t in1, limix::mint_t in2)

    Parameters:
        in1: limix::mint_t
        in2: limix::mint_t

    """
  return _core.argOutSwigTest2(*args)

def argOutSwigTest3(*args):
  """
    argOutSwigTest3(limix::mint_t in1, limix::mint_t in2)

    Parameters:
        in1: limix::mint_t
        in2: limix::mint_t

    """
  return _core.argOutSwigTest3(*args)

def argOutSwigTest4(*args):
  """
    argOutSwigTest4(MatrixXd const & m)

    Parameters:
        m: MatrixXd const &

    """
  return _core.argOutSwigTest4(*args)
# This file is compatible with both classic and new-style classes.


