seldon.py

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



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


class SwigPyIterator(_object):
    __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__ = _seldon.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self): return _seldon.SwigPyIterator_value(self)
    def incr(self, n = 1): return _seldon.SwigPyIterator_incr(self, n)
    def decr(self, n = 1): return _seldon.SwigPyIterator_decr(self, n)
    def distance(self, *args): return _seldon.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _seldon.SwigPyIterator_equal(self, *args)
    def copy(self): return _seldon.SwigPyIterator_copy(self)
    def next(self): return _seldon.SwigPyIterator_next(self)
    def __next__(self): return _seldon.SwigPyIterator___next__(self)
    def previous(self): return _seldon.SwigPyIterator_previous(self)
    def advance(self, *args): return _seldon.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _seldon.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _seldon.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _seldon.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _seldon.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _seldon.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): return _seldon.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _seldon.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class ios_base(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ios_base, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ios_base, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    erase_event = _seldon.ios_base_erase_event
    imbue_event = _seldon.ios_base_imbue_event
    copyfmt_event = _seldon.ios_base_copyfmt_event
    def register_callback(self, *args): return _seldon.ios_base_register_callback(self, *args)
    def flags(self, *args): return _seldon.ios_base_flags(self, *args)
    def setf(self, *args): return _seldon.ios_base_setf(self, *args)
    def unsetf(self, *args): return _seldon.ios_base_unsetf(self, *args)
    def precision(self, *args): return _seldon.ios_base_precision(self, *args)
    def width(self, *args): return _seldon.ios_base_width(self, *args)
    __swig_getmethods__["sync_with_stdio"] = lambda x: _seldon.ios_base_sync_with_stdio
    if _newclass:sync_with_stdio = staticmethod(_seldon.ios_base_sync_with_stdio)
    def imbue(self, *args): return _seldon.ios_base_imbue(self, *args)
    def getloc(self): return _seldon.ios_base_getloc(self)
    __swig_getmethods__["xalloc"] = lambda x: _seldon.ios_base_xalloc
    if _newclass:xalloc = staticmethod(_seldon.ios_base_xalloc)
    def iword(self, *args): return _seldon.ios_base_iword(self, *args)
    def pword(self, *args): return _seldon.ios_base_pword(self, *args)
    __swig_destroy__ = _seldon.delete_ios_base
    __del__ = lambda self : None;
ios_base_swigregister = _seldon.ios_base_swigregister
ios_base_swigregister(ios_base)
cvar = _seldon.cvar
ios_base.boolalpha = _seldon.cvar.ios_base_boolalpha
ios_base.dec = _seldon.cvar.ios_base_dec
ios_base.fixed = _seldon.cvar.ios_base_fixed
ios_base.hex = _seldon.cvar.ios_base_hex
ios_base.internal = _seldon.cvar.ios_base_internal
ios_base.left = _seldon.cvar.ios_base_left
ios_base.oct = _seldon.cvar.ios_base_oct
ios_base.right = _seldon.cvar.ios_base_right
ios_base.scientific = _seldon.cvar.ios_base_scientific
ios_base.showbase = _seldon.cvar.ios_base_showbase
ios_base.showpoint = _seldon.cvar.ios_base_showpoint
ios_base.showpos = _seldon.cvar.ios_base_showpos
ios_base.skipws = _seldon.cvar.ios_base_skipws
ios_base.unitbuf = _seldon.cvar.ios_base_unitbuf
ios_base.uppercase = _seldon.cvar.ios_base_uppercase
ios_base.adjustfield = _seldon.cvar.ios_base_adjustfield
ios_base.basefield = _seldon.cvar.ios_base_basefield
ios_base.floatfield = _seldon.cvar.ios_base_floatfield
ios_base.badbit = _seldon.cvar.ios_base_badbit
ios_base.eofbit = _seldon.cvar.ios_base_eofbit
ios_base.failbit = _seldon.cvar.ios_base_failbit
ios_base.goodbit = _seldon.cvar.ios_base_goodbit
ios_base.app = _seldon.cvar.ios_base_app
ios_base.ate = _seldon.cvar.ios_base_ate
ios_base.binary = _seldon.cvar.ios_base_binary
ios_base.ios_base_in = _seldon.cvar.ios_base_ios_base_in
ios_base.out = _seldon.cvar.ios_base_out
ios_base.trunc = _seldon.cvar.ios_base_trunc
ios_base.beg = _seldon.cvar.ios_base_beg
ios_base.cur = _seldon.cvar.ios_base_cur
ios_base.end = _seldon.cvar.ios_base_end

def ios_base_sync_with_stdio(__sync = True):
  return _seldon.ios_base_sync_with_stdio(__sync)
ios_base_sync_with_stdio = _seldon.ios_base_sync_with_stdio

def ios_base_xalloc():
  return _seldon.ios_base_xalloc()
ios_base_xalloc = _seldon.ios_base_xalloc

class ios(ios_base):
    __swig_setmethods__ = {}
    for _s in [ios_base]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ios, name, value)
    __swig_getmethods__ = {}
    for _s in [ios_base]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ios, name)
    __repr__ = _swig_repr
    def rdstate(self): return _seldon.ios_rdstate(self)
    def clear(self, *args): return _seldon.ios_clear(self, *args)
    def setstate(self, *args): return _seldon.ios_setstate(self, *args)
    def good(self): return _seldon.ios_good(self)
    def eof(self): return _seldon.ios_eof(self)
    def fail(self): return _seldon.ios_fail(self)
    def bad(self): return _seldon.ios_bad(self)
    def exceptions(self, *args): return _seldon.ios_exceptions(self, *args)
    def __init__(self, *args): 
        this = _seldon.new_ios(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_ios
    __del__ = lambda self : None;
    def tie(self, *args): return _seldon.ios_tie(self, *args)
    def rdbuf(self, *args): return _seldon.ios_rdbuf(self, *args)
    def copyfmt(self, *args): return _seldon.ios_copyfmt(self, *args)
    def fill(self, *args): return _seldon.ios_fill(self, *args)
    def imbue(self, *args): return _seldon.ios_imbue(self, *args)
    def narrow(self, *args): return _seldon.ios_narrow(self, *args)
    def widen(self, *args): return _seldon.ios_widen(self, *args)
ios_swigregister = _seldon.ios_swigregister
ios_swigregister(ios)

class string(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, string, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, string, name)
    __repr__ = _swig_repr
    def length(self): return _seldon.string_length(self)
    def max_size(self): return _seldon.string_max_size(self)
    def capacity(self): return _seldon.string_capacity(self)
    def reserve(self, __res_arg = 0): return _seldon.string_reserve(self, __res_arg)
    def copy(self, *args): return _seldon.string_copy(self, *args)
    def c_str(self): return _seldon.string_c_str(self)
    def find(self, *args): return _seldon.string_find(self, *args)
    def rfind(self, *args): return _seldon.string_rfind(self, *args)
    def find_first_of(self, *args): return _seldon.string_find_first_of(self, *args)
    def find_last_of(self, *args): return _seldon.string_find_last_of(self, *args)
    def find_first_not_of(self, *args): return _seldon.string_find_first_not_of(self, *args)
    def find_last_not_of(self, *args): return _seldon.string_find_last_not_of(self, *args)
    def substr(self, *args): return _seldon.string_substr(self, *args)
    def empty(self): return _seldon.string_empty(self)
    def size(self): return _seldon.string_size(self)
    def swap(self, *args): return _seldon.string_swap(self, *args)
    def get_allocator(self): return _seldon.string_get_allocator(self)
    def begin(self): return _seldon.string_begin(self)
    def end(self): return _seldon.string_end(self)
    def rbegin(self): return _seldon.string_rbegin(self)
    def rend(self): return _seldon.string_rend(self)
    def erase(self, *args): return _seldon.string_erase(self, *args)
    def __init__(self, *args): 
        this = _seldon.new_string(*args)
        try: self.this.append(this)
        except: self.this = this
    def assign(self, *args): return _seldon.string_assign(self, *args)
    def resize(self, *args): return _seldon.string_resize(self, *args)
    def iterator(self): return _seldon.string_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _seldon.string___nonzero__(self)
    def __bool__(self): return _seldon.string___bool__(self)
    def __len__(self): return _seldon.string___len__(self)
    def __getslice__(self, *args): return _seldon.string___getslice__(self, *args)
    def __setslice__(self, *args): return _seldon.string___setslice__(self, *args)
    def __delslice__(self, *args): return _seldon.string___delslice__(self, *args)
    def __delitem__(self, *args): return _seldon.string___delitem__(self, *args)
    def __getitem__(self, *args): return _seldon.string___getitem__(self, *args)
    def __setitem__(self, *args): return _seldon.string___setitem__(self, *args)
    def insert(self, *args): return _seldon.string_insert(self, *args)
    def replace(self, *args): return _seldon.string_replace(self, *args)
    def __iadd__(self, *args): return _seldon.string___iadd__(self, *args)
    def __add__(self, *args): return _seldon.string___add__(self, *args)
    def __radd__(self, *args): return _seldon.string___radd__(self, *args)
    def __str__(self): return _seldon.string___str__(self)
    def __rlshift__(self, *args): return _seldon.string___rlshift__(self, *args)
    def __eq__(self, *args): return _seldon.string___eq__(self, *args)
    def __ne__(self, *args): return _seldon.string___ne__(self, *args)
    def __gt__(self, *args): return _seldon.string___gt__(self, *args)
    def __lt__(self, *args): return _seldon.string___lt__(self, *args)
    def __ge__(self, *args): return _seldon.string___ge__(self, *args)
    def __le__(self, *args): return _seldon.string___le__(self, *args)
    __swig_destroy__ = _seldon.delete_string
    __del__ = lambda self : None;
string_swigregister = _seldon.string_swigregister
string_swigregister(string)
string.npos = _seldon.cvar.string_npos

class ostream(ios):
    __swig_setmethods__ = {}
    for _s in [ios]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ostream, name, value)
    __swig_getmethods__ = {}
    for _s in [ios]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ostream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_ostream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_ostream
    __del__ = lambda self : None;
    def __lshift__(self, *args): return _seldon.ostream___lshift__(self, *args)
    def put(self, *args): return _seldon.ostream_put(self, *args)
    def write(self, *args): return _seldon.ostream_write(self, *args)
    def flush(self): return _seldon.ostream_flush(self)
    def tellp(self): return _seldon.ostream_tellp(self)
    def seekp(self, *args): return _seldon.ostream_seekp(self, *args)
ostream_swigregister = _seldon.ostream_swigregister
ostream_swigregister(ostream)
cin = cvar.cin
cout = cvar.cout
cerr = cvar.cerr
clog = cvar.clog

class istream(ios):
    __swig_setmethods__ = {}
    for _s in [ios]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, istream, name, value)
    __swig_getmethods__ = {}
    for _s in [ios]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, istream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_istream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_istream
    __del__ = lambda self : None;
    def __rshift__(self, *args): return _seldon.istream___rshift__(self, *args)
    def gcount(self): return _seldon.istream_gcount(self)
    def get(self, *args): return _seldon.istream_get(self, *args)
    def getline(self, *args): return _seldon.istream_getline(self, *args)
    def ignore(self, *args): return _seldon.istream_ignore(self, *args)
    def peek(self): return _seldon.istream_peek(self)
    def read(self, *args): return _seldon.istream_read(self, *args)
    def readsome(self, *args): return _seldon.istream_readsome(self, *args)
    def putback(self, *args): return _seldon.istream_putback(self, *args)
    def unget(self): return _seldon.istream_unget(self)
    def sync(self): return _seldon.istream_sync(self)
    def tellg(self): return _seldon.istream_tellg(self)
    def seekg(self, *args): return _seldon.istream_seekg(self, *args)
istream_swigregister = _seldon.istream_swigregister
istream_swigregister(istream)

class iostream(istream,ostream):
    __swig_setmethods__ = {}
    for _s in [istream,ostream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, iostream, name, value)
    __swig_getmethods__ = {}
    for _s in [istream,ostream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, iostream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_iostream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_iostream
    __del__ = lambda self : None;
iostream_swigregister = _seldon.iostream_swigregister
iostream_swigregister(iostream)

endl_cb_ptr = _seldon.endl_cb_ptr

def endl(*args):
  return _seldon.endl(*args)
endl = _seldon.endl
ends_cb_ptr = _seldon.ends_cb_ptr

def ends(*args):
  return _seldon.ends(*args)
ends = _seldon.ends
flush_cb_ptr = _seldon.flush_cb_ptr

def flush(*args):
  return _seldon.flush(*args)
flush = _seldon.flush
class ifstream(istream):
    __swig_setmethods__ = {}
    for _s in [istream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ifstream, name, value)
    __swig_getmethods__ = {}
    for _s in [istream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ifstream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_ifstream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_ifstream
    __del__ = lambda self : None;
    def is_open(self): return _seldon.ifstream_is_open(self)
    def close(self): return _seldon.ifstream_close(self)
ifstream_swigregister = _seldon.ifstream_swigregister
ifstream_swigregister(ifstream)

class ofstream(ostream):
    __swig_setmethods__ = {}
    for _s in [ostream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofstream, name, value)
    __swig_getmethods__ = {}
    for _s in [ostream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ofstream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_ofstream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_ofstream
    __del__ = lambda self : None;
    def is_open(self): return _seldon.ofstream_is_open(self)
    def close(self): return _seldon.ofstream_close(self)
ofstream_swigregister = _seldon.ofstream_swigregister
ofstream_swigregister(ofstream)

class Error(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Error, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Error, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_Error(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_Error
    __del__ = lambda self : None;
    def What(self): return _seldon.Error_What(self)
    def CoutWhat(self): return _seldon.Error_CoutWhat(self)
Error_swigregister = _seldon.Error_swigregister
Error_swigregister(Error)

class Undefined(Error):
    __swig_setmethods__ = {}
    for _s in [Error]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Undefined, name, value)
    __swig_getmethods__ = {}
    for _s in [Error]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Undefined, name)
    __repr__ = _swig_repr
    def __init__(self, function = "", comment = ""): 
        this = _seldon.new_Undefined(function, comment)
        try: self.this.append(this)
        except: self.this = this
    def What(self): return _seldon.Undefined_What(self)
    __swig_destroy__ = _seldon.delete_Undefined
    __del__ = lambda self : None;
Undefined_swigregister = _seldon.Undefined_swigregister
Undefined_swigregister(Undefined)

class WrongArgument(Error):
    __swig_setmethods__ = {}
    for _s in [Error]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrongArgument, name, value)
    __swig_getmethods__ = {}
    for _s in [Error]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrongArgument, name)
    __repr__ = _swig_repr
    def __init__(self, function = "", comment = ""): 
        this = _seldon.new_WrongArgument(function, comment)
        try: self.this.append(this)
        except: self.this = this
    def What(self): return _seldon.WrongArgument_What(self)
    __swig_destroy__ = _seldon.delete_WrongArgument
    __del__ = lambda self : None;
WrongArgument_swigregister = _seldon.WrongArgument_swigregister
WrongArgument_swigregister(WrongArgument)

class NoMemory(Error):
    __swig_setmethods__ = {}
    for _s in [Error]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NoMemory, name, value)
    __swig_getmethods__ = {}
    for _s in [Error]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NoMemory, name)
    __repr__ = _swig_repr
    def __init__(self, function = "", comment = ""): 
        this = _seldon.new_NoMemory(function, comment)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_NoMemory
    __del__ = lambda self : None;
NoMemory_swigregister = _seldon.NoMemory_swigregister
NoMemory_swigregister(NoMemory)

class WrongDim(Error):
    __swig_setmethods__ = {}
    for _s in [Error]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrongDim, name, value)
    __swig_getmethods__ = {}
    for _s in [Error]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrongDim, name)
    __repr__ = _swig_repr
    def __init__(self, function = "", comment = ""): 
        this = _seldon.new_WrongDim(function, comment)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_WrongDim
    __del__ = lambda self : None;
WrongDim_swigregister = _seldon.WrongDim_swigregister
WrongDim_swigregister(WrongDim)

class WrongIndex(Error):
    __swig_setmethods__ = {}
    for _s in [Error]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrongIndex, name, value)
    __swig_getmethods__ = {}
    for _s in [Error]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrongIndex, name)
    __repr__ = _swig_repr
    def __init__(self, function = "", comment = ""): 
        this = _seldon.new_WrongIndex(function, comment)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_WrongIndex
    __del__ = lambda self : None;
WrongIndex_swigregister = _seldon.WrongIndex_swigregister
WrongIndex_swigregister(WrongIndex)

class WrongRow(Error):
    __swig_setmethods__ = {}
    for _s in [Error]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrongRow, name, value)
    __swig_getmethods__ = {}
    for _s in [Error]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrongRow, name)
    __repr__ = _swig_repr
    def __init__(self, function = "", comment = ""): 
        this = _seldon.new_WrongRow(function, comment)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_WrongRow
    __del__ = lambda self : None;
WrongRow_swigregister = _seldon.WrongRow_swigregister
WrongRow_swigregister(WrongRow)

class WrongCol(Error):
    __swig_setmethods__ = {}
    for _s in [Error]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrongCol, name, value)
    __swig_getmethods__ = {}
    for _s in [Error]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrongCol, name)
    __repr__ = _swig_repr
    def __init__(self, function = "", comment = ""): 
        this = _seldon.new_WrongCol(function, comment)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_WrongCol
    __del__ = lambda self : None;
WrongCol_swigregister = _seldon.WrongCol_swigregister
WrongCol_swigregister(WrongCol)

class IOError(Error):
    __swig_setmethods__ = {}
    for _s in [Error]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IOError, name, value)
    __swig_getmethods__ = {}
    for _s in [Error]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IOError, name)
    __repr__ = _swig_repr
    def __init__(self, function = "", comment = ""): 
        this = _seldon.new_IOError(function, comment)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_IOError
    __del__ = lambda self : None;
IOError_swigregister = _seldon.IOError_swigregister
IOError_swigregister(IOError)

class LapackError(Error):
    __swig_setmethods__ = {}
    for _s in [Error]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LapackError, name, value)
    __swig_getmethods__ = {}
    for _s in [Error]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LapackError, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_LapackError(*args)
        try: self.this.append(this)
        except: self.this = this
    def What(self): return _seldon.LapackError_What(self)
    __swig_destroy__ = _seldon.delete_LapackError
    __del__ = lambda self : None;
LapackError_swigregister = _seldon.LapackError_swigregister
LapackError_swigregister(LapackError)

class LapackInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LapackInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LapackInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_LapackInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    def GetInfo(self): return _seldon.LapackInfo_GetInfo(self)
    def GetInfoRef(self): return _seldon.LapackInfo_GetInfoRef(self)
    __swig_destroy__ = _seldon.delete_LapackInfo
    __del__ = lambda self : None;
LapackInfo_swigregister = _seldon.LapackInfo_swigregister
LapackInfo_swigregister(LapackInfo)

class Str(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Str, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Str, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_Str(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_Str
    __del__ = lambda self : None;
Str_swigregister = _seldon.Str_swigregister
Str_swigregister(Str)

class RowMajor(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RowMajor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RowMajor, name)
    __repr__ = _swig_repr
    __swig_getmethods__["GetFirst"] = lambda x: _seldon.RowMajor_GetFirst
    if _newclass:GetFirst = staticmethod(_seldon.RowMajor_GetFirst)
    __swig_getmethods__["GetSecond"] = lambda x: _seldon.RowMajor_GetSecond
    if _newclass:GetSecond = staticmethod(_seldon.RowMajor_GetSecond)
    def __init__(self): 
        this = _seldon.new_RowMajor()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_RowMajor
    __del__ = lambda self : None;
RowMajor_swigregister = _seldon.RowMajor_swigregister
RowMajor_swigregister(RowMajor)

def RowMajor_GetFirst(*args):
  return _seldon.RowMajor_GetFirst(*args)
RowMajor_GetFirst = _seldon.RowMajor_GetFirst

def RowMajor_GetSecond(*args):
  return _seldon.RowMajor_GetSecond(*args)
RowMajor_GetSecond = _seldon.RowMajor_GetSecond

class RowSparse(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RowSparse, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RowSparse, name)
    __repr__ = _swig_repr
    __swig_getmethods__["GetFirst"] = lambda x: _seldon.RowSparse_GetFirst
    if _newclass:GetFirst = staticmethod(_seldon.RowSparse_GetFirst)
    __swig_getmethods__["GetSecond"] = lambda x: _seldon.RowSparse_GetSecond
    if _newclass:GetSecond = staticmethod(_seldon.RowSparse_GetSecond)
    def __init__(self): 
        this = _seldon.new_RowSparse()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_RowSparse
    __del__ = lambda self : None;
RowSparse_swigregister = _seldon.RowSparse_swigregister
RowSparse_swigregister(RowSparse)

def RowSparse_GetFirst(*args):
  return _seldon.RowSparse_GetFirst(*args)
RowSparse_GetFirst = _seldon.RowSparse_GetFirst

def RowSparse_GetSecond(*args):
  return _seldon.RowSparse_GetSecond(*args)
RowSparse_GetSecond = _seldon.RowSparse_GetSecond

class FloatDouble(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FloatDouble, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FloatDouble, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _seldon.new_FloatDouble()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_FloatDouble
    __del__ = lambda self : None;
FloatDouble_swigregister = _seldon.FloatDouble_swigregister
FloatDouble_swigregister(FloatDouble)

class ColMajorCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ColMajorCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ColMajorCollection, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _seldon.new_ColMajorCollection()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_ColMajorCollection
    __del__ = lambda self : None;
ColMajorCollection_swigregister = _seldon.ColMajorCollection_swigregister
ColMajorCollection_swigregister(ColMajorCollection)

class RowMajorCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RowMajorCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RowMajorCollection, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _seldon.new_RowMajorCollection()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_RowMajorCollection
    __del__ = lambda self : None;
RowMajorCollection_swigregister = _seldon.RowMajorCollection_swigregister
RowMajorCollection_swigregister(RowMajorCollection)

class ColSymPackedCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ColSymPackedCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ColSymPackedCollection, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _seldon.new_ColSymPackedCollection()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_ColSymPackedCollection
    __del__ = lambda self : None;
ColSymPackedCollection_swigregister = _seldon.ColSymPackedCollection_swigregister
ColSymPackedCollection_swigregister(ColSymPackedCollection)

class RowSymPackedCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RowSymPackedCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RowSymPackedCollection, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _seldon.new_RowSymPackedCollection()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_RowSymPackedCollection
    __del__ = lambda self : None;
RowSymPackedCollection_swigregister = _seldon.RowSymPackedCollection_swigregister
RowSymPackedCollection_swigregister(RowSymPackedCollection)

class ColUpTriangPackedCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ColUpTriangPackedCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ColUpTriangPackedCollection, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _seldon.new_ColUpTriangPackedCollection()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_ColUpTriangPackedCollection
    __del__ = lambda self : None;
ColUpTriangPackedCollection_swigregister = _seldon.ColUpTriangPackedCollection_swigregister
ColUpTriangPackedCollection_swigregister(ColUpTriangPackedCollection)

class RowUpTriangPackedCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RowUpTriangPackedCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RowUpTriangPackedCollection, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _seldon.new_RowUpTriangPackedCollection()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_RowUpTriangPackedCollection
    __del__ = lambda self : None;
RowUpTriangPackedCollection_swigregister = _seldon.RowUpTriangPackedCollection_swigregister
RowUpTriangPackedCollection_swigregister(RowUpTriangPackedCollection)

class General(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, General, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, General, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _seldon.new_General()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_General
    __del__ = lambda self : None;
General_swigregister = _seldon.General_swigregister
General_swigregister(General)

class Symmetric(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Symmetric, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Symmetric, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _seldon.new_Symmetric()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_Symmetric
    __del__ = lambda self : None;
Symmetric_swigregister = _seldon.Symmetric_swigregister
Symmetric_swigregister(Symmetric)

class IntMalloc(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntMalloc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntMalloc, name)
    __repr__ = _swig_repr
    def allocate(self, *args): return _seldon.IntMalloc_allocate(self, *args)
    def deallocate(self, *args): return _seldon.IntMalloc_deallocate(self, *args)
    def reallocate(self, *args): return _seldon.IntMalloc_reallocate(self, *args)
    def memoryset(self, *args): return _seldon.IntMalloc_memoryset(self, *args)
    def memorycpy(self, *args): return _seldon.IntMalloc_memorycpy(self, *args)
    def __init__(self): 
        this = _seldon.new_IntMalloc()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_IntMalloc
    __del__ = lambda self : None;
IntMalloc_swigregister = _seldon.IntMalloc_swigregister
IntMalloc_swigregister(IntMalloc)

class BaseSeldonVectorInt(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BaseSeldonVectorInt, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BaseSeldonVectorInt, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_BaseSeldonVectorInt(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_BaseSeldonVectorInt
    __del__ = lambda self : None;
    def GetM(self): return _seldon.BaseSeldonVectorInt_GetM(self)
    def GetLength(self): return _seldon.BaseSeldonVectorInt_GetLength(self)
    def GetSize(self): return _seldon.BaseSeldonVectorInt_GetSize(self)
    def GetData(self): return _seldon.BaseSeldonVectorInt_GetData(self)
    def GetDataConst(self): return _seldon.BaseSeldonVectorInt_GetDataConst(self)
    def GetDataVoid(self): return _seldon.BaseSeldonVectorInt_GetDataVoid(self)
    def GetDataConstVoid(self): return _seldon.BaseSeldonVectorInt_GetDataConstVoid(self)
BaseSeldonVectorInt_swigregister = _seldon.BaseSeldonVectorInt_swigregister
BaseSeldonVectorInt_swigregister(BaseSeldonVectorInt)

class VectorInt(BaseSeldonVectorInt):
    __swig_setmethods__ = {}
    for _s in [BaseSeldonVectorInt]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorInt, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseSeldonVectorInt]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, VectorInt, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_VectorInt(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_VectorInt
    __del__ = lambda self : None;
    def Clear(self): return _seldon.VectorInt_Clear(self)
    def Reallocate(self, *args): return _seldon.VectorInt_Reallocate(self, *args)
    def Resize(self, *args): return _seldon.VectorInt_Resize(self, *args)
    def SetData(self, *args): return _seldon.VectorInt_SetData(self, *args)
    def Nullify(self): return _seldon.VectorInt_Nullify(self)
    def __call__(self, *args): return _seldon.VectorInt___call__(self, *args)
    def Get(self, *args): return _seldon.VectorInt_Get(self, *args)
    def Copy(self, *args): return _seldon.VectorInt_Copy(self, *args)
    def Append(self, *args): return _seldon.VectorInt_Append(self, *args)
    def GetDataSize(self): return _seldon.VectorInt_GetDataSize(self)
    def Zero(self): return _seldon.VectorInt_Zero(self)
    def Fill(self): return _seldon.VectorInt_Fill(self)
    def FillRand(self): return _seldon.VectorInt_FillRand(self)
    def Print(self): return _seldon.VectorInt_Print(self)
    def GetNormInf(self): return _seldon.VectorInt_GetNormInf(self)
    def GetNormInfIndex(self): return _seldon.VectorInt_GetNormInfIndex(self)
    def Write(self, *args): return _seldon.VectorInt_Write(self, *args)
    def WriteText(self, *args): return _seldon.VectorInt_WriteText(self, *args)
    def Read(self, *args): return _seldon.VectorInt_Read(self, *args)
    def ReadText(self, *args): return _seldon.VectorInt_ReadText(self, *args)
    def __getitem__(self, *args): return _seldon.VectorInt___getitem__(self, *args)
    def __setitem__(self, *args): return _seldon.VectorInt___setitem__(self, *args)
    def __len__(self): return _seldon.VectorInt___len__(self)
VectorInt_swigregister = _seldon.VectorInt_swigregister
VectorInt_swigregister(VectorInt)

class DoubleMalloc(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleMalloc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleMalloc, name)
    __repr__ = _swig_repr
    def allocate(self, *args): return _seldon.DoubleMalloc_allocate(self, *args)
    def deallocate(self, *args): return _seldon.DoubleMalloc_deallocate(self, *args)
    def reallocate(self, *args): return _seldon.DoubleMalloc_reallocate(self, *args)
    def memoryset(self, *args): return _seldon.DoubleMalloc_memoryset(self, *args)
    def memorycpy(self, *args): return _seldon.DoubleMalloc_memorycpy(self, *args)
    def __init__(self): 
        this = _seldon.new_DoubleMalloc()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_DoubleMalloc
    __del__ = lambda self : None;
DoubleMalloc_swigregister = _seldon.DoubleMalloc_swigregister
DoubleMalloc_swigregister(DoubleMalloc)

class BaseSeldonVectorDouble(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BaseSeldonVectorDouble, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BaseSeldonVectorDouble, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_BaseSeldonVectorDouble(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_BaseSeldonVectorDouble
    __del__ = lambda self : None;
    def GetM(self): return _seldon.BaseSeldonVectorDouble_GetM(self)
    def GetLength(self): return _seldon.BaseSeldonVectorDouble_GetLength(self)
    def GetSize(self): return _seldon.BaseSeldonVectorDouble_GetSize(self)
    def GetData(self): return _seldon.BaseSeldonVectorDouble_GetData(self)
    def GetDataConst(self): return _seldon.BaseSeldonVectorDouble_GetDataConst(self)
    def GetDataVoid(self): return _seldon.BaseSeldonVectorDouble_GetDataVoid(self)
    def GetDataConstVoid(self): return _seldon.BaseSeldonVectorDouble_GetDataConstVoid(self)
BaseSeldonVectorDouble_swigregister = _seldon.BaseSeldonVectorDouble_swigregister
BaseSeldonVectorDouble_swigregister(BaseSeldonVectorDouble)

class VectorDouble(BaseSeldonVectorDouble):
    __swig_setmethods__ = {}
    for _s in [BaseSeldonVectorDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorDouble, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseSeldonVectorDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, VectorDouble, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_VectorDouble(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_VectorDouble
    __del__ = lambda self : None;
    def Clear(self): return _seldon.VectorDouble_Clear(self)
    def Reallocate(self, *args): return _seldon.VectorDouble_Reallocate(self, *args)
    def Resize(self, *args): return _seldon.VectorDouble_Resize(self, *args)
    def SetData(self, *args): return _seldon.VectorDouble_SetData(self, *args)
    def Nullify(self): return _seldon.VectorDouble_Nullify(self)
    def __call__(self, *args): return _seldon.VectorDouble___call__(self, *args)
    def Get(self, *args): return _seldon.VectorDouble_Get(self, *args)
    def Copy(self, *args): return _seldon.VectorDouble_Copy(self, *args)
    def Append(self, *args): return _seldon.VectorDouble_Append(self, *args)
    def GetDataSize(self): return _seldon.VectorDouble_GetDataSize(self)
    def Zero(self): return _seldon.VectorDouble_Zero(self)
    def Fill(self): return _seldon.VectorDouble_Fill(self)
    def FillRand(self): return _seldon.VectorDouble_FillRand(self)
    def Print(self): return _seldon.VectorDouble_Print(self)
    def GetNormInf(self): return _seldon.VectorDouble_GetNormInf(self)
    def GetNormInfIndex(self): return _seldon.VectorDouble_GetNormInfIndex(self)
    def Write(self, *args): return _seldon.VectorDouble_Write(self, *args)
    def WriteText(self, *args): return _seldon.VectorDouble_WriteText(self, *args)
    def Read(self, *args): return _seldon.VectorDouble_Read(self, *args)
    def ReadText(self, *args): return _seldon.VectorDouble_ReadText(self, *args)
    def __getitem__(self, *args): return _seldon.VectorDouble___getitem__(self, *args)
    def __setitem__(self, *args): return _seldon.VectorDouble___setitem__(self, *args)
    def __len__(self): return _seldon.VectorDouble___len__(self)
VectorDouble_swigregister = _seldon.VectorDouble_swigregister
VectorDouble_swigregister(VectorDouble)

class MatrixBaseInt(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatrixBaseInt, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MatrixBaseInt, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_MatrixBaseInt(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_MatrixBaseInt
    __del__ = lambda self : None;
    def GetM(self, *args): return _seldon.MatrixBaseInt_GetM(self, *args)
    def GetN(self, *args): return _seldon.MatrixBaseInt_GetN(self, *args)
    def GetSize(self): return _seldon.MatrixBaseInt_GetSize(self)
    def GetData(self): return _seldon.MatrixBaseInt_GetData(self)
    def GetDataConst(self): return _seldon.MatrixBaseInt_GetDataConst(self)
    def GetDataVoid(self): return _seldon.MatrixBaseInt_GetDataVoid(self)
    def GetDataConstVoid(self): return _seldon.MatrixBaseInt_GetDataConstVoid(self)
    def GetAllocator(self): return _seldon.MatrixBaseInt_GetAllocator(self)
MatrixBaseInt_swigregister = _seldon.MatrixBaseInt_swigregister
MatrixBaseInt_swigregister(MatrixBaseInt)

class MatrixPointersInt(MatrixBaseInt):
    __swig_setmethods__ = {}
    for _s in [MatrixBaseInt]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatrixPointersInt, name, value)
    __swig_getmethods__ = {}
    for _s in [MatrixBaseInt]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MatrixPointersInt, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_MatrixPointersInt(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_MatrixPointersInt
    __del__ = lambda self : None;
    def Clear(self): return _seldon.MatrixPointersInt_Clear(self)
    def GetDataSize(self): return _seldon.MatrixPointersInt_GetDataSize(self)
    def GetMe(self): return _seldon.MatrixPointersInt_GetMe(self)
    def Reallocate(self, *args): return _seldon.MatrixPointersInt_Reallocate(self, *args)
    def SetData(self, *args): return _seldon.MatrixPointersInt_SetData(self, *args)
    def Nullify(self): return _seldon.MatrixPointersInt_Nullify(self)
    def Resize(self, *args): return _seldon.MatrixPointersInt_Resize(self, *args)
    def __call__(self, *args): return _seldon.MatrixPointersInt___call__(self, *args)
    def Val(self, *args): return _seldon.MatrixPointersInt_Val(self, *args)
    def Get(self, *args): return _seldon.MatrixPointersInt_Get(self, *args)
    def Set(self, *args): return _seldon.MatrixPointersInt_Set(self, *args)
    def Copy(self, *args): return _seldon.MatrixPointersInt_Copy(self, *args)
    def GetLD(self): return _seldon.MatrixPointersInt_GetLD(self)
    def Zero(self): return _seldon.MatrixPointersInt_Zero(self)
    def SetIdentity(self): return _seldon.MatrixPointersInt_SetIdentity(self)
    def Fill(self): return _seldon.MatrixPointersInt_Fill(self)
    def FillRand(self): return _seldon.MatrixPointersInt_FillRand(self)
    def Print(self, *args): return _seldon.MatrixPointersInt_Print(self, *args)
    def Write(self, *args): return _seldon.MatrixPointersInt_Write(self, *args)
    def WriteText(self, *args): return _seldon.MatrixPointersInt_WriteText(self, *args)
    def Read(self, *args): return _seldon.MatrixPointersInt_Read(self, *args)
    def ReadText(self, *args): return _seldon.MatrixPointersInt_ReadText(self, *args)
MatrixPointersInt_swigregister = _seldon.MatrixPointersInt_swigregister
MatrixPointersInt_swigregister(MatrixPointersInt)

class MatrixInt(MatrixPointersInt):
    __swig_setmethods__ = {}
    for _s in [MatrixPointersInt]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatrixInt, name, value)
    __swig_getmethods__ = {}
    for _s in [MatrixPointersInt]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MatrixInt, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_MatrixInt(*args)
        try: self.this.append(this)
        except: self.this = this
    def __getitem__(self, *args): return _seldon.MatrixInt___getitem__(self, *args)
    def __setitem__(self, *args): return _seldon.MatrixInt___setitem__(self, *args)
    def __len__(self): return _seldon.MatrixInt___len__(self)
    __swig_destroy__ = _seldon.delete_MatrixInt
    __del__ = lambda self : None;
MatrixInt_swigregister = _seldon.MatrixInt_swigregister
MatrixInt_swigregister(MatrixInt)

class MatrixBaseDouble(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatrixBaseDouble, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MatrixBaseDouble, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_MatrixBaseDouble(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_MatrixBaseDouble
    __del__ = lambda self : None;
    def GetM(self, *args): return _seldon.MatrixBaseDouble_GetM(self, *args)
    def GetN(self, *args): return _seldon.MatrixBaseDouble_GetN(self, *args)
    def GetSize(self): return _seldon.MatrixBaseDouble_GetSize(self)
    def GetData(self): return _seldon.MatrixBaseDouble_GetData(self)
    def GetDataConst(self): return _seldon.MatrixBaseDouble_GetDataConst(self)
    def GetDataVoid(self): return _seldon.MatrixBaseDouble_GetDataVoid(self)
    def GetDataConstVoid(self): return _seldon.MatrixBaseDouble_GetDataConstVoid(self)
    def GetAllocator(self): return _seldon.MatrixBaseDouble_GetAllocator(self)
MatrixBaseDouble_swigregister = _seldon.MatrixBaseDouble_swigregister
MatrixBaseDouble_swigregister(MatrixBaseDouble)

class MatrixPointersDouble(MatrixBaseDouble):
    __swig_setmethods__ = {}
    for _s in [MatrixBaseDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatrixPointersDouble, name, value)
    __swig_getmethods__ = {}
    for _s in [MatrixBaseDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MatrixPointersDouble, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_MatrixPointersDouble(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_MatrixPointersDouble
    __del__ = lambda self : None;
    def Clear(self): return _seldon.MatrixPointersDouble_Clear(self)
    def GetDataSize(self): return _seldon.MatrixPointersDouble_GetDataSize(self)
    def GetMe(self): return _seldon.MatrixPointersDouble_GetMe(self)
    def Reallocate(self, *args): return _seldon.MatrixPointersDouble_Reallocate(self, *args)
    def SetData(self, *args): return _seldon.MatrixPointersDouble_SetData(self, *args)
    def Nullify(self): return _seldon.MatrixPointersDouble_Nullify(self)
    def Resize(self, *args): return _seldon.MatrixPointersDouble_Resize(self, *args)
    def __call__(self, *args): return _seldon.MatrixPointersDouble___call__(self, *args)
    def Val(self, *args): return _seldon.MatrixPointersDouble_Val(self, *args)
    def Get(self, *args): return _seldon.MatrixPointersDouble_Get(self, *args)
    def Set(self, *args): return _seldon.MatrixPointersDouble_Set(self, *args)
    def Copy(self, *args): return _seldon.MatrixPointersDouble_Copy(self, *args)
    def GetLD(self): return _seldon.MatrixPointersDouble_GetLD(self)
    def Zero(self): return _seldon.MatrixPointersDouble_Zero(self)
    def SetIdentity(self): return _seldon.MatrixPointersDouble_SetIdentity(self)
    def Fill(self): return _seldon.MatrixPointersDouble_Fill(self)
    def FillRand(self): return _seldon.MatrixPointersDouble_FillRand(self)
    def Print(self, *args): return _seldon.MatrixPointersDouble_Print(self, *args)
    def Write(self, *args): return _seldon.MatrixPointersDouble_Write(self, *args)
    def WriteText(self, *args): return _seldon.MatrixPointersDouble_WriteText(self, *args)
    def Read(self, *args): return _seldon.MatrixPointersDouble_Read(self, *args)
    def ReadText(self, *args): return _seldon.MatrixPointersDouble_ReadText(self, *args)
MatrixPointersDouble_swigregister = _seldon.MatrixPointersDouble_swigregister
MatrixPointersDouble_swigregister(MatrixPointersDouble)

class MatrixDouble(MatrixPointersDouble):
    __swig_setmethods__ = {}
    for _s in [MatrixPointersDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatrixDouble, name, value)
    __swig_getmethods__ = {}
    for _s in [MatrixPointersDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MatrixDouble, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_MatrixDouble(*args)
        try: self.this.append(this)
        except: self.this = this
    def __getitem__(self, *args): return _seldon.MatrixDouble___getitem__(self, *args)
    def __setitem__(self, *args): return _seldon.MatrixDouble___setitem__(self, *args)
    def __len__(self): return _seldon.MatrixDouble___len__(self)
    __swig_destroy__ = _seldon.delete_MatrixDouble
    __del__ = lambda self : None;
MatrixDouble_swigregister = _seldon.MatrixDouble_swigregister
MatrixDouble_swigregister(MatrixDouble)

class VectorSparseDouble(VectorDouble):
    __swig_setmethods__ = {}
    for _s in [VectorDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorSparseDouble, name, value)
    __swig_getmethods__ = {}
    for _s in [VectorDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, VectorSparseDouble, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_VectorSparseDouble(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_VectorSparseDouble
    __del__ = lambda self : None;
    def Clear(self): return _seldon.VectorSparseDouble_Clear(self)
    def Reallocate(self, *args): return _seldon.VectorSparseDouble_Reallocate(self, *args)
    def Resize(self, *args): return _seldon.VectorSparseDouble_Resize(self, *args)
    def SetData(self, *args): return _seldon.VectorSparseDouble_SetData(self, *args)
    def Nullify(self): return _seldon.VectorSparseDouble_Nullify(self)
    def Value(self, *args): return _seldon.VectorSparseDouble_Value(self, *args)
    def Index(self, *args): return _seldon.VectorSparseDouble_Index(self, *args)
    def __call__(self, *args): return _seldon.VectorSparseDouble___call__(self, *args)
    def Get(self, *args): return _seldon.VectorSparseDouble_Get(self, *args)
    def Val(self, *args): return _seldon.VectorSparseDouble_Val(self, *args)
    def Copy(self, *args): return _seldon.VectorSparseDouble_Copy(self, *args)
    def GetIndex(self): return _seldon.VectorSparseDouble_GetIndex(self)
    def Assemble(self): return _seldon.VectorSparseDouble_Assemble(self)
    def AddInteraction(self, *args): return _seldon.VectorSparseDouble_AddInteraction(self, *args)
    def AddInteractionRow(self, *args): return _seldon.VectorSparseDouble_AddInteractionRow(self, *args)
    def Write(self, *args): return _seldon.VectorSparseDouble_Write(self, *args)
    def WriteText(self, *args): return _seldon.VectorSparseDouble_WriteText(self, *args)
    def Read(self, *args): return _seldon.VectorSparseDouble_Read(self, *args)
    def ReadText(self, *args): return _seldon.VectorSparseDouble_ReadText(self, *args)
VectorSparseDouble_swigregister = _seldon.VectorSparseDouble_swigregister
VectorSparseDouble_swigregister(VectorSparseDouble)

class BaseMatrixSparseDouble(MatrixBaseDouble):
    __swig_setmethods__ = {}
    for _s in [MatrixBaseDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BaseMatrixSparseDouble, name, value)
    __swig_getmethods__ = {}
    for _s in [MatrixBaseDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BaseMatrixSparseDouble, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_BaseMatrixSparseDouble(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_BaseMatrixSparseDouble
    __del__ = lambda self : None;
    def Clear(self): return _seldon.BaseMatrixSparseDouble_Clear(self)
    def SetData(self, *args): return _seldon.BaseMatrixSparseDouble_SetData(self, *args)
    def Nullify(self): return _seldon.BaseMatrixSparseDouble_Nullify(self)
    def Reallocate(self, *args): return _seldon.BaseMatrixSparseDouble_Reallocate(self, *args)
    def Resize(self, *args): return _seldon.BaseMatrixSparseDouble_Resize(self, *args)
    def Copy(self, *args): return _seldon.BaseMatrixSparseDouble_Copy(self, *args)
    def GetNonZeros(self): return _seldon.BaseMatrixSparseDouble_GetNonZeros(self)
    def GetDataSize(self): return _seldon.BaseMatrixSparseDouble_GetDataSize(self)
    def GetPtr(self): return _seldon.BaseMatrixSparseDouble_GetPtr(self)
    def GetInd(self): return _seldon.BaseMatrixSparseDouble_GetInd(self)
    def GetPtrSize(self): return _seldon.BaseMatrixSparseDouble_GetPtrSize(self)
    def GetIndSize(self): return _seldon.BaseMatrixSparseDouble_GetIndSize(self)
    def __call__(self, *args): return _seldon.BaseMatrixSparseDouble___call__(self, *args)
    def Val(self, *args): return _seldon.BaseMatrixSparseDouble_Val(self, *args)
    def Get(self, *args): return _seldon.BaseMatrixSparseDouble_Get(self, *args)
    def AddInteraction(self, *args): return _seldon.BaseMatrixSparseDouble_AddInteraction(self, *args)
    def Set(self, *args): return _seldon.BaseMatrixSparseDouble_Set(self, *args)
    def Zero(self): return _seldon.BaseMatrixSparseDouble_Zero(self)
    def SetIdentity(self): return _seldon.BaseMatrixSparseDouble_SetIdentity(self)
    def Fill(self): return _seldon.BaseMatrixSparseDouble_Fill(self)
    def FillRand(self, *args): return _seldon.BaseMatrixSparseDouble_FillRand(self, *args)
    def Print(self): return _seldon.BaseMatrixSparseDouble_Print(self)
    def Write(self, *args): return _seldon.BaseMatrixSparseDouble_Write(self, *args)
    def WriteText(self, *args): return _seldon.BaseMatrixSparseDouble_WriteText(self, *args)
    def Read(self, *args): return _seldon.BaseMatrixSparseDouble_Read(self, *args)
    def ReadText(self, *args): return _seldon.BaseMatrixSparseDouble_ReadText(self, *args)
BaseMatrixSparseDouble_swigregister = _seldon.BaseMatrixSparseDouble_swigregister
BaseMatrixSparseDouble_swigregister(BaseMatrixSparseDouble)

class MatrixSparseDouble(BaseMatrixSparseDouble):
    __swig_setmethods__ = {}
    for _s in [BaseMatrixSparseDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatrixSparseDouble, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseMatrixSparseDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MatrixSparseDouble, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _seldon.new_MatrixSparseDouble(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _seldon.delete_MatrixSparseDouble
    __del__ = lambda self : None;
MatrixSparseDouble_swigregister = _seldon.MatrixSparseDouble_swigregister
MatrixSparseDouble_swigregister(MatrixSparseDouble)


def skip_vector_double(*args):
  return _seldon.skip_vector_double(*args)
skip_vector_double = _seldon.skip_vector_double

def skip_matrix_double(*args):
  return _seldon.skip_matrix_double(*args)
skip_matrix_double = _seldon.skip_matrix_double
def load_vector(filename, array = False):
    """
    Loads a Seldon vector (in double precision) from a file. If 'array' is set
    to True, the vector is converted to a numpy array.
    """
    import seldon
    if isinstance(filename, str):
        stream = seldon.ifstream(filename)
    else: # assuming 'filename' is already a stream.
        stream = filename

    vector = seldon.VectorDouble()
    vector.Read(stream, True)

    if array:
        import numpy
        vector = numpy.array(vector)

    if isinstance(filename, str):
        stream.close()

    return vector


def load_vector_list(filename, array = False, begin = 0, N = 0):
    """
    Loads a list of Seldon vectors (in double precision) from a file, skipping
    the first 'begin' vectors. If 'array' is set to True, the vectors are
    converted to numpy arrays. 'N' is the number of vectors to read; all
    vectors are read if 'N' is 0 or negative.
    """
    import seldon
    if isinstance(filename, str):
        stream = seldon.ifstream(filename)
    else: # assuming 'filename' is already a stream.
        stream = filename

    begin = max(begin, 0)
    count = 0
    while stream.peek() != -1 and count != begin:
        skip_vector_double(stream)
        count += 1

    vector_list = []
    count = 0
    while stream.peek() != -1 and (N <= 0 or count < N):
        vector = seldon.VectorDouble()
        vector.Read(stream, True)
        vector_list.append(vector)
        count += 1

    if array:
        import numpy
        vector_list = [numpy.array(x) for x in vector_list]

    if isinstance(filename, str):
        stream.close()

    return vector_list


def to_vector(v):
    """
    Converts a list or a numpy array to a Seldon vector (in double precision).
    """
    import seldon
    out = seldon.VectorDouble(len(v))
    for i in range(len(v)):
        out[i] = v[i]
    return out


def load_matrix(filename, array = False):
    """
    Loads a Seldon matrix (in double precision) from a file. If 'array' is set
    to True, the matrix is converted to a numpy array.
    """
    import seldon
    if isinstance(filename, str):
        stream = seldon.ifstream(filename)
    else: # assuming 'filename' is already a stream.
        stream = filename

    matrix = seldon.MatrixDouble()
    matrix.Read(stream, True)

    if array:
        import numpy
        matrix = numpy.array(matrix)

    if isinstance(filename, str):
        stream.close()

    return matrix


def load_matrix_list(filename, array = False, begin = 0, N = 0):
    """
    Loads a list of Seldon matrices (in double precision) from a file,
    skipping the first 'begin' matrices.. If 'array' is set to True, the
    matrices are converted to numpy arrays. 'N' is the number of matrices to
    read; all matrices are read if 'N' is 0 or negative.
    """
    import seldon
    if isinstance(filename, str):
        stream = seldon.ifstream(filename)
    else: # assuming 'filename' is already a stream.
        stream = filename

    begin = max(begin, 0)
    count = 0
    while stream.peek() != -1 and count != begin:
        skip_matrix_double(stream)
        count += 1

    matrix_list = []
    count = 0
    while stream.peek() != -1 and (N <= 0 or count < N):
        matrix = seldon.MatrixDouble()
        matrix.Read(stream, True)
        matrix_list.append(matrix)
        count += 1

    if array:
        import numpy
        matrix_list = [numpy.array(x) for x in matrix_list]

    if isinstance(filename, str):
        stream.close()

    return matrix_list


def to_matrix(m):
    """
    Converts a numpy array to a Seldon matrix (in double precision).
    """
    import seldon
    out = seldon.MatrixDouble(m.shape[0], m.shape[1])
    for i in range(m.shape[0]):
        for j in range(m.shape[1]):
            out[i, j] = m[i, j]
    return out

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