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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _DataStats
else:
    import _DataStats

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        return _DataStats.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _DataStats:
_DataStats.SwigPyIterator_swigregister(SwigPyIterator)

class CharVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __nonzero__(self):
        return _DataStats.CharVector___nonzero__(self)

    def __bool__(self):
        return _DataStats.CharVector___bool__(self)

    def __len__(self):
        return _DataStats.CharVector___len__(self)

    def __getslice__(self, i, j):
        return _DataStats.CharVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _DataStats.CharVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _DataStats.CharVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _DataStats.CharVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _DataStats.CharVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _DataStats.CharVector___setitem__(self, *args)

    def pop(self):
        return _DataStats.CharVector_pop(self)

    def append(self, x):
        return _DataStats.CharVector_append(self, x)

    def empty(self):
        return _DataStats.CharVector_empty(self)

    def size(self):
        return _DataStats.CharVector_size(self)

    def swap(self, v):
        return _DataStats.CharVector_swap(self, v)

    def begin(self):
        return _DataStats.CharVector_begin(self)

    def end(self):
        return _DataStats.CharVector_end(self)

    def rbegin(self):
        return _DataStats.CharVector_rbegin(self)

    def rend(self):
        return _DataStats.CharVector_rend(self)

    def clear(self):
        return _DataStats.CharVector_clear(self)

    def get_allocator(self):
        return _DataStats.CharVector_get_allocator(self)

    def pop_back(self):
        return _DataStats.CharVector_pop_back(self)

    def erase(self, *args):
        return _DataStats.CharVector_erase(self, *args)

    def __init__(self, *args):
        _DataStats.CharVector_swiginit(self, _DataStats.new_CharVector(*args))

    def push_back(self, x):
        return _DataStats.CharVector_push_back(self, x)

    def front(self):
        return _DataStats.CharVector_front(self)

    def back(self):
        return _DataStats.CharVector_back(self)

    def assign(self, n, x):
        return _DataStats.CharVector_assign(self, n, x)

    def resize(self, *args):
        return _DataStats.CharVector_resize(self, *args)

    def insert(self, *args):
        return _DataStats.CharVector_insert(self, *args)

    def reserve(self, n):
        return _DataStats.CharVector_reserve(self, n)

    def capacity(self):
        return _DataStats.CharVector_capacity(self)
    __swig_destroy__ = _DataStats.delete_CharVector

# Register CharVector in _DataStats:
_DataStats.CharVector_swigregister(CharVector)

class CharHistVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _DataStats.CharHistVector_swiginit(self, _DataStats.new_CharHistVector(*args))
    first = property(_DataStats.CharHistVector_first_get, _DataStats.CharHistVector_first_set)
    second = property(_DataStats.CharHistVector_second_get, _DataStats.CharHistVector_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _DataStats.delete_CharHistVector

# Register CharHistVector in _DataStats:
_DataStats.CharHistVector_swigregister(CharHistVector)

class UCharVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __nonzero__(self):
        return _DataStats.UCharVector___nonzero__(self)

    def __bool__(self):
        return _DataStats.UCharVector___bool__(self)

    def __len__(self):
        return _DataStats.UCharVector___len__(self)

    def __getslice__(self, i, j):
        return _DataStats.UCharVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _DataStats.UCharVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _DataStats.UCharVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _DataStats.UCharVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _DataStats.UCharVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _DataStats.UCharVector___setitem__(self, *args)

    def pop(self):
        return _DataStats.UCharVector_pop(self)

    def append(self, x):
        return _DataStats.UCharVector_append(self, x)

    def empty(self):
        return _DataStats.UCharVector_empty(self)

    def size(self):
        return _DataStats.UCharVector_size(self)

    def swap(self, v):
        return _DataStats.UCharVector_swap(self, v)

    def begin(self):
        return _DataStats.UCharVector_begin(self)

    def end(self):
        return _DataStats.UCharVector_end(self)

    def rbegin(self):
        return _DataStats.UCharVector_rbegin(self)

    def rend(self):
        return _DataStats.UCharVector_rend(self)

    def clear(self):
        return _DataStats.UCharVector_clear(self)

    def get_allocator(self):
        return _DataStats.UCharVector_get_allocator(self)

    def pop_back(self):
        return _DataStats.UCharVector_pop_back(self)

    def erase(self, *args):
        return _DataStats.UCharVector_erase(self, *args)

    def __init__(self, *args):
        _DataStats.UCharVector_swiginit(self, _DataStats.new_UCharVector(*args))

    def push_back(self, x):
        return _DataStats.UCharVector_push_back(self, x)

    def front(self):
        return _DataStats.UCharVector_front(self)

    def back(self):
        return _DataStats.UCharVector_back(self)

    def assign(self, n, x):
        return _DataStats.UCharVector_assign(self, n, x)

    def resize(self, *args):
        return _DataStats.UCharVector_resize(self, *args)

    def insert(self, *args):
        return _DataStats.UCharVector_insert(self, *args)

    def reserve(self, n):
        return _DataStats.UCharVector_reserve(self, n)

    def capacity(self):
        return _DataStats.UCharVector_capacity(self)
    __swig_destroy__ = _DataStats.delete_UCharVector

# Register UCharVector in _DataStats:
_DataStats.UCharVector_swigregister(UCharVector)

class UCharHistVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _DataStats.UCharHistVector_swiginit(self, _DataStats.new_UCharHistVector(*args))
    first = property(_DataStats.UCharHistVector_first_get, _DataStats.UCharHistVector_first_set)
    second = property(_DataStats.UCharHistVector_second_get, _DataStats.UCharHistVector_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _DataStats.delete_UCharHistVector

# Register UCharHistVector in _DataStats:
_DataStats.UCharHistVector_swigregister(UCharHistVector)

class UInt16Vector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __nonzero__(self):
        return _DataStats.UInt16Vector___nonzero__(self)

    def __bool__(self):
        return _DataStats.UInt16Vector___bool__(self)

    def __len__(self):
        return _DataStats.UInt16Vector___len__(self)

    def __getslice__(self, i, j):
        return _DataStats.UInt16Vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _DataStats.UInt16Vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _DataStats.UInt16Vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _DataStats.UInt16Vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _DataStats.UInt16Vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _DataStats.UInt16Vector___setitem__(self, *args)

    def pop(self):
        return _DataStats.UInt16Vector_pop(self)

    def append(self, x):
        return _DataStats.UInt16Vector_append(self, x)

    def empty(self):
        return _DataStats.UInt16Vector_empty(self)

    def size(self):
        return _DataStats.UInt16Vector_size(self)

    def swap(self, v):
        return _DataStats.UInt16Vector_swap(self, v)

    def begin(self):
        return _DataStats.UInt16Vector_begin(self)

    def end(self):
        return _DataStats.UInt16Vector_end(self)

    def rbegin(self):
        return _DataStats.UInt16Vector_rbegin(self)

    def rend(self):
        return _DataStats.UInt16Vector_rend(self)

    def clear(self):
        return _DataStats.UInt16Vector_clear(self)

    def get_allocator(self):
        return _DataStats.UInt16Vector_get_allocator(self)

    def pop_back(self):
        return _DataStats.UInt16Vector_pop_back(self)

    def erase(self, *args):
        return _DataStats.UInt16Vector_erase(self, *args)

    def __init__(self, *args):
        _DataStats.UInt16Vector_swiginit(self, _DataStats.new_UInt16Vector(*args))

    def push_back(self, x):
        return _DataStats.UInt16Vector_push_back(self, x)

    def front(self):
        return _DataStats.UInt16Vector_front(self)

    def back(self):
        return _DataStats.UInt16Vector_back(self)

    def assign(self, n, x):
        return _DataStats.UInt16Vector_assign(self, n, x)

    def resize(self, *args):
        return _DataStats.UInt16Vector_resize(self, *args)

    def insert(self, *args):
        return _DataStats.UInt16Vector_insert(self, *args)

    def reserve(self, n):
        return _DataStats.UInt16Vector_reserve(self, n)

    def capacity(self):
        return _DataStats.UInt16Vector_capacity(self)
    __swig_destroy__ = _DataStats.delete_UInt16Vector

# Register UInt16Vector in _DataStats:
_DataStats.UInt16Vector_swigregister(UInt16Vector)

class UInt64Vector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __nonzero__(self):
        return _DataStats.UInt64Vector___nonzero__(self)

    def __bool__(self):
        return _DataStats.UInt64Vector___bool__(self)

    def __len__(self):
        return _DataStats.UInt64Vector___len__(self)

    def __getslice__(self, i, j):
        return _DataStats.UInt64Vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _DataStats.UInt64Vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _DataStats.UInt64Vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _DataStats.UInt64Vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _DataStats.UInt64Vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _DataStats.UInt64Vector___setitem__(self, *args)

    def pop(self):
        return _DataStats.UInt64Vector_pop(self)

    def append(self, x):
        return _DataStats.UInt64Vector_append(self, x)

    def empty(self):
        return _DataStats.UInt64Vector_empty(self)

    def size(self):
        return _DataStats.UInt64Vector_size(self)

    def swap(self, v):
        return _DataStats.UInt64Vector_swap(self, v)

    def begin(self):
        return _DataStats.UInt64Vector_begin(self)

    def end(self):
        return _DataStats.UInt64Vector_end(self)

    def rbegin(self):
        return _DataStats.UInt64Vector_rbegin(self)

    def rend(self):
        return _DataStats.UInt64Vector_rend(self)

    def clear(self):
        return _DataStats.UInt64Vector_clear(self)

    def get_allocator(self):
        return _DataStats.UInt64Vector_get_allocator(self)

    def pop_back(self):
        return _DataStats.UInt64Vector_pop_back(self)

    def erase(self, *args):
        return _DataStats.UInt64Vector_erase(self, *args)

    def __init__(self, *args):
        _DataStats.UInt64Vector_swiginit(self, _DataStats.new_UInt64Vector(*args))

    def push_back(self, x):
        return _DataStats.UInt64Vector_push_back(self, x)

    def front(self):
        return _DataStats.UInt64Vector_front(self)

    def back(self):
        return _DataStats.UInt64Vector_back(self)

    def assign(self, n, x):
        return _DataStats.UInt64Vector_assign(self, n, x)

    def resize(self, *args):
        return _DataStats.UInt64Vector_resize(self, *args)

    def insert(self, *args):
        return _DataStats.UInt64Vector_insert(self, *args)

    def reserve(self, n):
        return _DataStats.UInt64Vector_reserve(self, n)

    def capacity(self):
        return _DataStats.UInt64Vector_capacity(self)
    __swig_destroy__ = _DataStats.delete_UInt64Vector

# Register UInt64Vector in _DataStats:
_DataStats.UInt64Vector_swigregister(UInt64Vector)

class UInt64Array1024(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __nonzero__(self):
        return _DataStats.UInt64Array1024___nonzero__(self)

    def __bool__(self):
        return _DataStats.UInt64Array1024___bool__(self)

    def __len__(self):
        return _DataStats.UInt64Array1024___len__(self)

    def __getslice__(self, i, j):
        return _DataStats.UInt64Array1024___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _DataStats.UInt64Array1024___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _DataStats.UInt64Array1024___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _DataStats.UInt64Array1024___delitem__(self, *args)

    def __getitem__(self, *args):
        return _DataStats.UInt64Array1024___getitem__(self, *args)

    def __setitem__(self, *args):
        return _DataStats.UInt64Array1024___setitem__(self, *args)

    def __init__(self, *args):
        _DataStats.UInt64Array1024_swiginit(self, _DataStats.new_UInt64Array1024(*args))

    def empty(self):
        return _DataStats.UInt64Array1024_empty(self)

    def size(self):
        return _DataStats.UInt64Array1024_size(self)

    def swap(self, v):
        return _DataStats.UInt64Array1024_swap(self, v)

    def begin(self):
        return _DataStats.UInt64Array1024_begin(self)

    def end(self):
        return _DataStats.UInt64Array1024_end(self)

    def rbegin(self):
        return _DataStats.UInt64Array1024_rbegin(self)

    def rend(self):
        return _DataStats.UInt64Array1024_rend(self)

    def front(self):
        return _DataStats.UInt64Array1024_front(self)

    def back(self):
        return _DataStats.UInt64Array1024_back(self)

    def fill(self, u):
        return _DataStats.UInt64Array1024_fill(self, u)
    __swig_destroy__ = _DataStats.delete_UInt64Array1024

# Register UInt64Array1024 in _DataStats:
_DataStats.UInt64Array1024_swigregister(UInt64Array1024)

class UInt16HistVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _DataStats.UInt16HistVector_swiginit(self, _DataStats.new_UInt16HistVector(*args))
    first = property(_DataStats.UInt16HistVector_first_get, _DataStats.UInt16HistVector_first_set)
    second = property(_DataStats.UInt16HistVector_second_get, _DataStats.UInt16HistVector_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _DataStats.delete_UInt16HistVector

# Register UInt16HistVector in _DataStats:
_DataStats.UInt16HistVector_swigregister(UInt16HistVector)

class UInt64HistVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _DataStats.UInt64HistVector_swiginit(self, _DataStats.new_UInt64HistVector(*args))
    first = property(_DataStats.UInt64HistVector_first_get, _DataStats.UInt64HistVector_first_set)
    second = property(_DataStats.UInt64HistVector_second_get, _DataStats.UInt64HistVector_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _DataStats.delete_UInt64HistVector

# Register UInt64HistVector in _DataStats:
_DataStats.UInt64HistVector_swigregister(UInt64HistVector)

class DoubleVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _DataStats.DoubleVector_swiginit(self, _DataStats.new_DoubleVector(*args))

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

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

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

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

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

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

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

    def capacity(self):
        return _DataStats.DoubleVector_capacity(self)
    __swig_destroy__ = _DataStats.delete_DoubleVector

# Register DoubleVector in _DataStats:
_DataStats.DoubleVector_swigregister(DoubleVector)

class DoubleHistVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _DataStats.DoubleHistVector_swiginit(self, _DataStats.new_DoubleHistVector(*args))
    first = property(_DataStats.DoubleHistVector_first_get, _DataStats.DoubleHistVector_first_set)
    second = property(_DataStats.DoubleHistVector_second_get, _DataStats.DoubleHistVector_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _DataStats.delete_DoubleHistVector

# Register DoubleHistVector in _DataStats:
_DataStats.DoubleHistVector_swigregister(DoubleHistVector)

class UInt32Pair(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _DataStats.UInt32Pair_swiginit(self, _DataStats.new_UInt32Pair(*args))
    first = property(_DataStats.UInt32Pair_first_get, _DataStats.UInt32Pair_first_set)
    second = property(_DataStats.UInt32Pair_second_get, _DataStats.UInt32Pair_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _DataStats.delete_UInt32Pair

# Register UInt32Pair in _DataStats:
_DataStats.UInt32Pair_swigregister(UInt32Pair)

class UInt64MapUInt32Pair(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

    def __nonzero__(self):
        return _DataStats.UInt64MapUInt32Pair___nonzero__(self)

    def __bool__(self):
        return _DataStats.UInt64MapUInt32Pair___bool__(self)

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

    def __getitem__(self, key):
        return _DataStats.UInt64MapUInt32Pair___getitem__(self, key)

    def __delitem__(self, key):
        return _DataStats.UInt64MapUInt32Pair___delitem__(self, key)

    def has_key(self, key):
        return _DataStats.UInt64MapUInt32Pair_has_key(self, key)

    def keys(self):
        return _DataStats.UInt64MapUInt32Pair_keys(self)

    def values(self):
        return _DataStats.UInt64MapUInt32Pair_values(self)

    def items(self):
        return _DataStats.UInt64MapUInt32Pair_items(self)

    def __contains__(self, key):
        return _DataStats.UInt64MapUInt32Pair___contains__(self, key)

    def key_iterator(self):
        return _DataStats.UInt64MapUInt32Pair_key_iterator(self)

    def value_iterator(self):
        return _DataStats.UInt64MapUInt32Pair_value_iterator(self)

    def __setitem__(self, *args):
        return _DataStats.UInt64MapUInt32Pair___setitem__(self, *args)

    def asdict(self):
        return _DataStats.UInt64MapUInt32Pair_asdict(self)

    def __init__(self, *args):
        _DataStats.UInt64MapUInt32Pair_swiginit(self, _DataStats.new_UInt64MapUInt32Pair(*args))

    def empty(self):
        return _DataStats.UInt64MapUInt32Pair_empty(self)

    def size(self):
        return _DataStats.UInt64MapUInt32Pair_size(self)

    def swap(self, v):
        return _DataStats.UInt64MapUInt32Pair_swap(self, v)

    def begin(self):
        return _DataStats.UInt64MapUInt32Pair_begin(self)

    def end(self):
        return _DataStats.UInt64MapUInt32Pair_end(self)

    def rbegin(self):
        return _DataStats.UInt64MapUInt32Pair_rbegin(self)

    def rend(self):
        return _DataStats.UInt64MapUInt32Pair_rend(self)

    def clear(self):
        return _DataStats.UInt64MapUInt32Pair_clear(self)

    def get_allocator(self):
        return _DataStats.UInt64MapUInt32Pair_get_allocator(self)

    def count(self, x):
        return _DataStats.UInt64MapUInt32Pair_count(self, x)

    def erase(self, *args):
        return _DataStats.UInt64MapUInt32Pair_erase(self, *args)

    def find(self, x):
        return _DataStats.UInt64MapUInt32Pair_find(self, x)

    def lower_bound(self, x):
        return _DataStats.UInt64MapUInt32Pair_lower_bound(self, x)

    def upper_bound(self, x):
        return _DataStats.UInt64MapUInt32Pair_upper_bound(self, x)
    __swig_destroy__ = _DataStats.delete_UInt64MapUInt32Pair

# Register UInt64MapUInt32Pair in _DataStats:
_DataStats.UInt64MapUInt32Pair_swigregister(UInt64MapUInt32Pair)

class SurroundingBaseSurrounding(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    kStartPos = _DataStats.SurroundingBaseSurrounding_kStartPos

    @staticmethod
    def Length():
        return _DataStats.SurroundingBaseSurrounding_Length()

    @staticmethod
    def StartPos(pos, seq_len):
        return _DataStats.SurroundingBaseSurrounding_StartPos(pos, seq_len)

    @staticmethod
    def EndPos(pos, seq_len):
        return _DataStats.SurroundingBaseSurrounding_EndPos(pos, seq_len)

    @staticmethod
    def StartPosReverse(pos, seq_len):
        return _DataStats.SurroundingBaseSurrounding_StartPosReverse(pos, seq_len)

    @staticmethod
    def EndPosReverse(pos, seq_len):
        return _DataStats.SurroundingBaseSurrounding_EndPosReverse(pos, seq_len)

    def __init__(self, *args):
        _DataStats.SurroundingBaseSurrounding_swiginit(self, _DataStats.new_SurroundingBaseSurrounding(*args))

    def BaseAt(self, pos):
        return _DataStats.SurroundingBaseSurrounding_BaseAt(self, pos)

    def Valid(self):
        return _DataStats.SurroundingBaseSurrounding_Valid(self)

    def Forward(self, sequence, pos):
        return _DataStats.SurroundingBaseSurrounding_Forward(self, sequence, pos)

    def Reverse(self, sequence, pos):
        return _DataStats.SurroundingBaseSurrounding_Reverse(self, sequence, pos)

    def ForwardWithN(self, sequence, pos):
        return _DataStats.SurroundingBaseSurrounding_ForwardWithN(self, sequence, pos)

    def ReverseWithN(self, sequence, pos):
        return _DataStats.SurroundingBaseSurrounding_ReverseWithN(self, sequence, pos)

    def UpdateForward(self, sequence, new_pos):
        return _DataStats.SurroundingBaseSurrounding_UpdateForward(self, sequence, new_pos)

    def UpdateReverse(self, sequence, new_pos):
        return _DataStats.SurroundingBaseSurrounding_UpdateReverse(self, sequence, new_pos)

    def RollBackReverse(self, sequence, new_pos):
        return _DataStats.SurroundingBaseSurrounding_RollBackReverse(self, sequence, new_pos)

    def UpdateForwardWithN(self, sequence, new_pos):
        return _DataStats.SurroundingBaseSurrounding_UpdateForwardWithN(self, sequence, new_pos)

    def UpdateReverseWithN(self, sequence, new_pos):
        return _DataStats.SurroundingBaseSurrounding_UpdateReverseWithN(self, sequence, new_pos)
    __swig_destroy__ = _DataStats.delete_SurroundingBaseSurrounding

# Register SurroundingBaseSurrounding in _DataStats:
_DataStats.SurroundingBaseSurrounding_swigregister(SurroundingBaseSurrounding)

def SurroundingBaseSurrounding_Length():
    return _DataStats.SurroundingBaseSurrounding_Length()

def SurroundingBaseSurrounding_StartPos(pos, seq_len):
    return _DataStats.SurroundingBaseSurrounding_StartPos(pos, seq_len)

def SurroundingBaseSurrounding_EndPos(pos, seq_len):
    return _DataStats.SurroundingBaseSurrounding_EndPos(pos, seq_len)

def SurroundingBaseSurrounding_StartPosReverse(pos, seq_len):
    return _DataStats.SurroundingBaseSurrounding_StartPosReverse(pos, seq_len)

def SurroundingBaseSurrounding_EndPosReverse(pos, seq_len):
    return _DataStats.SurroundingBaseSurrounding_EndPosReverse(pos, seq_len)

class Surrounding(SurroundingBaseSurrounding):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def ChangeSurroundingBase(self, pos, new_base):
        return _DataStats.Surrounding_ChangeSurroundingBase(self, pos, new_base)

    def DeleteSurroundingBaseShiftingOnRightSide(self, pos, new_end_base):
        return _DataStats.Surrounding_DeleteSurroundingBaseShiftingOnRightSide(self, pos, new_end_base)

    def DeleteSurroundingBaseShiftingOnLeftSide(self, pos, new_end_base):
        return _DataStats.Surrounding_DeleteSurroundingBaseShiftingOnLeftSide(self, pos, new_end_base)

    def InsertSurroundingBasesShiftingOnRightSide(self, pos, new_bases):
        return _DataStats.Surrounding_InsertSurroundingBasesShiftingOnRightSide(self, pos, new_bases)

    def InsertSurroundingBasesShiftingOnLeftSide(self, pos, new_bases):
        return _DataStats.Surrounding_InsertSurroundingBasesShiftingOnLeftSide(self, pos, new_bases)

    def __init__(self):
        _DataStats.Surrounding_swiginit(self, _DataStats.new_Surrounding())
    __swig_destroy__ = _DataStats.delete_Surrounding

# Register Surrounding in _DataStats:
_DataStats.Surrounding_swigregister(Surrounding)

class SurroundingCountAtomic(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _DataStats.SurroundingCountAtomic_swiginit(self, _DataStats.new_SurroundingCountAtomic())

    def Count(self, sur):
        return _DataStats.SurroundingCountAtomic_Count(self, sur)
    __swig_destroy__ = _DataStats.delete_SurroundingCountAtomic

# Register SurroundingCountAtomic in _DataStats:
_DataStats.SurroundingCountAtomic_swigregister(SurroundingCountAtomic)

class SurroundingCount(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _DataStats.SurroundingCount_swiginit(self, _DataStats.new_SurroundingCount())

    def Acquire(self, tmp_counts):
        return _DataStats.SurroundingCount_Acquire(self, tmp_counts)
    __swig_destroy__ = _DataStats.delete_SurroundingCount

# Register SurroundingCount in _DataStats:
_DataStats.SurroundingCount_swigregister(SurroundingCount)

class SurroundingBias(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _DataStats.SurroundingBias_swiginit(self, _DataStats.new_SurroundingBias())

    def SetUniform(self):
        return _DataStats.SurroundingBias_SetUniform(self)

    def CombinePositions(self, separated):
        return _DataStats.SurroundingBias_CombinePositions(self, separated)

    def SeparatePositions(self, separated):
        return _DataStats.SurroundingBias_SeparatePositions(self, separated)

    def Bias(self, sur):
        return _DataStats.SurroundingBias_Bias(self, sur)
    __swig_destroy__ = _DataStats.delete_SurroundingBias

# Register SurroundingBias in _DataStats:
_DataStats.SurroundingBias_swigregister(SurroundingBias)

class Reference(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    kMinDistToContigEnds = _DataStats.Reference_kMinDistToContigEnds

    def __init__(self):
        _DataStats.Reference_swiginit(self, _DataStats.new_Reference())

    def NumberSequences(self):
        return _DataStats.Reference_NumberSequences(self)

    def ReferenceId(self, n):
        return _DataStats.Reference_ReferenceId(self, n)

    def ReferenceIdFirstPart(self, n):
        return _DataStats.Reference_ReferenceIdFirstPart(self, n)

    def ReferenceSequence(self, *args):
        return _DataStats.Reference_ReferenceSequence(self, *args)

    def SequenceLength(self, n):
        return _DataStats.Reference_SequenceLength(self, n)

    def MaxSequenceLength(self):
        return _DataStats.Reference_MaxSequenceLength(self)

    def TotalSize(self):
        return _DataStats.Reference_TotalSize(self)

    def RefSeqsSortedByNxx(self, ref_seqs):
        return _DataStats.Reference_RefSeqsSortedByNxx(self, ref_seqs)

    def RefSeqsInNxx(self, ref_seqs, nxx_ref_seqs):
        return _DataStats.Reference_RefSeqsInNxx(self, ref_seqs, nxx_ref_seqs)

    def NumRefSeqBinsInNxx(self, ref_seqs, max_ref_seq_bin_length):
        return _DataStats.Reference_NumRefSeqBinsInNxx(self, ref_seqs, max_ref_seq_bin_length)

    def GC(self, seq_id, pos):
        return _DataStats.Reference_GC(self, seq_id, pos)

    def N(self, seq_id, pos):
        return _DataStats.Reference_N(self, seq_id, pos)

    def GCContentAbsolut(self, *args):
        return _DataStats.Reference_GCContentAbsolut(self, *args)

    def UpdateGC(self, gc, n_count, seq_id, old_pos, new_pos):
        return _DataStats.Reference_UpdateGC(self, gc, n_count, seq_id, old_pos, new_pos)

    def GCContent(self, seq_id, start_pos, end_pos):
        return _DataStats.Reference_GCContent(self, seq_id, start_pos, end_pos)

    def ForwardSurrounding(self, surrounding, ref_seq_id, pos):
        return _DataStats.Reference_ForwardSurrounding(self, surrounding, ref_seq_id, pos)

    def ReverseSurrounding(self, surrounding, ref_seq_id, pos):
        return _DataStats.Reference_ReverseSurrounding(self, surrounding, ref_seq_id, pos)

    def ForwardSurroundingWithN(self, surrounding, ref_seq_id, pos):
        return _DataStats.Reference_ForwardSurroundingWithN(self, surrounding, ref_seq_id, pos)

    def ReverseSurroundingWithN(self, surrounding, ref_seq_id, pos):
        return _DataStats.Reference_ReverseSurroundingWithN(self, surrounding, ref_seq_id, pos)

    def ReadFasta(self, fasta_file):
        return _DataStats.Reference_ReadFasta(self, fasta_file)

    def ReplaceN(self, seed):
        return _DataStats.Reference_ReplaceN(self, seed)

    def HasN(self):
        return _DataStats.Reference_HasN(self)

    def WriteFasta(self, fasta_file):
        return _DataStats.Reference_WriteFasta(self, fasta_file)
    __swig_destroy__ = _DataStats.delete_Reference

# Register Reference in _DataStats:
_DataStats.Reference_swigregister(Reference)

class FragmentSite(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    gc_ = property(_DataStats.FragmentSite_gc__get, _DataStats.FragmentSite_gc__set)
    start_surrounding_ = property(_DataStats.FragmentSite_start_surrounding__get, _DataStats.FragmentSite_start_surrounding__set)
    end_surrounding_ = property(_DataStats.FragmentSite_end_surrounding__get, _DataStats.FragmentSite_end_surrounding__set)
    count_forward_ = property(_DataStats.FragmentSite_count_forward__get, _DataStats.FragmentSite_count_forward__set)
    count_reverse_ = property(_DataStats.FragmentSite_count_reverse__get, _DataStats.FragmentSite_count_reverse__set)
    bias_ = property(_DataStats.FragmentSite_bias__get, _DataStats.FragmentSite_bias__set)

    def __init__(self, *args):
        _DataStats.FragmentSite_swiginit(self, _DataStats.new_FragmentSite(*args))

    @staticmethod
    def LowerBias(lhs, rhs):
        return _DataStats.FragmentSite_LowerBias(lhs, rhs)
    __swig_destroy__ = _DataStats.delete_FragmentSite

# Register FragmentSite in _DataStats:
_DataStats.FragmentSite_swigregister(FragmentSite)

def FragmentSite_LowerBias(lhs, rhs):
    return _DataStats.FragmentSite_LowerBias(lhs, rhs)

class DataStatsInterface(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, ref):
        _DataStats.DataStatsInterface_swiginit(self, _DataStats.new_DataStatsInterface(ref))

    def AdapterName(self, template_segment, id):
        return _DataStats.DataStatsInterface_AdapterName(self, template_segment, id)

    def AdapterCount(self, template_segment):
        return _DataStats.DataStatsInterface_AdapterCount(self, template_segment)

    def AdapterPolyATailLength(self):
        return _DataStats.DataStatsInterface_AdapterPolyATailLength(self)

    def AdapterOverrunBases(self, nucleotide):
        return _DataStats.DataStatsInterface_AdapterOverrunBases(self, nucleotide)

    def ErrorRatesByDistanceStart(self):
        return _DataStats.DataStatsInterface_ErrorRatesByDistanceStart(self)

    def ErrorRatesByDistanceEnd(self):
        return _DataStats.DataStatsInterface_ErrorRatesByDistanceEnd(self)

    def ErrorRatesByDistance(self, distance):
        return _DataStats.DataStatsInterface_ErrorRatesByDistance(self, distance)

    def ErrorRatesByGCStart(self):
        return _DataStats.DataStatsInterface_ErrorRatesByGCStart(self)

    def ErrorRatesByGCEnd(self):
        return _DataStats.DataStatsInterface_ErrorRatesByGCEnd(self)

    def ErrorRatesByGC(self, gc):
        return _DataStats.DataStatsInterface_ErrorRatesByGC(self, gc)

    def BlockErrorRate(self):
        return _DataStats.DataStatsInterface_BlockErrorRate(self)

    def BlockPercentSystematic(self):
        return _DataStats.DataStatsInterface_BlockPercentSystematic(self)

    def SystematicErrorPValues(self):
        return _DataStats.DataStatsInterface_SystematicErrorPValues(self)

    def Coverage(self):
        return _DataStats.DataStatsInterface_Coverage(self)

    def CoverageStranded(self, reverse_strand):
        return _DataStats.DataStatsInterface_CoverageStranded(self, reverse_strand)

    def CoverageStrandedPercent(self, reverse_strand):
        return _DataStats.DataStatsInterface_CoverageStrandedPercent(self, reverse_strand)

    def CoverageStrandedPercentMinCov10(self, reverse_strand):
        return _DataStats.DataStatsInterface_CoverageStrandedPercentMinCov10(self, reverse_strand)

    def CoverageStrandedPercentMinCov20(self, reverse_strand):
        return _DataStats.DataStatsInterface_CoverageStrandedPercentMinCov20(self, reverse_strand)

    def ErrorCoverage(self):
        return _DataStats.DataStatsInterface_ErrorCoverage(self)

    def ErrorCoveragePercent(self):
        return _DataStats.DataStatsInterface_ErrorCoveragePercent(self)

    def ErrorCoveragePercentMinCov10(self):
        return _DataStats.DataStatsInterface_ErrorCoveragePercentMinCov10(self)

    def ErrorCoveragePercentMinCov20(self):
        return _DataStats.DataStatsInterface_ErrorCoveragePercentMinCov20(self)

    def ErrorCoveragePercentStranded(self, forward_errors_percent, reverse_errors_percent):
        return _DataStats.DataStatsInterface_ErrorCoveragePercentStranded(self, forward_errors_percent, reverse_errors_percent)

    def ErrorCoveragePercentStrandedMinCov10(self, forward_errors_percent, reverse_errors_percent):
        return _DataStats.DataStatsInterface_ErrorCoveragePercentStrandedMinCov10(self, forward_errors_percent, reverse_errors_percent)

    def ErrorCoveragePercentStrandedMinCov20(self, forward_errors_percent, reverse_errors_percent):
        return _DataStats.DataStatsInterface_ErrorCoveragePercentStrandedMinCov20(self, forward_errors_percent, reverse_errors_percent)

    def ErrorsPerRead(self, template_segment):
        return _DataStats.DataStatsInterface_ErrorsPerRead(self, template_segment)

    def CalledBasesByBaseQualityPerPreviousCalledBase(self, template_segment, ref_base, called_base, previous_base):
        return _DataStats.DataStatsInterface_CalledBasesByBaseQualityPerPreviousCalledBase(self, template_segment, ref_base, called_base, previous_base)

    def CalledBasesByBaseQuality(self, template_segment, ref_base, called_base):
        return _DataStats.DataStatsInterface_CalledBasesByBaseQuality(self, template_segment, ref_base, called_base)

    def CalledBasesByPosition(self, template_segment, ref_base, called_base):
        return _DataStats.DataStatsInterface_CalledBasesByPosition(self, template_segment, ref_base, called_base)

    def InDelErrorByLength(self, indel_type):
        return _DataStats.DataStatsInterface_InDelErrorByLength(self, indel_type)

    def InDelErrorByPosition(self, indel_type):
        return _DataStats.DataStatsInterface_InDelErrorByPosition(self, indel_type)

    def InDelErrorByGC(self, indel_type):
        return _DataStats.DataStatsInterface_InDelErrorByGC(self, indel_type)

    def FragmentDuplicationNumber(self):
        return _DataStats.DataStatsInterface_FragmentDuplicationNumber(self)

    def Abundance(self):
        return _DataStats.DataStatsInterface_Abundance(self)

    def InsertLengths(self):
        return _DataStats.DataStatsInterface_InsertLengths(self)

    def GCFragmentContent(self):
        return _DataStats.DataStatsInterface_GCFragmentContent(self)

    def GCFragmentContentBias(self):
        return _DataStats.DataStatsInterface_GCFragmentContentBias(self)

    def OutskirtContent(self, direction, nucleotide):
        return _DataStats.DataStatsInterface_OutskirtContent(self, direction, nucleotide)

    def FragmentSurroundingBiasByBase(self, nucleotide):
        return _DataStats.DataStatsInterface_FragmentSurroundingBiasByBase(self, nucleotide)

    def SequenceQualityProbabilityMean(self, template_segment):
        return _DataStats.DataStatsInterface_SequenceQualityProbabilityMean(self, template_segment)

    def SequenceQualityMinimum(self, template_segment):
        return _DataStats.DataStatsInterface_SequenceQualityMinimum(self, template_segment)

    def SequenceQualityFirstQuartile(self, template_segment):
        return _DataStats.DataStatsInterface_SequenceQualityFirstQuartile(self, template_segment)

    def SequenceQualityMedian(self, template_segment):
        return _DataStats.DataStatsInterface_SequenceQualityMedian(self, template_segment)

    def SequenceQualityThirdQuartile(self, template_segment):
        return _DataStats.DataStatsInterface_SequenceQualityThirdQuartile(self, template_segment)

    def SequenceQualityMaximum(self, template_segment):
        return _DataStats.DataStatsInterface_SequenceQualityMaximum(self, template_segment)

    def SequenceQualityContent(self, template_segment, quality):
        return _DataStats.DataStatsInterface_SequenceQualityContent(self, template_segment, quality)

    def HomoqualityDistribution(self, quality):
        return _DataStats.DataStatsInterface_HomoqualityDistribution(self, quality)

    def NucleotideQuality(self, template_segment, nucleotide):
        return _DataStats.DataStatsInterface_NucleotideQuality(self, template_segment, nucleotide)

    def BaseQualityStatsReference(self, template_segment, read_position):
        return _DataStats.DataStatsInterface_BaseQualityStatsReference(self, template_segment, read_position)

    def BaseQualityMeanReference(self, template_segment):
        return _DataStats.DataStatsInterface_BaseQualityMeanReference(self, template_segment)

    def BaseQualityMinimumReference(self, template_segment):
        return _DataStats.DataStatsInterface_BaseQualityMinimumReference(self, template_segment)

    def BaseQualityFirstQuartileReference(self, template_segment):
        return _DataStats.DataStatsInterface_BaseQualityFirstQuartileReference(self, template_segment)

    def BaseQualityMedianReference(self, template_segment):
        return _DataStats.DataStatsInterface_BaseQualityMedianReference(self, template_segment)

    def BaseQualityThirdQuartileReference(self, template_segment):
        return _DataStats.DataStatsInterface_BaseQualityThirdQuartileReference(self, template_segment)

    def BaseQualityMaximumReference(self, template_segment):
        return _DataStats.DataStatsInterface_BaseQualityMaximumReference(self, template_segment)

    def AverageSequenceQualityForGC(self, template_segment):
        return _DataStats.DataStatsInterface_AverageSequenceQualityForGC(self, template_segment)

    def BaseQualityStats(self, template_segment, read_position):
        return _DataStats.DataStatsInterface_BaseQualityStats(self, template_segment, read_position)

    def BaseQualityMean(self, template_segment):
        return _DataStats.DataStatsInterface_BaseQualityMean(self, template_segment)

    def BaseQualityMinimum(self, template_segment):
        return _DataStats.DataStatsInterface_BaseQualityMinimum(self, template_segment)

    def BaseQualityFirstQuartile(self, template_segment):
        return _DataStats.DataStatsInterface_BaseQualityFirstQuartile(self, template_segment)

    def BaseQualityMedian(self, template_segment):
        return _DataStats.DataStatsInterface_BaseQualityMedian(self, template_segment)

    def BaseQualityThirdQuartile(self, template_segment):
        return _DataStats.DataStatsInterface_BaseQualityThirdQuartile(self, template_segment)

    def BaseQualityMaximum(self, template_segment):
        return _DataStats.DataStatsInterface_BaseQualityMaximum(self, template_segment)

    def TileQualityMeanDifference(self, template_segment, tile_id):
        return _DataStats.DataStatsInterface_TileQualityMeanDifference(self, template_segment, tile_id)

    def BaseQualityMeanPerStrand(self, strand):
        return _DataStats.DataStatsInterface_BaseQualityMeanPerStrand(self, strand)

    def BaseQualityForSequenceStart(self, template_segment):
        return _DataStats.DataStatsInterface_BaseQualityForSequenceStart(self, template_segment)

    def BaseQualityForSequenceEnd(self, template_segment):
        return _DataStats.DataStatsInterface_BaseQualityForSequenceEnd(self, template_segment)

    def BaseQualityForSequence(self, template_segment, seq_quality):
        return _DataStats.DataStatsInterface_BaseQualityForSequence(self, template_segment, seq_quality)

    def BaseQualityForPrecedingQualityStart(self, template_segment):
        return _DataStats.DataStatsInterface_BaseQualityForPrecedingQualityStart(self, template_segment)

    def BaseQualityForPrecedingQualityEnd(self, template_segment):
        return _DataStats.DataStatsInterface_BaseQualityForPrecedingQualityEnd(self, template_segment)

    def BaseQualityForPrecedingQuality(self, template_segment, seq_quality):
        return _DataStats.DataStatsInterface_BaseQualityForPrecedingQuality(self, template_segment, seq_quality)

    def SequenceQualityMean(self, template_segment):
        return _DataStats.DataStatsInterface_SequenceQualityMean(self, template_segment)

    def SequenceQualityPairsStart(self):
        return _DataStats.DataStatsInterface_SequenceQualityPairsStart(self)

    def SequenceQualityPairsEnd(self):
        return _DataStats.DataStatsInterface_SequenceQualityPairsEnd(self)

    def SequenceQualityPairs(self, seq_quality_first):
        return _DataStats.DataStatsInterface_SequenceQualityPairs(self, seq_quality_first)

    def MeanSequenceQualityMeanByFragmentLength(self, template_segment):
        return _DataStats.DataStatsInterface_MeanSequenceQualityMeanByFragmentLength(self, template_segment)

    def AverageSequenceQualityForBase(self, template_segment, nucleotide):
        return _DataStats.DataStatsInterface_AverageSequenceQualityForBase(self, template_segment, nucleotide)

    def TileNames(self):
        return _DataStats.DataStatsInterface_TileNames(self)

    def TileAbundance(self):
        return _DataStats.DataStatsInterface_TileAbundance(self)

    def PhredQualityOffset(self):
        return _DataStats.DataStatsInterface_PhredQualityOffset(self)

    def TotalNumberReads(self):
        return _DataStats.DataStatsInterface_TotalNumberReads(self)

    def ReadLengths(self, template_segment):
        return _DataStats.DataStatsInterface_ReadLengths(self, template_segment)

    def ProperPairMappingQuality(self):
        return _DataStats.DataStatsInterface_ProperPairMappingQuality(self)

    def ImproperPairMappingQuality(self):
        return _DataStats.DataStatsInterface_ImproperPairMappingQuality(self)

    def SingleReadMappingQuality(self):
        return _DataStats.DataStatsInterface_SingleReadMappingQuality(self)

    def GCReadContent(self, template_segment):
        return _DataStats.DataStatsInterface_GCReadContent(self, template_segment)

    def GCReadContentReference(self, template_segment):
        return _DataStats.DataStatsInterface_GCReadContentReference(self, template_segment)

    def GCReadContentMapped(self, template_segment):
        return _DataStats.DataStatsInterface_GCReadContentMapped(self, template_segment)

    def NContent(self, template_segment):
        return _DataStats.DataStatsInterface_NContent(self, template_segment)

    def SequenceContent(self, template_segment, nucleotide):
        return _DataStats.DataStatsInterface_SequenceContent(self, template_segment, nucleotide)

    def SequenceContentReference(self, template_segment, strand, nucleotide):
        return _DataStats.DataStatsInterface_SequenceContentReference(self, template_segment, strand, nucleotide)

    def HomopolymerDistribution(self, nucleotide):
        return _DataStats.DataStatsInterface_HomopolymerDistribution(self, nucleotide)

    def ReadBam(self, bam_file, adapter_file, adapter_matrix, variant_file, num_threads, calculate_bias=True):
        return _DataStats.DataStatsInterface_ReadBam(self, bam_file, adapter_file, adapter_matrix, variant_file, num_threads, calculate_bias)

    def Load(self, archive_file):
        return _DataStats.DataStatsInterface_Load(self, archive_file)

    def Save(self, archive_file):
        return _DataStats.DataStatsInterface_Save(self, archive_file)
    __swig_destroy__ = _DataStats.delete_DataStatsInterface

# Register DataStatsInterface in _DataStats:
_DataStats.DataStatsInterface_swigregister(DataStatsInterface)



