# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.5
#
# 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('_scorer', [dirname(__file__)])
        except ImportError:
            import _scorer
            return _scorer
        if fp is not None:
            try:
                _mod = imp.load_module('_scorer', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _scorer = swig_import_helper()
    del swig_import_helper
else:
    import _scorer
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


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


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

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


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except:
        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__ = _scorer.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        return _scorer.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _scorer.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _scorer.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _scorer.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _scorer.SwigPyIterator_equal(self, x)

    def copy(self):
        return _scorer.SwigPyIterator_copy(self)

    def next(self):
        return _scorer.SwigPyIterator_next(self)

    def __next__(self):
        return _scorer.SwigPyIterator___next__(self)

    def previous(self):
        return _scorer.SwigPyIterator_previous(self)

    def advance(self, n):
        return _scorer.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _scorer.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _scorer.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _scorer.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _scorer.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _scorer.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _scorer.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _scorer.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

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

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

    def __nonzero__(self):
        return _scorer.AtomVector___nonzero__(self)

    def __bool__(self):
        return _scorer.AtomVector___bool__(self)

    def __len__(self):
        return _scorer.AtomVector___len__(self)

    def pop(self):
        return _scorer.AtomVector_pop(self)

    def __getslice__(self, i, j):
        return _scorer.AtomVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _scorer.AtomVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _scorer.AtomVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _scorer.AtomVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _scorer.AtomVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _scorer.AtomVector___setitem__(self, *args)

    def append(self, x):
        return _scorer.AtomVector_append(self, x)

    def empty(self):
        return _scorer.AtomVector_empty(self)

    def size(self):
        return _scorer.AtomVector_size(self)

    def clear(self):
        return _scorer.AtomVector_clear(self)

    def swap(self, v):
        return _scorer.AtomVector_swap(self, v)

    def get_allocator(self):
        return _scorer.AtomVector_get_allocator(self)

    def begin(self):
        return _scorer.AtomVector_begin(self)

    def end(self):
        return _scorer.AtomVector_end(self)

    def rbegin(self):
        return _scorer.AtomVector_rbegin(self)

    def rend(self):
        return _scorer.AtomVector_rend(self)

    def pop_back(self):
        return _scorer.AtomVector_pop_back(self)

    def erase(self, *args):
        return _scorer.AtomVector_erase(self, *args)

    def __init__(self, *args):
        this = _scorer.new_AtomVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _scorer.AtomVector_push_back(self, x)

    def front(self):
        return _scorer.AtomVector_front(self)

    def back(self):
        return _scorer.AtomVector_back(self)

    def assign(self, n, x):
        return _scorer.AtomVector_assign(self, n, x)

    def resize(self, *args):
        return _scorer.AtomVector_resize(self, *args)

    def insert(self, *args):
        return _scorer.AtomVector_insert(self, *args)

    def reserve(self, n):
        return _scorer.AtomVector_reserve(self, n)

    def capacity(self):
        return _scorer.AtomVector_capacity(self)
    __swig_destroy__ = _scorer.delete_AtomVector
    __del__ = lambda self: None
AtomVector_swigregister = _scorer.AtomVector_swigregister
AtomVector_swigregister(AtomVector)

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

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

    def __nonzero__(self):
        return _scorer.BondVector___nonzero__(self)

    def __bool__(self):
        return _scorer.BondVector___bool__(self)

    def __len__(self):
        return _scorer.BondVector___len__(self)

    def pop(self):
        return _scorer.BondVector_pop(self)

    def __getslice__(self, i, j):
        return _scorer.BondVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _scorer.BondVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _scorer.BondVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _scorer.BondVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _scorer.BondVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _scorer.BondVector___setitem__(self, *args)

    def append(self, x):
        return _scorer.BondVector_append(self, x)

    def empty(self):
        return _scorer.BondVector_empty(self)

    def size(self):
        return _scorer.BondVector_size(self)

    def clear(self):
        return _scorer.BondVector_clear(self)

    def swap(self, v):
        return _scorer.BondVector_swap(self, v)

    def get_allocator(self):
        return _scorer.BondVector_get_allocator(self)

    def begin(self):
        return _scorer.BondVector_begin(self)

    def end(self):
        return _scorer.BondVector_end(self)

    def rbegin(self):
        return _scorer.BondVector_rbegin(self)

    def rend(self):
        return _scorer.BondVector_rend(self)

    def pop_back(self):
        return _scorer.BondVector_pop_back(self)

    def erase(self, *args):
        return _scorer.BondVector_erase(self, *args)

    def __init__(self, *args):
        this = _scorer.new_BondVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _scorer.BondVector_push_back(self, x)

    def front(self):
        return _scorer.BondVector_front(self)

    def back(self):
        return _scorer.BondVector_back(self)

    def assign(self, n, x):
        return _scorer.BondVector_assign(self, n, x)

    def resize(self, *args):
        return _scorer.BondVector_resize(self, *args)

    def insert(self, *args):
        return _scorer.BondVector_insert(self, *args)

    def reserve(self, n):
        return _scorer.BondVector_reserve(self, n)

    def capacity(self):
        return _scorer.BondVector_capacity(self)
    __swig_destroy__ = _scorer.delete_BondVector
    __del__ = lambda self: None
BondVector_swigregister = _scorer.BondVector_swigregister
BondVector_swigregister(BondVector)

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

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

    def __nonzero__(self):
        return _scorer.CoordsVector___nonzero__(self)

    def __bool__(self):
        return _scorer.CoordsVector___bool__(self)

    def __len__(self):
        return _scorer.CoordsVector___len__(self)

    def pop(self):
        return _scorer.CoordsVector_pop(self)

    def __getslice__(self, i, j):
        return _scorer.CoordsVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _scorer.CoordsVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _scorer.CoordsVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _scorer.CoordsVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _scorer.CoordsVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _scorer.CoordsVector___setitem__(self, *args)

    def append(self, x):
        return _scorer.CoordsVector_append(self, x)

    def empty(self):
        return _scorer.CoordsVector_empty(self)

    def size(self):
        return _scorer.CoordsVector_size(self)

    def clear(self):
        return _scorer.CoordsVector_clear(self)

    def swap(self, v):
        return _scorer.CoordsVector_swap(self, v)

    def get_allocator(self):
        return _scorer.CoordsVector_get_allocator(self)

    def begin(self):
        return _scorer.CoordsVector_begin(self)

    def end(self):
        return _scorer.CoordsVector_end(self)

    def rbegin(self):
        return _scorer.CoordsVector_rbegin(self)

    def rend(self):
        return _scorer.CoordsVector_rend(self)

    def pop_back(self):
        return _scorer.CoordsVector_pop_back(self)

    def erase(self, *args):
        return _scorer.CoordsVector_erase(self, *args)

    def __init__(self, *args):
        this = _scorer.new_CoordsVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _scorer.CoordsVector_push_back(self, x)

    def front(self):
        return _scorer.CoordsVector_front(self)

    def back(self):
        return _scorer.CoordsVector_back(self)

    def assign(self, n, x):
        return _scorer.CoordsVector_assign(self, n, x)

    def resize(self, *args):
        return _scorer.CoordsVector_resize(self, *args)

    def insert(self, *args):
        return _scorer.CoordsVector_insert(self, *args)

    def reserve(self, n):
        return _scorer.CoordsVector_reserve(self, n)

    def capacity(self):
        return _scorer.CoordsVector_capacity(self)
    __swig_destroy__ = _scorer.delete_CoordsVector
    __del__ = lambda self: None
CoordsVector_swigregister = _scorer.CoordsVector_swigregister
CoordsVector_swigregister(CoordsVector)

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

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

    def __nonzero__(self):
        return _scorer.DoubleVector___nonzero__(self)

    def __bool__(self):
        return _scorer.DoubleVector___bool__(self)

    def __len__(self):
        return _scorer.DoubleVector___len__(self)

    def pop(self):
        return _scorer.DoubleVector_pop(self)

    def __getslice__(self, i, j):
        return _scorer.DoubleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _scorer.DoubleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _scorer.DoubleVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _scorer.DoubleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _scorer.DoubleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _scorer.DoubleVector___setitem__(self, *args)

    def append(self, x):
        return _scorer.DoubleVector_append(self, x)

    def empty(self):
        return _scorer.DoubleVector_empty(self)

    def size(self):
        return _scorer.DoubleVector_size(self)

    def clear(self):
        return _scorer.DoubleVector_clear(self)

    def swap(self, v):
        return _scorer.DoubleVector_swap(self, v)

    def get_allocator(self):
        return _scorer.DoubleVector_get_allocator(self)

    def begin(self):
        return _scorer.DoubleVector_begin(self)

    def end(self):
        return _scorer.DoubleVector_end(self)

    def rbegin(self):
        return _scorer.DoubleVector_rbegin(self)

    def rend(self):
        return _scorer.DoubleVector_rend(self)

    def pop_back(self):
        return _scorer.DoubleVector_pop_back(self)

    def erase(self, *args):
        return _scorer.DoubleVector_erase(self, *args)

    def __init__(self, *args):
        this = _scorer.new_DoubleVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _scorer.DoubleVector_push_back(self, x)

    def front(self):
        return _scorer.DoubleVector_front(self)

    def back(self):
        return _scorer.DoubleVector_back(self)

    def assign(self, n, x):
        return _scorer.DoubleVector_assign(self, n, x)

    def resize(self, *args):
        return _scorer.DoubleVector_resize(self, *args)

    def insert(self, *args):
        return _scorer.DoubleVector_insert(self, *args)

    def reserve(self, n):
        return _scorer.DoubleVector_reserve(self, n)

    def capacity(self):
        return _scorer.DoubleVector_capacity(self)
    __swig_destroy__ = _scorer.delete_DoubleVector
    __del__ = lambda self: None
DoubleVector_swigregister = _scorer.DoubleVector_swigregister
DoubleVector_swigregister(DoubleVector)

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

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

    def __nonzero__(self):
        return _scorer.DoubleArray___nonzero__(self)

    def __bool__(self):
        return _scorer.DoubleArray___bool__(self)

    def __len__(self):
        return _scorer.DoubleArray___len__(self)

    def pop(self):
        return _scorer.DoubleArray_pop(self)

    def __getslice__(self, i, j):
        return _scorer.DoubleArray___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _scorer.DoubleArray___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _scorer.DoubleArray___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _scorer.DoubleArray___delitem__(self, *args)

    def __getitem__(self, *args):
        return _scorer.DoubleArray___getitem__(self, *args)

    def __setitem__(self, *args):
        return _scorer.DoubleArray___setitem__(self, *args)

    def append(self, x):
        return _scorer.DoubleArray_append(self, x)

    def empty(self):
        return _scorer.DoubleArray_empty(self)

    def size(self):
        return _scorer.DoubleArray_size(self)

    def clear(self):
        return _scorer.DoubleArray_clear(self)

    def swap(self, v):
        return _scorer.DoubleArray_swap(self, v)

    def get_allocator(self):
        return _scorer.DoubleArray_get_allocator(self)

    def begin(self):
        return _scorer.DoubleArray_begin(self)

    def end(self):
        return _scorer.DoubleArray_end(self)

    def rbegin(self):
        return _scorer.DoubleArray_rbegin(self)

    def rend(self):
        return _scorer.DoubleArray_rend(self)

    def pop_back(self):
        return _scorer.DoubleArray_pop_back(self)

    def erase(self, *args):
        return _scorer.DoubleArray_erase(self, *args)

    def __init__(self, *args):
        this = _scorer.new_DoubleArray(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _scorer.DoubleArray_push_back(self, x)

    def front(self):
        return _scorer.DoubleArray_front(self)

    def back(self):
        return _scorer.DoubleArray_back(self)

    def assign(self, n, x):
        return _scorer.DoubleArray_assign(self, n, x)

    def resize(self, *args):
        return _scorer.DoubleArray_resize(self, *args)

    def insert(self, *args):
        return _scorer.DoubleArray_insert(self, *args)

    def reserve(self, n):
        return _scorer.DoubleArray_reserve(self, n)

    def capacity(self):
        return _scorer.DoubleArray_capacity(self)
    __swig_destroy__ = _scorer.delete_DoubleArray
    __del__ = lambda self: None
DoubleArray_swigregister = _scorer.DoubleArray_swigregister
DoubleArray_swigregister(DoubleArray)

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

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

    def __nonzero__(self):
        return _scorer.DoubleArrayArray___nonzero__(self)

    def __bool__(self):
        return _scorer.DoubleArrayArray___bool__(self)

    def __len__(self):
        return _scorer.DoubleArrayArray___len__(self)

    def pop(self):
        return _scorer.DoubleArrayArray_pop(self)

    def __getslice__(self, i, j):
        return _scorer.DoubleArrayArray___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _scorer.DoubleArrayArray___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _scorer.DoubleArrayArray___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _scorer.DoubleArrayArray___delitem__(self, *args)

    def __getitem__(self, *args):
        return _scorer.DoubleArrayArray___getitem__(self, *args)

    def __setitem__(self, *args):
        return _scorer.DoubleArrayArray___setitem__(self, *args)

    def append(self, x):
        return _scorer.DoubleArrayArray_append(self, x)

    def empty(self):
        return _scorer.DoubleArrayArray_empty(self)

    def size(self):
        return _scorer.DoubleArrayArray_size(self)

    def clear(self):
        return _scorer.DoubleArrayArray_clear(self)

    def swap(self, v):
        return _scorer.DoubleArrayArray_swap(self, v)

    def get_allocator(self):
        return _scorer.DoubleArrayArray_get_allocator(self)

    def begin(self):
        return _scorer.DoubleArrayArray_begin(self)

    def end(self):
        return _scorer.DoubleArrayArray_end(self)

    def rbegin(self):
        return _scorer.DoubleArrayArray_rbegin(self)

    def rend(self):
        return _scorer.DoubleArrayArray_rend(self)

    def pop_back(self):
        return _scorer.DoubleArrayArray_pop_back(self)

    def erase(self, *args):
        return _scorer.DoubleArrayArray_erase(self, *args)

    def __init__(self, *args):
        this = _scorer.new_DoubleArrayArray(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _scorer.DoubleArrayArray_push_back(self, x)

    def front(self):
        return _scorer.DoubleArrayArray_front(self)

    def back(self):
        return _scorer.DoubleArrayArray_back(self)

    def assign(self, n, x):
        return _scorer.DoubleArrayArray_assign(self, n, x)

    def resize(self, *args):
        return _scorer.DoubleArrayArray_resize(self, *args)

    def insert(self, *args):
        return _scorer.DoubleArrayArray_insert(self, *args)

    def reserve(self, n):
        return _scorer.DoubleArrayArray_reserve(self, n)

    def capacity(self):
        return _scorer.DoubleArrayArray_capacity(self)
    __swig_destroy__ = _scorer.delete_DoubleArrayArray
    __del__ = lambda self: None
DoubleArrayArray_swigregister = _scorer.DoubleArrayArray_swigregister
DoubleArrayArray_swigregister(DoubleArrayArray)

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

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

    def __nonzero__(self):
        return _scorer.TermVector___nonzero__(self)

    def __bool__(self):
        return _scorer.TermVector___bool__(self)

    def __len__(self):
        return _scorer.TermVector___len__(self)

    def pop(self):
        return _scorer.TermVector_pop(self)

    def __getslice__(self, i, j):
        return _scorer.TermVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _scorer.TermVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _scorer.TermVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _scorer.TermVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _scorer.TermVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _scorer.TermVector___setitem__(self, *args)

    def append(self, x):
        return _scorer.TermVector_append(self, x)

    def empty(self):
        return _scorer.TermVector_empty(self)

    def size(self):
        return _scorer.TermVector_size(self)

    def clear(self):
        return _scorer.TermVector_clear(self)

    def swap(self, v):
        return _scorer.TermVector_swap(self, v)

    def get_allocator(self):
        return _scorer.TermVector_get_allocator(self)

    def begin(self):
        return _scorer.TermVector_begin(self)

    def end(self):
        return _scorer.TermVector_end(self)

    def rbegin(self):
        return _scorer.TermVector_rbegin(self)

    def rend(self):
        return _scorer.TermVector_rend(self)

    def pop_back(self):
        return _scorer.TermVector_pop_back(self)

    def erase(self, *args):
        return _scorer.TermVector_erase(self, *args)

    def __init__(self, *args):
        this = _scorer.new_TermVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _scorer.TermVector_push_back(self, x)

    def front(self):
        return _scorer.TermVector_front(self)

    def back(self):
        return _scorer.TermVector_back(self)

    def assign(self, n, x):
        return _scorer.TermVector_assign(self, n, x)

    def resize(self, *args):
        return _scorer.TermVector_resize(self, *args)

    def insert(self, *args):
        return _scorer.TermVector_insert(self, *args)

    def reserve(self, n):
        return _scorer.TermVector_reserve(self, n)

    def capacity(self):
        return _scorer.TermVector_capacity(self)
    __swig_destroy__ = _scorer.delete_TermVector
    __del__ = lambda self: None
TermVector_swigregister = _scorer.TermVector_swigregister
TermVector_swigregister(TermVector)

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

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

    def __nonzero__(self):
        return _scorer.DoublePtrArray___nonzero__(self)

    def __bool__(self):
        return _scorer.DoublePtrArray___bool__(self)

    def __len__(self):
        return _scorer.DoublePtrArray___len__(self)

    def pop(self):
        return _scorer.DoublePtrArray_pop(self)

    def __getslice__(self, i, j):
        return _scorer.DoublePtrArray___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _scorer.DoublePtrArray___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _scorer.DoublePtrArray___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _scorer.DoublePtrArray___delitem__(self, *args)

    def __getitem__(self, *args):
        return _scorer.DoublePtrArray___getitem__(self, *args)

    def __setitem__(self, *args):
        return _scorer.DoublePtrArray___setitem__(self, *args)

    def append(self, x):
        return _scorer.DoublePtrArray_append(self, x)

    def empty(self):
        return _scorer.DoublePtrArray_empty(self)

    def size(self):
        return _scorer.DoublePtrArray_size(self)

    def clear(self):
        return _scorer.DoublePtrArray_clear(self)

    def swap(self, v):
        return _scorer.DoublePtrArray_swap(self, v)

    def get_allocator(self):
        return _scorer.DoublePtrArray_get_allocator(self)

    def begin(self):
        return _scorer.DoublePtrArray_begin(self)

    def end(self):
        return _scorer.DoublePtrArray_end(self)

    def rbegin(self):
        return _scorer.DoublePtrArray_rbegin(self)

    def rend(self):
        return _scorer.DoublePtrArray_rend(self)

    def pop_back(self):
        return _scorer.DoublePtrArray_pop_back(self)

    def erase(self, *args):
        return _scorer.DoublePtrArray_erase(self, *args)

    def __init__(self, *args):
        this = _scorer.new_DoublePtrArray(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _scorer.DoublePtrArray_push_back(self, x)

    def front(self):
        return _scorer.DoublePtrArray_front(self)

    def back(self):
        return _scorer.DoublePtrArray_back(self)

    def assign(self, n, x):
        return _scorer.DoublePtrArray_assign(self, n, x)

    def resize(self, *args):
        return _scorer.DoublePtrArray_resize(self, *args)

    def insert(self, *args):
        return _scorer.DoublePtrArray_insert(self, *args)

    def reserve(self, n):
        return _scorer.DoublePtrArray_reserve(self, n)

    def capacity(self):
        return _scorer.DoublePtrArray_capacity(self)
    __swig_destroy__ = _scorer.delete_DoublePtrArray
    __del__ = lambda self: None
DoublePtrArray_swigregister = _scorer.DoublePtrArray_swigregister
DoublePtrArray_swigregister(DoublePtrArray)

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

    def __init__(self):
        this = _scorer.new_AutoDockParameters()
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_ad_version(self):
        return _scorer.AutoDockParameters_get_ad_version(self)

    def set_ad_version(self, version):
        return _scorer.AutoDockParameters_set_ad_version(self, version)

    def is_hbond(self, atom_type1, atom_type2):
        return _scorer.AutoDockParameters_is_hbond(self, atom_type1, atom_type2)

    def get_Rij(self, atom_type1, atom_type2):
        return _scorer.AutoDockParameters_get_Rij(self, atom_type1, atom_type2)

    def set_Rij(self, atom_type1, atom_type2, value):
        return _scorer.AutoDockParameters_set_Rij(self, atom_type1, atom_type2, value)

    def get_epsij(self, atom_type1, atom_type2):
        return _scorer.AutoDockParameters_get_epsij(self, atom_type1, atom_type2)

    def set_epsij(self, atom_type1, atom_type2, value):
        return _scorer.AutoDockParameters_set_epsij(self, atom_type1, atom_type2, value)

    def get_sol_par(self, atom_type):
        return _scorer.AutoDockParameters_get_sol_par(self, atom_type)

    def set_sol_par(self, atom_type, value):
        return _scorer.AutoDockParameters_set_sol_par(self, atom_type, value)

    def get_sol_volume(self, atom_type):
        return _scorer.AutoDockParameters_get_sol_volume(self, atom_type)

    def set_sol_volume(self, atom_type, value):
        return _scorer.AutoDockParameters_set_sol_volume(self, atom_type, value)

    def get_qasp(self):
        return _scorer.AutoDockParameters_get_qasp(self)

    def get_atom_types(self):
        return _scorer.AutoDockParameters_get_atom_types(self)
    __swig_destroy__ = _scorer.delete_AutoDockParameters
    __del__ = lambda self: None
AutoDockParameters_swigregister = _scorer.AutoDockParameters_swigregister
AutoDockParameters_swigregister(AutoDockParameters)

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

    def __init__(self, i_mol_sys):
        this = _scorer.new_PairwiseScorer(i_mol_sys)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _scorer.delete_PairwiseScorer
    __del__ = lambda self: None

    def set_molecular_system(self, i_mol_sys):
        return _scorer.PairwiseScorer_set_molecular_system(self, i_mol_sys)

    def _f(self, atom_a, atom_b):
        return _scorer.PairwiseScorer__f(self, atom_a, atom_b)

    def get_score_array(self):
        return _scorer.PairwiseScorer_get_score_array(self)

    def get_score(self):
        return _scorer.PairwiseScorer_get_score(self)

    def __call__(self, i, j):
        return _scorer.PairwiseScorer___call__(self, i, j)

    def get_molecular_system(self):
        return _scorer.PairwiseScorer_get_molecular_system(self)
    __swig_setmethods__["score_array"] = _scorer.PairwiseScorer_score_array_set
    __swig_getmethods__["score_array"] = _scorer.PairwiseScorer_score_array_get
    if _newclass:
        score_array = _swig_property(_scorer.PairwiseScorer_score_array_get, _scorer.PairwiseScorer_score_array_set)

    def get_symmetric(self):
        return _scorer.PairwiseScorer_get_symmetric(self)

    def set_symmetric(self, value):
        return _scorer.PairwiseScorer_set_symmetric(self, value)
PairwiseScorer_swigregister = _scorer.PairwiseScorer_swigregister
PairwiseScorer_swigregister(PairwiseScorer)

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

    def __init__(self, i_mol_sys):
        this = _scorer.new_DistDepPairwiseScorer(i_mol_sys)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _scorer.delete_DistDepPairwiseScorer
    __del__ = lambda self: None

    def get_score_array(self):
        return _scorer.DistDepPairwiseScorer_get_score_array(self)

    def _f(self, atom_a, atom_b, dist):
        return _scorer.DistDepPairwiseScorer__f(self, atom_a, atom_b, dist)

    def get_non_bonded_cutoff(self):
        return _scorer.DistDepPairwiseScorer_get_non_bonded_cutoff(self)

    def set_non_bonded_cutoff(self, value):
        return _scorer.DistDepPairwiseScorer_set_non_bonded_cutoff(self, value)

    def get_use_non_bonded_cutoff(self):
        return _scorer.DistDepPairwiseScorer_get_use_non_bonded_cutoff(self)

    def set_use_non_bonded_cutoff(self, value):
        return _scorer.DistDepPairwiseScorer_set_use_non_bonded_cutoff(self, value)
DistDepPairwiseScorer_swigregister = _scorer.DistDepPairwiseScorer_swigregister
DistDepPairwiseScorer_swigregister(DistDepPairwiseScorer)

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

    def __init__(self, *args):
        this = _scorer.new_MolecularSystem(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_entities(self, new_atoms):
        return _scorer.MolecularSystem_add_entities(self, new_atoms)

    def build_bonds(self, atom_set_ix):
        return _scorer.MolecularSystem_build_bonds(self, atom_set_ix)

    def rebuild_bonds(self, atom_set_ix):
        return _scorer.MolecularSystem_rebuild_bonds(self, atom_set_ix)

    def set_coords(self, atom_set_ix, new_coords):
        return _scorer.MolecularSystem_set_coords(self, atom_set_ix, new_coords)

    def check_distance_cutoff(self, ix, jx, cutoff):
        return _scorer.MolecularSystem_check_distance_cutoff(self, ix, jx, cutoff)

    def get_distance_matrix(self, ix, jx):
        return _scorer.MolecularSystem_get_distance_matrix(self, ix, jx)

    def get_atoms(self, atom_set_ix):
        return _scorer.MolecularSystem_get_atoms(self, atom_set_ix)

    def get_configuration(self):
        return _scorer.MolecularSystem_get_configuration(self)

    def set_configuration(self, ix=-1, jx=-1):
        return _scorer.MolecularSystem_set_configuration(self, ix, jx)

    def cppunit_distance_matrices(self):
        return _scorer.MolecularSystem_cppunit_distance_matrices(self)

    def compute_bonded_matrix(self, atom_set_ix):
        return _scorer.MolecularSystem_compute_bonded_matrix(self, atom_set_ix)

    def ignore_interface(self, atom_set_ix):
        return _scorer.MolecularSystem_ignore_interface(self, atom_set_ix)

    def ignore_recptor_ligand_bonds(self, mask_1_4):
        return _scorer.MolecularSystem_ignore_recptor_ligand_bonds(self, mask_1_4)
    __swig_setmethods__["mask"] = _scorer.MolecularSystem_mask_set
    __swig_getmethods__["mask"] = _scorer.MolecularSystem_mask_get
    if _newclass:
        mask = _swig_property(_scorer.MolecularSystem_mask_get, _scorer.MolecularSystem_mask_set)

    def get_mask(self):
        return _scorer.MolecularSystem_get_mask(self)

    def set_use_mask(self, useIt):
        return _scorer.MolecularSystem_set_use_mask(self, useIt)

    def get_use_mask(self):
        return _scorer.MolecularSystem_get_use_mask(self)

    def is_masked(self, ix, jx):
        return _scorer.MolecularSystem_is_masked(self, ix, jx)

    def set_mask(self, ix, jx, value):
        return _scorer.MolecularSystem_set_mask(self, ix, jx, value)
    __swig_destroy__ = _scorer.delete_MolecularSystem
    __del__ = lambda self: None

    def compute_distance_matrix(self, ix, jx):
        return _scorer.MolecularSystem_compute_distance_matrix(self, ix, jx)

    def clear_distance_matrix(self, atom_set_ix):
        return _scorer.MolecularSystem_clear_distance_matrix(self, atom_set_ix)
MolecularSystem_swigregister = _scorer.MolecularSystem_swigregister
MolecularSystem_swigregister(MolecularSystem)

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

    def __eq__(self, other):
        return _scorer.Atom___eq__(self, other)

    def __gt__(self, other):
        return _scorer.Atom___gt__(self, other)

    def __lt__(self, other):
        return _scorer.Atom___lt__(self, other)

    def get_name(self):
        return _scorer.Atom_get_name(self)

    def set_name(self, name):
        return _scorer.Atom_set_name(self, name)

    def get_element(self):
        return _scorer.Atom_get_element(self)

    def set_element(self, element):
        return _scorer.Atom_set_element(self, element)

    def get_atom_type(self):
        return _scorer.Atom_get_atom_type(self)

    def set_atom_type(self, atom_type):
        return _scorer.Atom_set_atom_type(self, atom_type)

    def get_coords(self):
        return _scorer.Atom_get_coords(self)

    def set_coords(self, coords):
        return _scorer.Atom_set_coords(self, coords)

    def get_charge(self):
        return _scorer.Atom_get_charge(self)

    def set_charge(self, charge):
        return _scorer.Atom_set_charge(self, charge)

    def get_atvol(self):
        return _scorer.Atom_get_atvol(self)

    def set_atvol(self, atvol):
        return _scorer.Atom_set_atvol(self, atvol)

    def get_atsolpar(self):
        return _scorer.Atom_get_atsolpar(self)

    def set_atsolpar(self, atsolpar):
        return _scorer.Atom_set_atsolpar(self, atsolpar)

    def get_bond_ord_rad(self):
        return _scorer.Atom_get_bond_ord_rad(self)

    def set_bond_ord_rad(self, bond_ord_rad):
        return _scorer.Atom_set_bond_ord_rad(self, bond_ord_rad)

    def get_bonds(self):
        return _scorer.Atom_get_bonds(self)

    def build_bonds(self, atoms):
        return _scorer.Atom_build_bonds(self, atoms)

    def has_bond(self, other):
        return _scorer.Atom_has_bond(self, other)

    def could_bond_to(self, other):
        return _scorer.Atom_could_bond_to(self, other)

    def get_bonds_built(self):
        return _scorer.Atom_get_bonds_built(self)

    def remove_bonds(self):
        return _scorer.Atom_remove_bonds(self)

    def get_atInterface(self):
        return _scorer.Atom_get_atInterface(self)

    def set_atInterface(self, arg2):
        return _scorer.Atom_set_atInterface(self, arg2)

    def __init__(self, *args):
        this = _scorer.new_Atom(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _scorer.delete_Atom
    __del__ = lambda self: None
Atom_swigregister = _scorer.Atom_swigregister
Atom_swigregister(Atom)

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

    def __init__(self):
        this = _scorer.new_Molecule()
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_filename(self):
        return _scorer.Molecule_get_filename(self)

    def get_name(self):
        return _scorer.Molecule_get_name(self)

    def get_atoms(self, *args):
        return _scorer.Molecule_get_atoms(self, *args)

    def read_pdb(self, i_filename):
        return _scorer.Molecule_read_pdb(self, i_filename)

    def read_pdbq(self, i_filename):
        return _scorer.Molecule_read_pdbq(self, i_filename)
    __swig_destroy__ = _scorer.delete_Molecule
    __del__ = lambda self: None
Molecule_swigregister = _scorer.Molecule_swigregister
Molecule_swigregister(Molecule)

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

    def __init__(self, i_ms):
        this = _scorer.new_HydrogenBonding(i_ms)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _scorer.delete_HydrogenBonding
    __del__ = lambda self: None

    def _f(self, atom_a, atom_b, i_dist, bx):
        return _scorer.HydrogenBonding__f(self, atom_a, atom_b, i_dist, bx)

    def calc_closestH(self, distance_matrix):
        return _scorer.HydrogenBonding_calc_closestH(self, distance_matrix)

    def get_Rij(self, atom_type1, atom_type2):
        return _scorer.HydrogenBonding_get_Rij(self, atom_type1, atom_type2)

    def set_Rij(self, atom_type1, atom_type2, value):
        return _scorer.HydrogenBonding_set_Rij(self, atom_type1, atom_type2, value)

    def get_epsij(self, atom_type1, atom_type2):
        return _scorer.HydrogenBonding_get_epsij(self, atom_type1, atom_type2)

    def set_epsij(self, atom_type1, atom_type2, value):
        return _scorer.HydrogenBonding_set_epsij(self, atom_type1, atom_type2, value)

    def get_smoothing(self):
        return _scorer.HydrogenBonding_get_smoothing(self)

    def set_smoothing(self, value):
        return _scorer.HydrogenBonding_set_smoothing(self, value)

    def get_directional(self):
        return _scorer.HydrogenBonding_get_directional(self)

    def set_directional(self, value):
        return _scorer.HydrogenBonding_set_directional(self, value)

    def get_NA_HDfactor(self):
        return _scorer.HydrogenBonding_get_NA_HDfactor(self)

    def set_NA_HDfactor(self, value):
        return _scorer.HydrogenBonding_set_NA_HDfactor(self, value)

    def get_score_array(self):
        return _scorer.HydrogenBonding_get_score_array(self)

    def cppunit_get_H_factor(self, atom_ia, probe, dist):
        return _scorer.HydrogenBonding_cppunit_get_H_factor(self, atom_ia, probe, dist)

    def cppunit_get_O_factor(self, atom_ia, probe, dist):
        return _scorer.HydrogenBonding_cppunit_get_O_factor(self, atom_ia, probe, dist)
HydrogenBonding_swigregister = _scorer.HydrogenBonding_swigregister
HydrogenBonding_swigregister(HydrogenBonding)

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

    def __init__(self, i_ms):
        this = _scorer.new_VanDerWaals(i_ms)
        try:
            self.this.append(this)
        except:
            self.this = this

    def _f(self, atom_a, atom_b, i_dist):
        return _scorer.VanDerWaals__f(self, atom_a, atom_b, i_dist)

    def get_smoothing(self):
        return _scorer.VanDerWaals_get_smoothing(self)

    def set_smoothing(self, value):
        return _scorer.VanDerWaals_set_smoothing(self, value)

    def set_smoothing_width(self, width):
        return _scorer.VanDerWaals_set_smoothing_width(self, width)
    __swig_destroy__ = _scorer.delete_VanDerWaals
    __del__ = lambda self: None
VanDerWaals_swigregister = _scorer.VanDerWaals_swigregister
VanDerWaals_swigregister(VanDerWaals)

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

    def __init__(self, i_ms):
        this = _scorer.new_WeightedMultiTerm(i_ms)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _scorer.delete_WeightedMultiTerm
    __del__ = lambda self: None

    def add_term(self, term, weight):
        return _scorer.WeightedMultiTerm_add_term(self, term, weight)

    def get_terms(self):
        return _scorer.WeightedMultiTerm_get_terms(self)

    def get_weights(self):
        return _scorer.WeightedMultiTerm_get_weights(self)

    def get_score_array(self):
        return _scorer.WeightedMultiTerm_get_score_array(self)

    def get_score(self):
        return _scorer.WeightedMultiTerm_get_score(self)

    def clear_score_array(self):
        return _scorer.WeightedMultiTerm_clear_score_array(self)
WeightedMultiTerm_swigregister = _scorer.WeightedMultiTerm_swigregister
WeightedMultiTerm_swigregister(WeightedMultiTerm)

class Coords(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Coords, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Coords, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _scorer.Coords_x_set
    __swig_getmethods__["x"] = _scorer.Coords_x_get
    if _newclass:
        x = _swig_property(_scorer.Coords_x_get, _scorer.Coords_x_set)
    __swig_setmethods__["y"] = _scorer.Coords_y_set
    __swig_getmethods__["y"] = _scorer.Coords_y_get
    if _newclass:
        y = _swig_property(_scorer.Coords_y_get, _scorer.Coords_y_set)
    __swig_setmethods__["z"] = _scorer.Coords_z_set
    __swig_getmethods__["z"] = _scorer.Coords_z_get
    if _newclass:
        z = _swig_property(_scorer.Coords_z_get, _scorer.Coords_z_set)
    __swig_destroy__ = _scorer.delete_Coords
    __del__ = lambda self: None

    def __init__(self, *args):
        this = _scorer.new_Coords(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __eq__(self, other):
        return _scorer.Coords___eq__(self, other)

    def vector_to(self, other):
        return _scorer.Coords_vector_to(self, other)

    def vector_to_ptr(self, other):
        return _scorer.Coords_vector_to_ptr(self, other)

    def dot(self, other):
        return _scorer.Coords_dot(self, other)

    def __neg__(self):
        return _scorer.Coords___neg__(self)

    def __sub__(self, other):
        return _scorer.Coords___sub__(self, other)

    def __add__(self, other):
        return _scorer.Coords___add__(self, other)

    def __mul__(self, other):
        return _scorer.Coords___mul__(self, other)

    def mag(self):
        return _scorer.Coords_mag(self)

    def mag2(self):
        return _scorer.Coords_mag2(self)

    def normalize(self, *args):
        return _scorer.Coords_normalize(self, *args)

    def scale(self, scale_factor):
        return _scorer.Coords_scale(self, scale_factor)
Coords_swigregister = _scorer.Coords_swigregister
Coords_swigregister(Coords)

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

    def __init__(self, i_ms):
        this = _scorer.new_Electrostatics(i_ms)
        try:
            self.this.append(this)
        except:
            self.this = this

    def _f(self, atom_a, atom_b, dist):
        return _scorer.Electrostatics__f(self, atom_a, atom_b, dist)
    __swig_destroy__ = _scorer.delete_Electrostatics
    __del__ = lambda self: None
Electrostatics_swigregister = _scorer.Electrostatics_swigregister
Electrostatics_swigregister(Electrostatics)

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

    def __init__(self, i_ms):
        this = _scorer.new_Desolvation(i_ms)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _scorer.delete_Desolvation
    __del__ = lambda self: None
Desolvation_swigregister = _scorer.Desolvation_swigregister
Desolvation_swigregister(Desolvation)

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

    def __init__(self, i_ms):
        this = _scorer.new_Desolvation3(i_ms)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _scorer.delete_Desolvation3
    __del__ = lambda self: None
Desolvation3_swigregister = _scorer.Desolvation3_swigregister
Desolvation3_swigregister(Desolvation3)

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

    def __init__(self, i_ms):
        this = _scorer.new_Desolvation4(i_ms)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _scorer.delete_Desolvation4
    __del__ = lambda self: None
Desolvation4_swigregister = _scorer.Desolvation4_swigregister
Desolvation4_swigregister(Desolvation4)

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

    def set_molecular_system(self, i_ms):
        return _scorer.InternalEnergy_set_molecular_system(self, i_ms)

    def __init__(self, i_ms):
        this = _scorer.new_InternalEnergy(i_ms)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _scorer.delete_InternalEnergy
    __del__ = lambda self: None

    def add_term(self, term, weight):
        return _scorer.InternalEnergy_add_term(self, term, weight)

    def get_terms(self):
        return _scorer.InternalEnergy_get_terms(self)

    def get_weights(self):
        return _scorer.InternalEnergy_get_weights(self)

    def get_score_array(self):
        return _scorer.InternalEnergy_get_score_array(self)

    def get_score(self):
        return _scorer.InternalEnergy_get_score(self)
    __swig_setmethods__["score_array"] = _scorer.InternalEnergy_score_array_set
    __swig_getmethods__["score_array"] = _scorer.InternalEnergy_score_array_get
    if _newclass:
        score_array = _swig_property(_scorer.InternalEnergy_score_array_get, _scorer.InternalEnergy_score_array_set)
InternalEnergy_swigregister = _scorer.InternalEnergy_swigregister
InternalEnergy_swigregister(InternalEnergy)


def updateCoords(splitPoint, msSize, ms, atomicCoords):
    return _scorer.updateCoords(splitPoint, msSize, ms, atomicCoords)
updateCoords = _scorer.updateCoords

def printAtomicCoordinate(atomicCoords, clen):
    return _scorer.printAtomicCoordinate(atomicCoords, clen)
printAtomicCoordinate = _scorer.printAtomicCoordinate

def isNAN(n):
    return _scorer.isNAN(n)
isNAN = _scorer.isNAN
# This file is compatible with both classic and new-style classes.


