# 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.

"""Codes for various geographical computations and filters"""

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 _math
else:
    import _math

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__ = _math.delete_SwigPyIterator

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import seiscomp.core
class vectorf(object):
    r"""Proxy of C++ std::vector< float > class."""

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

    def iterator(self):
        r"""iterator(vectorf self) -> SwigPyIterator"""
        return _math.vectorf_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vectorf self) -> bool"""
        return _math.vectorf___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vectorf self) -> bool"""
        return _math.vectorf___bool__(self)

    def __len__(self):
        r"""__len__(vectorf self) -> std::vector< float >::size_type"""
        return _math.vectorf___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vectorf self, std::vector< float >::difference_type i, std::vector< float >::difference_type j) -> vectorf"""
        return _math.vectorf___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vectorf self, std::vector< float >::difference_type i, std::vector< float >::difference_type j)
        __setslice__(vectorf self, std::vector< float >::difference_type i, std::vector< float >::difference_type j, vectorf v)
        """
        return _math.vectorf___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vectorf self, std::vector< float >::difference_type i, std::vector< float >::difference_type j)"""
        return _math.vectorf___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vectorf self, std::vector< float >::difference_type i)
        __delitem__(vectorf self, PySliceObject * slice)
        """
        return _math.vectorf___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vectorf self, PySliceObject * slice) -> vectorf
        __getitem__(vectorf self, std::vector< float >::difference_type i) -> std::vector< float >::value_type const &
        """
        return _math.vectorf___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vectorf self, PySliceObject * slice, vectorf v)
        __setitem__(vectorf self, PySliceObject * slice)
        __setitem__(vectorf self, std::vector< float >::difference_type i, std::vector< float >::value_type const & x)
        """
        return _math.vectorf___setitem__(self, *args)

    def pop(self):
        r"""pop(vectorf self) -> std::vector< float >::value_type"""
        return _math.vectorf_pop(self)

    def append(self, x):
        r"""append(vectorf self, std::vector< float >::value_type const & x)"""
        return _math.vectorf_append(self, x)

    def empty(self):
        r"""empty(vectorf self) -> bool"""
        return _math.vectorf_empty(self)

    def size(self):
        r"""size(vectorf self) -> std::vector< float >::size_type"""
        return _math.vectorf_size(self)

    def swap(self, v):
        r"""swap(vectorf self, vectorf v)"""
        return _math.vectorf_swap(self, v)

    def begin(self):
        r"""begin(vectorf self) -> std::vector< float >::iterator"""
        return _math.vectorf_begin(self)

    def end(self):
        r"""end(vectorf self) -> std::vector< float >::iterator"""
        return _math.vectorf_end(self)

    def rbegin(self):
        r"""rbegin(vectorf self) -> std::vector< float >::reverse_iterator"""
        return _math.vectorf_rbegin(self)

    def rend(self):
        r"""rend(vectorf self) -> std::vector< float >::reverse_iterator"""
        return _math.vectorf_rend(self)

    def clear(self):
        r"""clear(vectorf self)"""
        return _math.vectorf_clear(self)

    def get_allocator(self):
        r"""get_allocator(vectorf self) -> std::vector< float >::allocator_type"""
        return _math.vectorf_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vectorf self)"""
        return _math.vectorf_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vectorf self, std::vector< float >::iterator pos) -> std::vector< float >::iterator
        erase(vectorf self, std::vector< float >::iterator first, std::vector< float >::iterator last) -> std::vector< float >::iterator
        """
        return _math.vectorf_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vectorf self) -> vectorf
        __init__(vectorf self, vectorf other) -> vectorf
        __init__(vectorf self, std::vector< float >::size_type size) -> vectorf
        __init__(vectorf self, std::vector< float >::size_type size, std::vector< float >::value_type const & value) -> vectorf
        """
        _math.vectorf_swiginit(self, _math.new_vectorf(*args))

    def push_back(self, x):
        r"""push_back(vectorf self, std::vector< float >::value_type const & x)"""
        return _math.vectorf_push_back(self, x)

    def front(self):
        r"""front(vectorf self) -> std::vector< float >::value_type const &"""
        return _math.vectorf_front(self)

    def back(self):
        r"""back(vectorf self) -> std::vector< float >::value_type const &"""
        return _math.vectorf_back(self)

    def assign(self, n, x):
        r"""assign(vectorf self, std::vector< float >::size_type n, std::vector< float >::value_type const & x)"""
        return _math.vectorf_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vectorf self, std::vector< float >::size_type new_size)
        resize(vectorf self, std::vector< float >::size_type new_size, std::vector< float >::value_type const & x)
        """
        return _math.vectorf_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vectorf self, std::vector< float >::iterator pos, std::vector< float >::value_type const & x) -> std::vector< float >::iterator
        insert(vectorf self, std::vector< float >::iterator pos, std::vector< float >::size_type n, std::vector< float >::value_type const & x)
        """
        return _math.vectorf_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vectorf self, std::vector< float >::size_type n)"""
        return _math.vectorf_reserve(self, n)

    def capacity(self):
        r"""capacity(vectorf self) -> std::vector< float >::size_type"""
        return _math.vectorf_capacity(self)
    __swig_destroy__ = _math.delete_vectorf

# Register vectorf in _math:
_math.vectorf_swigregister(vectorf)

class vectord(object):
    r"""Proxy of C++ std::vector< double > class."""

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

    def iterator(self):
        r"""iterator(vectord self) -> SwigPyIterator"""
        return _math.vectord_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vectord self) -> bool"""
        return _math.vectord___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vectord self) -> bool"""
        return _math.vectord___bool__(self)

    def __len__(self):
        r"""__len__(vectord self) -> std::vector< double >::size_type"""
        return _math.vectord___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vectord self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> vectord"""
        return _math.vectord___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vectord self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
        __setslice__(vectord self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, vectord v)
        """
        return _math.vectord___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vectord self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _math.vectord___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vectord self, std::vector< double >::difference_type i)
        __delitem__(vectord self, PySliceObject * slice)
        """
        return _math.vectord___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vectord self, PySliceObject * slice) -> vectord
        __getitem__(vectord self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
        """
        return _math.vectord___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vectord self, PySliceObject * slice, vectord v)
        __setitem__(vectord self, PySliceObject * slice)
        __setitem__(vectord self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
        """
        return _math.vectord___setitem__(self, *args)

    def pop(self):
        r"""pop(vectord self) -> std::vector< double >::value_type"""
        return _math.vectord_pop(self)

    def append(self, x):
        r"""append(vectord self, std::vector< double >::value_type const & x)"""
        return _math.vectord_append(self, x)

    def empty(self):
        r"""empty(vectord self) -> bool"""
        return _math.vectord_empty(self)

    def size(self):
        r"""size(vectord self) -> std::vector< double >::size_type"""
        return _math.vectord_size(self)

    def swap(self, v):
        r"""swap(vectord self, vectord v)"""
        return _math.vectord_swap(self, v)

    def begin(self):
        r"""begin(vectord self) -> std::vector< double >::iterator"""
        return _math.vectord_begin(self)

    def end(self):
        r"""end(vectord self) -> std::vector< double >::iterator"""
        return _math.vectord_end(self)

    def rbegin(self):
        r"""rbegin(vectord self) -> std::vector< double >::reverse_iterator"""
        return _math.vectord_rbegin(self)

    def rend(self):
        r"""rend(vectord self) -> std::vector< double >::reverse_iterator"""
        return _math.vectord_rend(self)

    def clear(self):
        r"""clear(vectord self)"""
        return _math.vectord_clear(self)

    def get_allocator(self):
        r"""get_allocator(vectord self) -> std::vector< double >::allocator_type"""
        return _math.vectord_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vectord self)"""
        return _math.vectord_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vectord self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
        erase(vectord self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
        """
        return _math.vectord_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vectord self) -> vectord
        __init__(vectord self, vectord other) -> vectord
        __init__(vectord self, std::vector< double >::size_type size) -> vectord
        __init__(vectord self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> vectord
        """
        _math.vectord_swiginit(self, _math.new_vectord(*args))

    def push_back(self, x):
        r"""push_back(vectord self, std::vector< double >::value_type const & x)"""
        return _math.vectord_push_back(self, x)

    def front(self):
        r"""front(vectord self) -> std::vector< double >::value_type const &"""
        return _math.vectord_front(self)

    def back(self):
        r"""back(vectord self) -> std::vector< double >::value_type const &"""
        return _math.vectord_back(self)

    def assign(self, n, x):
        r"""assign(vectord self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _math.vectord_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vectord self, std::vector< double >::size_type new_size)
        resize(vectord self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
        """
        return _math.vectord_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vectord self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
        insert(vectord self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
        """
        return _math.vectord_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vectord self, std::vector< double >::size_type n)"""
        return _math.vectord_reserve(self, n)

    def capacity(self):
        r"""capacity(vectord self) -> std::vector< double >::size_type"""
        return _math.vectord_capacity(self)
    __swig_destroy__ = _math.delete_vectord

# Register vectord in _math:
_math.vectord_swigregister(vectord)


def round(val):
    r"""round(double val) -> double"""
    return _math.round(val)
class CoordF(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::Math::Geo::Coord< float > class."""

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

    def serialize(self, ar):
        r"""serialize(CoordF self, GenericArchive ar)"""
        return _math.CoordF_serialize(self, ar)

    def __init__(self, *args):
        r"""
        __init__(CoordF self) -> CoordF
        __init__(CoordF self, float lat_, float lon_) -> CoordF
        """
        _math.CoordF_swiginit(self, _math.new_CoordF(*args))

    def set(self, lat_, lon_):
        r"""set(CoordF self, float lat_, float lon_)"""
        return _math.CoordF_set(self, lat_, lon_)

    def latitude(self):
        r"""latitude(CoordF self) -> float"""
        return _math.CoordF_latitude(self)

    def longitude(self):
        r"""longitude(CoordF self) -> float"""
        return _math.CoordF_longitude(self)

    def __eq__(self, other):
        r"""__eq__(CoordF self, CoordF other) -> bool"""
        return _math.CoordF___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(CoordF self, CoordF other) -> bool"""
        return _math.CoordF___ne__(self, other)
    lat = property(_math.CoordF_lat_get, _math.CoordF_lat_set, doc=r"""lat : float""")
    lon = property(_math.CoordF_lon_get, _math.CoordF_lon_set, doc=r"""lon : float""")
    __swig_destroy__ = _math.delete_CoordF

# Register CoordF in _math:
_math.CoordF_swigregister(CoordF)

class CoordD(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::Math::Geo::Coord< double > class."""

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

    def serialize(self, ar):
        r"""serialize(CoordD self, GenericArchive ar)"""
        return _math.CoordD_serialize(self, ar)

    def __init__(self, *args):
        r"""
        __init__(CoordD self) -> CoordD
        __init__(CoordD self, double lat_, double lon_) -> CoordD
        """
        _math.CoordD_swiginit(self, _math.new_CoordD(*args))

    def set(self, lat_, lon_):
        r"""set(CoordD self, double lat_, double lon_)"""
        return _math.CoordD_set(self, lat_, lon_)

    def latitude(self):
        r"""latitude(CoordD self) -> double"""
        return _math.CoordD_latitude(self)

    def longitude(self):
        r"""longitude(CoordD self) -> double"""
        return _math.CoordD_longitude(self)

    def __eq__(self, other):
        r"""__eq__(CoordD self, CoordD other) -> bool"""
        return _math.CoordD___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(CoordD self, CoordD other) -> bool"""
        return _math.CoordD___ne__(self, other)
    lat = property(_math.CoordD_lat_get, _math.CoordD_lat_set, doc=r"""lat : double""")
    lon = property(_math.CoordD_lon_get, _math.CoordD_lon_set, doc=r"""lon : double""")
    __swig_destroy__ = _math.delete_CoordD

# Register CoordD in _math:
_math.CoordD_swigregister(CoordD)

class NamedCoordF(CoordF):
    r"""Proxy of C++ Seiscomp::Math::Geo::NamedCoord< float > class."""

    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):
        r"""
        __init__(NamedCoordF self) -> NamedCoordF
        __init__(NamedCoordF self, std::string const & name, float lat_, float lon_) -> NamedCoordF
        """
        _math.NamedCoordF_swiginit(self, _math.new_NamedCoordF(*args))
    __swig_destroy__ = _math.delete_NamedCoordF

    def set(self, *args):
        r"""
        set(NamedCoordF self, float lat_, float lon_)
        set(NamedCoordF self, std::string const & name, float lat_, float lon_)
        """
        return _math.NamedCoordF_set(self, *args)

    def setName(self, name):
        r"""setName(NamedCoordF self, std::string const & name)"""
        return _math.NamedCoordF_setName(self, name)

    def name(self):
        r"""name(NamedCoordF self) -> std::string const &"""
        return _math.NamedCoordF_name(self)

    def serialize(self, ar):
        r"""serialize(NamedCoordF self, GenericArchive ar)"""
        return _math.NamedCoordF_serialize(self, ar)

# Register NamedCoordF in _math:
_math.NamedCoordF_swigregister(NamedCoordF)

class NamedCoordD(CoordD):
    r"""Proxy of C++ Seiscomp::Math::Geo::NamedCoord< double > class."""

    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):
        r"""
        __init__(NamedCoordD self) -> NamedCoordD
        __init__(NamedCoordD self, std::string const & name, double lat_, double lon_) -> NamedCoordD
        """
        _math.NamedCoordD_swiginit(self, _math.new_NamedCoordD(*args))
    __swig_destroy__ = _math.delete_NamedCoordD

    def set(self, *args):
        r"""
        set(NamedCoordD self, double lat_, double lon_)
        set(NamedCoordD self, std::string const & name, double lat_, double lon_)
        """
        return _math.NamedCoordD_set(self, *args)

    def setName(self, name):
        r"""setName(NamedCoordD self, std::string const & name)"""
        return _math.NamedCoordD_setName(self, name)

    def name(self):
        r"""name(NamedCoordD self) -> std::string const &"""
        return _math.NamedCoordD_name(self)

    def serialize(self, ar):
        r"""serialize(NamedCoordD self, GenericArchive ar)"""
        return _math.NamedCoordD_serialize(self, ar)

# Register NamedCoordD in _math:
_math.NamedCoordD_swigregister(NamedCoordD)

class HotspotListF(object):
    r"""Proxy of C++ std::vector< Seiscomp::Math::Geo::NamedCoordF > class."""

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

    def iterator(self):
        r"""iterator(HotspotListF self) -> SwigPyIterator"""
        return _math.HotspotListF_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(HotspotListF self) -> bool"""
        return _math.HotspotListF___nonzero__(self)

    def __bool__(self):
        r"""__bool__(HotspotListF self) -> bool"""
        return _math.HotspotListF___bool__(self)

    def __len__(self):
        r"""__len__(HotspotListF self) -> std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::size_type"""
        return _math.HotspotListF___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(HotspotListF self, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::difference_type i, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::difference_type j) -> HotspotListF"""
        return _math.HotspotListF___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(HotspotListF self, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::difference_type i, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::difference_type j)
        __setslice__(HotspotListF self, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::difference_type i, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::difference_type j, HotspotListF v)
        """
        return _math.HotspotListF___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(HotspotListF self, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::difference_type i, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::difference_type j)"""
        return _math.HotspotListF___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(HotspotListF self, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::difference_type i)
        __delitem__(HotspotListF self, PySliceObject * slice)
        """
        return _math.HotspotListF___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(HotspotListF self, PySliceObject * slice) -> HotspotListF
        __getitem__(HotspotListF self, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::difference_type i) -> NamedCoordF
        """
        return _math.HotspotListF___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(HotspotListF self, PySliceObject * slice, HotspotListF v)
        __setitem__(HotspotListF self, PySliceObject * slice)
        __setitem__(HotspotListF self, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::difference_type i, NamedCoordF x)
        """
        return _math.HotspotListF___setitem__(self, *args)

    def pop(self):
        r"""pop(HotspotListF self) -> NamedCoordF"""
        return _math.HotspotListF_pop(self)

    def append(self, x):
        r"""append(HotspotListF self, NamedCoordF x)"""
        return _math.HotspotListF_append(self, x)

    def empty(self):
        r"""empty(HotspotListF self) -> bool"""
        return _math.HotspotListF_empty(self)

    def size(self):
        r"""size(HotspotListF self) -> std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::size_type"""
        return _math.HotspotListF_size(self)

    def swap(self, v):
        r"""swap(HotspotListF self, HotspotListF v)"""
        return _math.HotspotListF_swap(self, v)

    def begin(self):
        r"""begin(HotspotListF self) -> std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::iterator"""
        return _math.HotspotListF_begin(self)

    def end(self):
        r"""end(HotspotListF self) -> std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::iterator"""
        return _math.HotspotListF_end(self)

    def rbegin(self):
        r"""rbegin(HotspotListF self) -> std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::reverse_iterator"""
        return _math.HotspotListF_rbegin(self)

    def rend(self):
        r"""rend(HotspotListF self) -> std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::reverse_iterator"""
        return _math.HotspotListF_rend(self)

    def clear(self):
        r"""clear(HotspotListF self)"""
        return _math.HotspotListF_clear(self)

    def get_allocator(self):
        r"""get_allocator(HotspotListF self) -> std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::allocator_type"""
        return _math.HotspotListF_get_allocator(self)

    def pop_back(self):
        r"""pop_back(HotspotListF self)"""
        return _math.HotspotListF_pop_back(self)

    def erase(self, *args):
        r"""
        erase(HotspotListF self, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::iterator pos) -> std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::iterator
        erase(HotspotListF self, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::iterator first, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::iterator last) -> std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::iterator
        """
        return _math.HotspotListF_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(HotspotListF self) -> HotspotListF
        __init__(HotspotListF self, HotspotListF other) -> HotspotListF
        __init__(HotspotListF self, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::size_type size) -> HotspotListF
        __init__(HotspotListF self, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::size_type size, NamedCoordF value) -> HotspotListF
        """
        _math.HotspotListF_swiginit(self, _math.new_HotspotListF(*args))

    def push_back(self, x):
        r"""push_back(HotspotListF self, NamedCoordF x)"""
        return _math.HotspotListF_push_back(self, x)

    def front(self):
        r"""front(HotspotListF self) -> NamedCoordF"""
        return _math.HotspotListF_front(self)

    def back(self):
        r"""back(HotspotListF self) -> NamedCoordF"""
        return _math.HotspotListF_back(self)

    def assign(self, n, x):
        r"""assign(HotspotListF self, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::size_type n, NamedCoordF x)"""
        return _math.HotspotListF_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(HotspotListF self, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::size_type new_size)
        resize(HotspotListF self, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::size_type new_size, NamedCoordF x)
        """
        return _math.HotspotListF_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(HotspotListF self, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::iterator pos, NamedCoordF x) -> std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::iterator
        insert(HotspotListF self, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::iterator pos, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::size_type n, NamedCoordF x)
        """
        return _math.HotspotListF_insert(self, *args)

    def reserve(self, n):
        r"""reserve(HotspotListF self, std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::size_type n)"""
        return _math.HotspotListF_reserve(self, n)

    def capacity(self):
        r"""capacity(HotspotListF self) -> std::vector< Seiscomp::Math::Geo::NamedCoord< float > >::size_type"""
        return _math.HotspotListF_capacity(self)
    __swig_destroy__ = _math.delete_HotspotListF

# Register HotspotListF in _math:
_math.HotspotListF_swigregister(HotspotListF)

class HotspotListD(object):
    r"""Proxy of C++ std::vector< Seiscomp::Math::Geo::NamedCoordD > class."""

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

    def iterator(self):
        r"""iterator(HotspotListD self) -> SwigPyIterator"""
        return _math.HotspotListD_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(HotspotListD self) -> bool"""
        return _math.HotspotListD___nonzero__(self)

    def __bool__(self):
        r"""__bool__(HotspotListD self) -> bool"""
        return _math.HotspotListD___bool__(self)

    def __len__(self):
        r"""__len__(HotspotListD self) -> std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::size_type"""
        return _math.HotspotListD___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(HotspotListD self, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::difference_type i, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::difference_type j) -> HotspotListD"""
        return _math.HotspotListD___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(HotspotListD self, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::difference_type i, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::difference_type j)
        __setslice__(HotspotListD self, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::difference_type i, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::difference_type j, HotspotListD v)
        """
        return _math.HotspotListD___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(HotspotListD self, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::difference_type i, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::difference_type j)"""
        return _math.HotspotListD___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(HotspotListD self, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::difference_type i)
        __delitem__(HotspotListD self, PySliceObject * slice)
        """
        return _math.HotspotListD___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(HotspotListD self, PySliceObject * slice) -> HotspotListD
        __getitem__(HotspotListD self, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::difference_type i) -> NamedCoordD
        """
        return _math.HotspotListD___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(HotspotListD self, PySliceObject * slice, HotspotListD v)
        __setitem__(HotspotListD self, PySliceObject * slice)
        __setitem__(HotspotListD self, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::difference_type i, NamedCoordD x)
        """
        return _math.HotspotListD___setitem__(self, *args)

    def pop(self):
        r"""pop(HotspotListD self) -> NamedCoordD"""
        return _math.HotspotListD_pop(self)

    def append(self, x):
        r"""append(HotspotListD self, NamedCoordD x)"""
        return _math.HotspotListD_append(self, x)

    def empty(self):
        r"""empty(HotspotListD self) -> bool"""
        return _math.HotspotListD_empty(self)

    def size(self):
        r"""size(HotspotListD self) -> std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::size_type"""
        return _math.HotspotListD_size(self)

    def swap(self, v):
        r"""swap(HotspotListD self, HotspotListD v)"""
        return _math.HotspotListD_swap(self, v)

    def begin(self):
        r"""begin(HotspotListD self) -> std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::iterator"""
        return _math.HotspotListD_begin(self)

    def end(self):
        r"""end(HotspotListD self) -> std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::iterator"""
        return _math.HotspotListD_end(self)

    def rbegin(self):
        r"""rbegin(HotspotListD self) -> std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::reverse_iterator"""
        return _math.HotspotListD_rbegin(self)

    def rend(self):
        r"""rend(HotspotListD self) -> std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::reverse_iterator"""
        return _math.HotspotListD_rend(self)

    def clear(self):
        r"""clear(HotspotListD self)"""
        return _math.HotspotListD_clear(self)

    def get_allocator(self):
        r"""get_allocator(HotspotListD self) -> std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::allocator_type"""
        return _math.HotspotListD_get_allocator(self)

    def pop_back(self):
        r"""pop_back(HotspotListD self)"""
        return _math.HotspotListD_pop_back(self)

    def erase(self, *args):
        r"""
        erase(HotspotListD self, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::iterator pos) -> std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::iterator
        erase(HotspotListD self, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::iterator first, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::iterator last) -> std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::iterator
        """
        return _math.HotspotListD_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(HotspotListD self) -> HotspotListD
        __init__(HotspotListD self, HotspotListD other) -> HotspotListD
        __init__(HotspotListD self, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::size_type size) -> HotspotListD
        __init__(HotspotListD self, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::size_type size, NamedCoordD value) -> HotspotListD
        """
        _math.HotspotListD_swiginit(self, _math.new_HotspotListD(*args))

    def push_back(self, x):
        r"""push_back(HotspotListD self, NamedCoordD x)"""
        return _math.HotspotListD_push_back(self, x)

    def front(self):
        r"""front(HotspotListD self) -> NamedCoordD"""
        return _math.HotspotListD_front(self)

    def back(self):
        r"""back(HotspotListD self) -> NamedCoordD"""
        return _math.HotspotListD_back(self)

    def assign(self, n, x):
        r"""assign(HotspotListD self, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::size_type n, NamedCoordD x)"""
        return _math.HotspotListD_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(HotspotListD self, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::size_type new_size)
        resize(HotspotListD self, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::size_type new_size, NamedCoordD x)
        """
        return _math.HotspotListD_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(HotspotListD self, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::iterator pos, NamedCoordD x) -> std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::iterator
        insert(HotspotListD self, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::iterator pos, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::size_type n, NamedCoordD x)
        """
        return _math.HotspotListD_insert(self, *args)

    def reserve(self, n):
        r"""reserve(HotspotListD self, std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::size_type n)"""
        return _math.HotspotListD_reserve(self, n)

    def capacity(self):
        r"""capacity(HotspotListD self) -> std::vector< Seiscomp::Math::Geo::NamedCoord< double > >::size_type"""
        return _math.HotspotListD_capacity(self)
    __swig_destroy__ = _math.delete_HotspotListD

# Register HotspotListD in _math:
_math.HotspotListD_swigregister(HotspotListD)

class CityF(NamedCoordF):
    r"""Proxy of C++ Seiscomp::Math::Geo::City< float > class."""

    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):
        r"""
        __init__(CityF self) -> CityF
        __init__(CityF self, std::string const & name, float lat_, float lon_, size_t population) -> CityF
        __init__(CityF self, std::string const & name, std::string const & countryID, float lat_, float lon_, size_t population) -> CityF
        """
        _math.CityF_swiginit(self, _math.new_CityF(*args))
    __swig_destroy__ = _math.delete_CityF

    def setPopulation(self, population):
        r"""setPopulation(CityF self, double population)"""
        return _math.CityF_setPopulation(self, population)

    def population(self):
        r"""population(CityF self) -> double"""
        return _math.CityF_population(self)

    def setCountryID(self, arg2):
        r"""setCountryID(CityF self, std::string const & arg2)"""
        return _math.CityF_setCountryID(self, arg2)

    def countryID(self):
        r"""countryID(CityF self) -> std::string const &"""
        return _math.CityF_countryID(self)

    def setCategory(self, arg2):
        r"""setCategory(CityF self, std::string & arg2)"""
        return _math.CityF_setCategory(self, arg2)

    def category(self):
        r"""category(CityF self) -> std::string const &"""
        return _math.CityF_category(self)

    def serialize(self, ar):
        r"""serialize(CityF self, GenericArchive ar)"""
        return _math.CityF_serialize(self, ar)

# Register CityF in _math:
_math.CityF_swigregister(CityF)

class CityD(NamedCoordD):
    r"""Proxy of C++ Seiscomp::Math::Geo::City< double > class."""

    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):
        r"""
        __init__(CityD self) -> CityD
        __init__(CityD self, std::string const & name, double lat_, double lon_, size_t population) -> CityD
        __init__(CityD self, std::string const & name, std::string const & countryID, double lat_, double lon_, size_t population) -> CityD
        """
        _math.CityD_swiginit(self, _math.new_CityD(*args))
    __swig_destroy__ = _math.delete_CityD

    def setPopulation(self, population):
        r"""setPopulation(CityD self, double population)"""
        return _math.CityD_setPopulation(self, population)

    def population(self):
        r"""population(CityD self) -> double"""
        return _math.CityD_population(self)

    def setCountryID(self, arg2):
        r"""setCountryID(CityD self, std::string const & arg2)"""
        return _math.CityD_setCountryID(self, arg2)

    def countryID(self):
        r"""countryID(CityD self) -> std::string const &"""
        return _math.CityD_countryID(self)

    def setCategory(self, arg2):
        r"""setCategory(CityD self, std::string & arg2)"""
        return _math.CityD_setCategory(self, arg2)

    def category(self):
        r"""category(CityD self) -> std::string const &"""
        return _math.CityD_category(self)

    def serialize(self, ar):
        r"""serialize(CityD self, GenericArchive ar)"""
        return _math.CityD_serialize(self, ar)

# Register CityD in _math:
_math.CityD_swigregister(CityD)

class CityListF(object):
    r"""Proxy of C++ std::vector< Seiscomp::Math::Geo::CityF > class."""

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

    def iterator(self):
        r"""iterator(CityListF self) -> SwigPyIterator"""
        return _math.CityListF_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(CityListF self) -> bool"""
        return _math.CityListF___nonzero__(self)

    def __bool__(self):
        r"""__bool__(CityListF self) -> bool"""
        return _math.CityListF___bool__(self)

    def __len__(self):
        r"""__len__(CityListF self) -> std::vector< Seiscomp::Math::Geo::City< float > >::size_type"""
        return _math.CityListF___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(CityListF self, std::vector< Seiscomp::Math::Geo::City< float > >::difference_type i, std::vector< Seiscomp::Math::Geo::City< float > >::difference_type j) -> CityListF"""
        return _math.CityListF___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(CityListF self, std::vector< Seiscomp::Math::Geo::City< float > >::difference_type i, std::vector< Seiscomp::Math::Geo::City< float > >::difference_type j)
        __setslice__(CityListF self, std::vector< Seiscomp::Math::Geo::City< float > >::difference_type i, std::vector< Seiscomp::Math::Geo::City< float > >::difference_type j, CityListF v)
        """
        return _math.CityListF___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(CityListF self, std::vector< Seiscomp::Math::Geo::City< float > >::difference_type i, std::vector< Seiscomp::Math::Geo::City< float > >::difference_type j)"""
        return _math.CityListF___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(CityListF self, std::vector< Seiscomp::Math::Geo::City< float > >::difference_type i)
        __delitem__(CityListF self, PySliceObject * slice)
        """
        return _math.CityListF___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(CityListF self, PySliceObject * slice) -> CityListF
        __getitem__(CityListF self, std::vector< Seiscomp::Math::Geo::City< float > >::difference_type i) -> CityF
        """
        return _math.CityListF___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(CityListF self, PySliceObject * slice, CityListF v)
        __setitem__(CityListF self, PySliceObject * slice)
        __setitem__(CityListF self, std::vector< Seiscomp::Math::Geo::City< float > >::difference_type i, CityF x)
        """
        return _math.CityListF___setitem__(self, *args)

    def pop(self):
        r"""pop(CityListF self) -> CityF"""
        return _math.CityListF_pop(self)

    def append(self, x):
        r"""append(CityListF self, CityF x)"""
        return _math.CityListF_append(self, x)

    def empty(self):
        r"""empty(CityListF self) -> bool"""
        return _math.CityListF_empty(self)

    def size(self):
        r"""size(CityListF self) -> std::vector< Seiscomp::Math::Geo::City< float > >::size_type"""
        return _math.CityListF_size(self)

    def swap(self, v):
        r"""swap(CityListF self, CityListF v)"""
        return _math.CityListF_swap(self, v)

    def begin(self):
        r"""begin(CityListF self) -> std::vector< Seiscomp::Math::Geo::City< float > >::iterator"""
        return _math.CityListF_begin(self)

    def end(self):
        r"""end(CityListF self) -> std::vector< Seiscomp::Math::Geo::City< float > >::iterator"""
        return _math.CityListF_end(self)

    def rbegin(self):
        r"""rbegin(CityListF self) -> std::vector< Seiscomp::Math::Geo::City< float > >::reverse_iterator"""
        return _math.CityListF_rbegin(self)

    def rend(self):
        r"""rend(CityListF self) -> std::vector< Seiscomp::Math::Geo::City< float > >::reverse_iterator"""
        return _math.CityListF_rend(self)

    def clear(self):
        r"""clear(CityListF self)"""
        return _math.CityListF_clear(self)

    def get_allocator(self):
        r"""get_allocator(CityListF self) -> std::vector< Seiscomp::Math::Geo::City< float > >::allocator_type"""
        return _math.CityListF_get_allocator(self)

    def pop_back(self):
        r"""pop_back(CityListF self)"""
        return _math.CityListF_pop_back(self)

    def erase(self, *args):
        r"""
        erase(CityListF self, std::vector< Seiscomp::Math::Geo::City< float > >::iterator pos) -> std::vector< Seiscomp::Math::Geo::City< float > >::iterator
        erase(CityListF self, std::vector< Seiscomp::Math::Geo::City< float > >::iterator first, std::vector< Seiscomp::Math::Geo::City< float > >::iterator last) -> std::vector< Seiscomp::Math::Geo::City< float > >::iterator
        """
        return _math.CityListF_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(CityListF self) -> CityListF
        __init__(CityListF self, CityListF other) -> CityListF
        __init__(CityListF self, std::vector< Seiscomp::Math::Geo::City< float > >::size_type size) -> CityListF
        __init__(CityListF self, std::vector< Seiscomp::Math::Geo::City< float > >::size_type size, CityF value) -> CityListF
        """
        _math.CityListF_swiginit(self, _math.new_CityListF(*args))

    def push_back(self, x):
        r"""push_back(CityListF self, CityF x)"""
        return _math.CityListF_push_back(self, x)

    def front(self):
        r"""front(CityListF self) -> CityF"""
        return _math.CityListF_front(self)

    def back(self):
        r"""back(CityListF self) -> CityF"""
        return _math.CityListF_back(self)

    def assign(self, n, x):
        r"""assign(CityListF self, std::vector< Seiscomp::Math::Geo::City< float > >::size_type n, CityF x)"""
        return _math.CityListF_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(CityListF self, std::vector< Seiscomp::Math::Geo::City< float > >::size_type new_size)
        resize(CityListF self, std::vector< Seiscomp::Math::Geo::City< float > >::size_type new_size, CityF x)
        """
        return _math.CityListF_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(CityListF self, std::vector< Seiscomp::Math::Geo::City< float > >::iterator pos, CityF x) -> std::vector< Seiscomp::Math::Geo::City< float > >::iterator
        insert(CityListF self, std::vector< Seiscomp::Math::Geo::City< float > >::iterator pos, std::vector< Seiscomp::Math::Geo::City< float > >::size_type n, CityF x)
        """
        return _math.CityListF_insert(self, *args)

    def reserve(self, n):
        r"""reserve(CityListF self, std::vector< Seiscomp::Math::Geo::City< float > >::size_type n)"""
        return _math.CityListF_reserve(self, n)

    def capacity(self):
        r"""capacity(CityListF self) -> std::vector< Seiscomp::Math::Geo::City< float > >::size_type"""
        return _math.CityListF_capacity(self)
    __swig_destroy__ = _math.delete_CityListF

# Register CityListF in _math:
_math.CityListF_swigregister(CityListF)

class CityListD(object):
    r"""Proxy of C++ std::vector< Seiscomp::Math::Geo::CityD > class."""

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

    def iterator(self):
        r"""iterator(CityListD self) -> SwigPyIterator"""
        return _math.CityListD_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(CityListD self) -> bool"""
        return _math.CityListD___nonzero__(self)

    def __bool__(self):
        r"""__bool__(CityListD self) -> bool"""
        return _math.CityListD___bool__(self)

    def __len__(self):
        r"""__len__(CityListD self) -> std::vector< Seiscomp::Math::Geo::City< double > >::size_type"""
        return _math.CityListD___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(CityListD self, std::vector< Seiscomp::Math::Geo::City< double > >::difference_type i, std::vector< Seiscomp::Math::Geo::City< double > >::difference_type j) -> CityListD"""
        return _math.CityListD___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(CityListD self, std::vector< Seiscomp::Math::Geo::City< double > >::difference_type i, std::vector< Seiscomp::Math::Geo::City< double > >::difference_type j)
        __setslice__(CityListD self, std::vector< Seiscomp::Math::Geo::City< double > >::difference_type i, std::vector< Seiscomp::Math::Geo::City< double > >::difference_type j, CityListD v)
        """
        return _math.CityListD___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(CityListD self, std::vector< Seiscomp::Math::Geo::City< double > >::difference_type i, std::vector< Seiscomp::Math::Geo::City< double > >::difference_type j)"""
        return _math.CityListD___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(CityListD self, std::vector< Seiscomp::Math::Geo::City< double > >::difference_type i)
        __delitem__(CityListD self, PySliceObject * slice)
        """
        return _math.CityListD___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(CityListD self, PySliceObject * slice) -> CityListD
        __getitem__(CityListD self, std::vector< Seiscomp::Math::Geo::City< double > >::difference_type i) -> CityD
        """
        return _math.CityListD___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(CityListD self, PySliceObject * slice, CityListD v)
        __setitem__(CityListD self, PySliceObject * slice)
        __setitem__(CityListD self, std::vector< Seiscomp::Math::Geo::City< double > >::difference_type i, CityD x)
        """
        return _math.CityListD___setitem__(self, *args)

    def pop(self):
        r"""pop(CityListD self) -> CityD"""
        return _math.CityListD_pop(self)

    def append(self, x):
        r"""append(CityListD self, CityD x)"""
        return _math.CityListD_append(self, x)

    def empty(self):
        r"""empty(CityListD self) -> bool"""
        return _math.CityListD_empty(self)

    def size(self):
        r"""size(CityListD self) -> std::vector< Seiscomp::Math::Geo::City< double > >::size_type"""
        return _math.CityListD_size(self)

    def swap(self, v):
        r"""swap(CityListD self, CityListD v)"""
        return _math.CityListD_swap(self, v)

    def begin(self):
        r"""begin(CityListD self) -> std::vector< Seiscomp::Math::Geo::City< double > >::iterator"""
        return _math.CityListD_begin(self)

    def end(self):
        r"""end(CityListD self) -> std::vector< Seiscomp::Math::Geo::City< double > >::iterator"""
        return _math.CityListD_end(self)

    def rbegin(self):
        r"""rbegin(CityListD self) -> std::vector< Seiscomp::Math::Geo::City< double > >::reverse_iterator"""
        return _math.CityListD_rbegin(self)

    def rend(self):
        r"""rend(CityListD self) -> std::vector< Seiscomp::Math::Geo::City< double > >::reverse_iterator"""
        return _math.CityListD_rend(self)

    def clear(self):
        r"""clear(CityListD self)"""
        return _math.CityListD_clear(self)

    def get_allocator(self):
        r"""get_allocator(CityListD self) -> std::vector< Seiscomp::Math::Geo::City< double > >::allocator_type"""
        return _math.CityListD_get_allocator(self)

    def pop_back(self):
        r"""pop_back(CityListD self)"""
        return _math.CityListD_pop_back(self)

    def erase(self, *args):
        r"""
        erase(CityListD self, std::vector< Seiscomp::Math::Geo::City< double > >::iterator pos) -> std::vector< Seiscomp::Math::Geo::City< double > >::iterator
        erase(CityListD self, std::vector< Seiscomp::Math::Geo::City< double > >::iterator first, std::vector< Seiscomp::Math::Geo::City< double > >::iterator last) -> std::vector< Seiscomp::Math::Geo::City< double > >::iterator
        """
        return _math.CityListD_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(CityListD self) -> CityListD
        __init__(CityListD self, CityListD other) -> CityListD
        __init__(CityListD self, std::vector< Seiscomp::Math::Geo::City< double > >::size_type size) -> CityListD
        __init__(CityListD self, std::vector< Seiscomp::Math::Geo::City< double > >::size_type size, CityD value) -> CityListD
        """
        _math.CityListD_swiginit(self, _math.new_CityListD(*args))

    def push_back(self, x):
        r"""push_back(CityListD self, CityD x)"""
        return _math.CityListD_push_back(self, x)

    def front(self):
        r"""front(CityListD self) -> CityD"""
        return _math.CityListD_front(self)

    def back(self):
        r"""back(CityListD self) -> CityD"""
        return _math.CityListD_back(self)

    def assign(self, n, x):
        r"""assign(CityListD self, std::vector< Seiscomp::Math::Geo::City< double > >::size_type n, CityD x)"""
        return _math.CityListD_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(CityListD self, std::vector< Seiscomp::Math::Geo::City< double > >::size_type new_size)
        resize(CityListD self, std::vector< Seiscomp::Math::Geo::City< double > >::size_type new_size, CityD x)
        """
        return _math.CityListD_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(CityListD self, std::vector< Seiscomp::Math::Geo::City< double > >::iterator pos, CityD x) -> std::vector< Seiscomp::Math::Geo::City< double > >::iterator
        insert(CityListD self, std::vector< Seiscomp::Math::Geo::City< double > >::iterator pos, std::vector< Seiscomp::Math::Geo::City< double > >::size_type n, CityD x)
        """
        return _math.CityListD_insert(self, *args)

    def reserve(self, n):
        r"""reserve(CityListD self, std::vector< Seiscomp::Math::Geo::City< double > >::size_type n)"""
        return _math.CityListD_reserve(self, n)

    def capacity(self):
        r"""capacity(CityListD self) -> std::vector< Seiscomp::Math::Geo::City< double > >::size_type"""
        return _math.CityListD_capacity(self)
    __swig_destroy__ = _math.delete_CityListD

# Register CityListD in _math:
_math.CityListD_swigregister(CityListD)

class AlignmentError(object):
    r"""Proxy of C++ Seiscomp::Math::Filtering::AlignmentError class."""

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

    def __init__(self, txt):
        r"""__init__(AlignmentError self, char const * txt) -> AlignmentError"""
        _math.AlignmentError_swiginit(self, _math.new_AlignmentError(txt))

    def what(self):
        r"""what(AlignmentError self) -> char const *"""
        return _math.AlignmentError_what(self)
    __swig_destroy__ = _math.delete_AlignmentError

# Register AlignmentError in _math:
_math.AlignmentError_swigregister(AlignmentError)


def next_power_of_2(arg1):
    r"""next_power_of_2(long arg1) -> long"""
    return _math.next_power_of_2(arg1)
class InPlaceFilterF(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::Math::Filtering::InPlaceFilter< float > class."""

    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__ = _math.delete_InPlaceFilterF

    def setStartTime(self, time):
        r"""setStartTime(InPlaceFilterF self, Time time)"""
        return _math.InPlaceFilterF_setStartTime(self, time)

    def setStreamID(self, net, sta, loc, cha):
        r"""setStreamID(InPlaceFilterF self, std::string const & net, std::string const & sta, std::string const & loc, std::string const & cha)"""
        return _math.InPlaceFilterF_setStreamID(self, net, sta, loc, cha)

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(InPlaceFilterF self, double fsamp)"""
        return _math.InPlaceFilterF_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(InPlaceFilterF self, int n, double const * params) -> int"""
        return _math.InPlaceFilterF_setParameters(self, n, params)

    def apply(self, *args):
        r"""
        apply(InPlaceFilterF self, vectorf f)
        apply(InPlaceFilterF self, FloatArrayT arr)
        """
        return _math.InPlaceFilterF_apply(self, *args)

    def handleGap(self, n=0):
        r"""handleGap(InPlaceFilterF self, int n=0)"""
        return _math.InPlaceFilterF_handleGap(self, n)

    def clone(self):
        r"""clone(InPlaceFilterF self) -> InPlaceFilterF"""
        return _math.InPlaceFilterF_clone(self)

    @staticmethod
    def Create(strFilter, strError=None):
        r"""Create(std::string const & strFilter, std::string * strError=None) -> InPlaceFilterF"""
        return _math.InPlaceFilterF_Create(strFilter, strError)

# Register InPlaceFilterF in _math:
_math.InPlaceFilterF_swigregister(InPlaceFilterF)

def InPlaceFilterF_Create(strFilter, strError=None):
    r"""InPlaceFilterF_Create(std::string const & strFilter, std::string * strError=None) -> InPlaceFilterF"""
    return _math.InPlaceFilterF_Create(strFilter, strError)

class InPlaceFilterD(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::Math::Filtering::InPlaceFilter< double > class."""

    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__ = _math.delete_InPlaceFilterD

    def setStartTime(self, time):
        r"""setStartTime(InPlaceFilterD self, Time time)"""
        return _math.InPlaceFilterD_setStartTime(self, time)

    def setStreamID(self, net, sta, loc, cha):
        r"""setStreamID(InPlaceFilterD self, std::string const & net, std::string const & sta, std::string const & loc, std::string const & cha)"""
        return _math.InPlaceFilterD_setStreamID(self, net, sta, loc, cha)

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(InPlaceFilterD self, double fsamp)"""
        return _math.InPlaceFilterD_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(InPlaceFilterD self, int n, double const * params) -> int"""
        return _math.InPlaceFilterD_setParameters(self, n, params)

    def apply(self, *args):
        r"""
        apply(InPlaceFilterD self, vectord f)
        apply(InPlaceFilterD self, DoubleArrayT arr)
        """
        return _math.InPlaceFilterD_apply(self, *args)

    def handleGap(self, n=0):
        r"""handleGap(InPlaceFilterD self, int n=0)"""
        return _math.InPlaceFilterD_handleGap(self, n)

    def clone(self):
        r"""clone(InPlaceFilterD self) -> InPlaceFilterD"""
        return _math.InPlaceFilterD_clone(self)

    @staticmethod
    def Create(strFilter, strError=None):
        r"""Create(std::string const & strFilter, std::string * strError=None) -> InPlaceFilterD"""
        return _math.InPlaceFilterD_Create(strFilter, strError)

# Register InPlaceFilterD in _math:
_math.InPlaceFilterD_swigregister(InPlaceFilterD)

def InPlaceFilterD_Create(strFilter, strError=None):
    r"""InPlaceFilterD_Create(std::string const & strFilter, std::string * strError=None) -> InPlaceFilterD"""
    return _math.InPlaceFilterD_Create(strFilter, strError)

class AverageFilterF(InPlaceFilterF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::Average< float > class."""

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

    def __init__(self, timeSpan=1.0, fsamp=0.0):
        r"""__init__(AverageFilterF self, double timeSpan=1.0, double fsamp=0.0) -> AverageFilterF"""
        _math.AverageFilterF_swiginit(self, _math.new_AverageFilterF(timeSpan, fsamp))

    def setLength(self, timeSpan):
        r"""setLength(AverageFilterF self, double timeSpan)"""
        return _math.AverageFilterF_setLength(self, timeSpan)

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(AverageFilterF self, double fsamp)"""
        return _math.AverageFilterF_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(AverageFilterF self, int n, double const * params) -> int"""
        return _math.AverageFilterF_setParameters(self, n, params)

    def clone(self):
        r"""clone(AverageFilterF self) -> InPlaceFilterF"""
        return _math.AverageFilterF_clone(self)

    def reset(self):
        r"""reset(AverageFilterF self)"""
        return _math.AverageFilterF_reset(self)
    __swig_destroy__ = _math.delete_AverageFilterF

# Register AverageFilterF in _math:
_math.AverageFilterF_swigregister(AverageFilterF)

class AverageFilterD(InPlaceFilterD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::Average< double > class."""

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

    def __init__(self, timeSpan=1.0, fsamp=0.0):
        r"""__init__(AverageFilterD self, double timeSpan=1.0, double fsamp=0.0) -> AverageFilterD"""
        _math.AverageFilterD_swiginit(self, _math.new_AverageFilterD(timeSpan, fsamp))

    def setLength(self, timeSpan):
        r"""setLength(AverageFilterD self, double timeSpan)"""
        return _math.AverageFilterD_setLength(self, timeSpan)

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(AverageFilterD self, double fsamp)"""
        return _math.AverageFilterD_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(AverageFilterD self, int n, double const * params) -> int"""
        return _math.AverageFilterD_setParameters(self, n, params)

    def clone(self):
        r"""clone(AverageFilterD self) -> InPlaceFilterD"""
        return _math.AverageFilterD_clone(self)

    def reset(self):
        r"""reset(AverageFilterD self)"""
        return _math.AverageFilterD_reset(self)
    __swig_destroy__ = _math.delete_AverageFilterD

# Register AverageFilterD in _math:
_math.AverageFilterD_swigregister(AverageFilterD)

class STALTAFilterF(InPlaceFilterF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::STALTA< float > class."""

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

    def __init__(self, lenSTA=2, lenLTA=50, fsamp=1.):
        r"""__init__(STALTAFilterF self, double lenSTA=2, double lenLTA=50, double fsamp=1.) -> STALTAFilterF"""
        _math.STALTAFilterF_swiginit(self, _math.new_STALTAFilterF(lenSTA, lenLTA, fsamp))

    def reset(self):
        r"""reset(STALTAFilterF self)"""
        return _math.STALTAFilterF_reset(self)

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(STALTAFilterF self, double fsamp)"""
        return _math.STALTAFilterF_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(STALTAFilterF self, int n, double const * params) -> int"""
        return _math.STALTAFilterF_setParameters(self, n, params)

    def clone(self):
        r"""clone(STALTAFilterF self) -> InPlaceFilterF"""
        return _math.STALTAFilterF_clone(self)
    __swig_destroy__ = _math.delete_STALTAFilterF

# Register STALTAFilterF in _math:
_math.STALTAFilterF_swigregister(STALTAFilterF)

class STALTAFilterD(InPlaceFilterD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::STALTA< double > class."""

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

    def __init__(self, lenSTA=2, lenLTA=50, fsamp=1.):
        r"""__init__(STALTAFilterD self, double lenSTA=2, double lenLTA=50, double fsamp=1.) -> STALTAFilterD"""
        _math.STALTAFilterD_swiginit(self, _math.new_STALTAFilterD(lenSTA, lenLTA, fsamp))

    def reset(self):
        r"""reset(STALTAFilterD self)"""
        return _math.STALTAFilterD_reset(self)

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(STALTAFilterD self, double fsamp)"""
        return _math.STALTAFilterD_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(STALTAFilterD self, int n, double const * params) -> int"""
        return _math.STALTAFilterD_setParameters(self, n, params)

    def clone(self):
        r"""clone(STALTAFilterD self) -> InPlaceFilterD"""
        return _math.STALTAFilterD_clone(self)
    __swig_destroy__ = _math.delete_STALTAFilterD

# Register STALTAFilterD in _math:
_math.STALTAFilterD_swigregister(STALTAFilterD)

class STALTA2FilterF(InPlaceFilterF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::STALTA2< float > class."""

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

    def __init__(self, lenSTA=2, lenLTA=50, eventON=3., eventOFF=1., fsamp=1.):
        r"""__init__(STALTA2FilterF self, double lenSTA=2, double lenLTA=50, double eventON=3., double eventOFF=1., double fsamp=1.) -> STALTA2FilterF"""
        _math.STALTA2FilterF_swiginit(self, _math.new_STALTA2FilterF(lenSTA, lenLTA, eventON, eventOFF, fsamp))

    def reset(self):
        r"""reset(STALTA2FilterF self)"""
        return _math.STALTA2FilterF_reset(self)

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(STALTA2FilterF self, double fsamp)"""
        return _math.STALTA2FilterF_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(STALTA2FilterF self, int n, double const * params) -> int"""
        return _math.STALTA2FilterF_setParameters(self, n, params)

    def clone(self):
        r"""clone(STALTA2FilterF self) -> InPlaceFilterF"""
        return _math.STALTA2FilterF_clone(self)
    __swig_destroy__ = _math.delete_STALTA2FilterF

# Register STALTA2FilterF in _math:
_math.STALTA2FilterF_swigregister(STALTA2FilterF)

class STALTA2FilterD(InPlaceFilterD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::STALTA2< double > class."""

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

    def __init__(self, lenSTA=2, lenLTA=50, eventON=3., eventOFF=1., fsamp=1.):
        r"""__init__(STALTA2FilterD self, double lenSTA=2, double lenLTA=50, double eventON=3., double eventOFF=1., double fsamp=1.) -> STALTA2FilterD"""
        _math.STALTA2FilterD_swiginit(self, _math.new_STALTA2FilterD(lenSTA, lenLTA, eventON, eventOFF, fsamp))

    def reset(self):
        r"""reset(STALTA2FilterD self)"""
        return _math.STALTA2FilterD_reset(self)

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(STALTA2FilterD self, double fsamp)"""
        return _math.STALTA2FilterD_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(STALTA2FilterD self, int n, double const * params) -> int"""
        return _math.STALTA2FilterD_setParameters(self, n, params)

    def clone(self):
        r"""clone(STALTA2FilterD self) -> InPlaceFilterD"""
        return _math.STALTA2FilterD_clone(self)
    __swig_destroy__ = _math.delete_STALTA2FilterD

# Register STALTA2FilterD in _math:
_math.STALTA2FilterD_swigregister(STALTA2FilterD)

class STALTAClassicFilterF(InPlaceFilterF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::STALTA_Classic< float > class."""

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

    def __init__(self, lenSTA=2., lenLTA=50., fsamp=1.):
        r"""__init__(STALTAClassicFilterF self, double lenSTA=2., double lenLTA=50., double fsamp=1.) -> STALTAClassicFilterF"""
        _math.STALTAClassicFilterF_swiginit(self, _math.new_STALTAClassicFilterF(lenSTA, lenLTA, fsamp))

    def reset(self):
        r"""reset(STALTAClassicFilterF self)"""
        return _math.STALTAClassicFilterF_reset(self)

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(STALTAClassicFilterF self, double fsamp)"""
        return _math.STALTAClassicFilterF_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(STALTAClassicFilterF self, int n, double const * params) -> int"""
        return _math.STALTAClassicFilterF_setParameters(self, n, params)

    def clone(self):
        r"""clone(STALTAClassicFilterF self) -> InPlaceFilterF"""
        return _math.STALTAClassicFilterF_clone(self)
    __swig_destroy__ = _math.delete_STALTAClassicFilterF

# Register STALTAClassicFilterF in _math:
_math.STALTAClassicFilterF_swigregister(STALTAClassicFilterF)

class STALTAClassicFilterD(InPlaceFilterD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::STALTA_Classic< double > class."""

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

    def __init__(self, lenSTA=2., lenLTA=50., fsamp=1.):
        r"""__init__(STALTAClassicFilterD self, double lenSTA=2., double lenLTA=50., double fsamp=1.) -> STALTAClassicFilterD"""
        _math.STALTAClassicFilterD_swiginit(self, _math.new_STALTAClassicFilterD(lenSTA, lenLTA, fsamp))

    def reset(self):
        r"""reset(STALTAClassicFilterD self)"""
        return _math.STALTAClassicFilterD_reset(self)

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(STALTAClassicFilterD self, double fsamp)"""
        return _math.STALTAClassicFilterD_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(STALTAClassicFilterD self, int n, double const * params) -> int"""
        return _math.STALTAClassicFilterD_setParameters(self, n, params)

    def clone(self):
        r"""clone(STALTAClassicFilterD self) -> InPlaceFilterD"""
        return _math.STALTAClassicFilterD_clone(self)
    __swig_destroy__ = _math.delete_STALTAClassicFilterD

# Register STALTAClassicFilterD in _math:
_math.STALTAClassicFilterD_swigregister(STALTAClassicFilterD)

class RunningMeanFilterF(InPlaceFilterF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::RunningMean< float > class."""

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

    def __init__(self, windowLength=0, fsamp=0.0):
        r"""__init__(RunningMeanFilterF self, double windowLength=0, double fsamp=0.0) -> RunningMeanFilterF"""
        _math.RunningMeanFilterF_swiginit(self, _math.new_RunningMeanFilterF(windowLength, fsamp))
    __swig_destroy__ = _math.delete_RunningMeanFilterF

    def setLength(self, windowLength):
        r"""setLength(RunningMeanFilterF self, double windowLength)"""
        return _math.RunningMeanFilterF_setLength(self, windowLength)

    def clone(self):
        r"""clone(RunningMeanFilterF self) -> InPlaceFilterF"""
        return _math.RunningMeanFilterF_clone(self)

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(RunningMeanFilterF self, double fsamp)"""
        return _math.RunningMeanFilterF_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(RunningMeanFilterF self, int n, double const * params) -> int"""
        return _math.RunningMeanFilterF_setParameters(self, n, params)

    def reset(self):
        r"""reset(RunningMeanFilterF self)"""
        return _math.RunningMeanFilterF_reset(self)

# Register RunningMeanFilterF in _math:
_math.RunningMeanFilterF_swigregister(RunningMeanFilterF)

class RunningMeanFilterD(InPlaceFilterD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::RunningMean< double > class."""

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

    def __init__(self, windowLength=0, fsamp=0.0):
        r"""__init__(RunningMeanFilterD self, double windowLength=0, double fsamp=0.0) -> RunningMeanFilterD"""
        _math.RunningMeanFilterD_swiginit(self, _math.new_RunningMeanFilterD(windowLength, fsamp))
    __swig_destroy__ = _math.delete_RunningMeanFilterD

    def setLength(self, windowLength):
        r"""setLength(RunningMeanFilterD self, double windowLength)"""
        return _math.RunningMeanFilterD_setLength(self, windowLength)

    def clone(self):
        r"""clone(RunningMeanFilterD self) -> InPlaceFilterD"""
        return _math.RunningMeanFilterD_clone(self)

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(RunningMeanFilterD self, double fsamp)"""
        return _math.RunningMeanFilterD_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(RunningMeanFilterD self, int n, double const * params) -> int"""
        return _math.RunningMeanFilterD_setParameters(self, n, params)

    def reset(self):
        r"""reset(RunningMeanFilterD self)"""
        return _math.RunningMeanFilterD_reset(self)

# Register RunningMeanFilterD in _math:
_math.RunningMeanFilterD_swigregister(RunningMeanFilterD)

class RunningMeanHighPassFilterF(RunningMeanFilterF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::RunningMeanHighPass< float > class."""

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

    def __init__(self, windowLength=0, fsamp=0.0):
        r"""__init__(RunningMeanHighPassFilterF self, double windowLength=0, double fsamp=0.0) -> RunningMeanHighPassFilterF"""
        _math.RunningMeanHighPassFilterF_swiginit(self, _math.new_RunningMeanHighPassFilterF(windowLength, fsamp))
    __swig_destroy__ = _math.delete_RunningMeanHighPassFilterF

    def clone(self):
        r"""clone(RunningMeanHighPassFilterF self) -> InPlaceFilterF"""
        return _math.RunningMeanHighPassFilterF_clone(self)

# Register RunningMeanHighPassFilterF in _math:
_math.RunningMeanHighPassFilterF_swigregister(RunningMeanHighPassFilterF)

class RunningMeanHighPassFilterD(RunningMeanFilterD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::RunningMeanHighPass< double > class."""

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

    def __init__(self, windowLength=0, fsamp=0.0):
        r"""__init__(RunningMeanHighPassFilterD self, double windowLength=0, double fsamp=0.0) -> RunningMeanHighPassFilterD"""
        _math.RunningMeanHighPassFilterD_swiginit(self, _math.new_RunningMeanHighPassFilterD(windowLength, fsamp))
    __swig_destroy__ = _math.delete_RunningMeanHighPassFilterD

    def clone(self):
        r"""clone(RunningMeanHighPassFilterD self) -> InPlaceFilterD"""
        return _math.RunningMeanHighPassFilterD_clone(self)

# Register RunningMeanHighPassFilterD in _math:
_math.RunningMeanHighPassFilterD_swigregister(RunningMeanHighPassFilterD)

class InitialTaperFilterF(InPlaceFilterF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::InitialTaper< float > class."""

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

    def __init__(self, taperLength=0, offset=0, fsamp=0):
        r"""__init__(InitialTaperFilterF self, double taperLength=0, float offset=0, double fsamp=0) -> InitialTaperFilterF"""
        _math.InitialTaperFilterF_swiginit(self, _math.new_InitialTaperFilterF(taperLength, offset, fsamp))
    __swig_destroy__ = _math.delete_InitialTaperFilterF

    def setLength(self, taperLength, offset=0):
        r"""setLength(InitialTaperFilterF self, double taperLength, float offset=0)"""
        return _math.InitialTaperFilterF_setLength(self, taperLength, offset)

    def clone(self):
        r"""clone(InitialTaperFilterF self) -> InPlaceFilterF"""
        return _math.InitialTaperFilterF_clone(self)

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(InitialTaperFilterF self, double fsamp)"""
        return _math.InitialTaperFilterF_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(InitialTaperFilterF self, int n, double const * params) -> int"""
        return _math.InitialTaperFilterF_setParameters(self, n, params)

    def reset(self):
        r"""reset(InitialTaperFilterF self)"""
        return _math.InitialTaperFilterF_reset(self)

# Register InitialTaperFilterF in _math:
_math.InitialTaperFilterF_swigregister(InitialTaperFilterF)

class InitialTaperFilterD(InPlaceFilterD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::InitialTaper< double > class."""

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

    def __init__(self, taperLength=0, offset=0, fsamp=0):
        r"""__init__(InitialTaperFilterD self, double taperLength=0, double offset=0, double fsamp=0) -> InitialTaperFilterD"""
        _math.InitialTaperFilterD_swiginit(self, _math.new_InitialTaperFilterD(taperLength, offset, fsamp))
    __swig_destroy__ = _math.delete_InitialTaperFilterD

    def setLength(self, taperLength, offset=0):
        r"""setLength(InitialTaperFilterD self, double taperLength, double offset=0)"""
        return _math.InitialTaperFilterD_setLength(self, taperLength, offset)

    def clone(self):
        r"""clone(InitialTaperFilterD self) -> InPlaceFilterD"""
        return _math.InitialTaperFilterD_clone(self)

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(InitialTaperFilterD self, double fsamp)"""
        return _math.InitialTaperFilterD_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(InitialTaperFilterD self, int n, double const * params) -> int"""
        return _math.InitialTaperFilterD_setParameters(self, n, params)

    def reset(self):
        r"""reset(InitialTaperFilterD self)"""
        return _math.InitialTaperFilterD_reset(self)

# Register InitialTaperFilterD in _math:
_math.InitialTaperFilterD_swigregister(InitialTaperFilterD)

class BiquadCoefficients(object):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::BiquadCoefficients class."""

    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):
        r"""
        __init__(BiquadCoefficients self, double b0=0, double b1=0, double b2=0, double a0=1, double a1=0, double a2=0) -> BiquadCoefficients
        __init__(BiquadCoefficients self, BiquadCoefficients bq) -> BiquadCoefficients
        """
        _math.BiquadCoefficients_swiginit(self, _math.new_BiquadCoefficients(*args))

    def set(self, b0, b1, b2, a0, a1, a2):
        r"""set(BiquadCoefficients self, double b0, double b1, double b2, double a0, double a1, double a2)"""
        return _math.BiquadCoefficients_set(self, b0, b1, b2, a0, a1, a2)
    b0 = property(_math.BiquadCoefficients_b0_get, _math.BiquadCoefficients_b0_set, doc=r"""b0 : double""")
    b1 = property(_math.BiquadCoefficients_b1_get, _math.BiquadCoefficients_b1_set, doc=r"""b1 : double""")
    b2 = property(_math.BiquadCoefficients_b2_get, _math.BiquadCoefficients_b2_set, doc=r"""b2 : double""")
    a0 = property(_math.BiquadCoefficients_a0_get, _math.BiquadCoefficients_a0_set, doc=r"""a0 : double""")
    a1 = property(_math.BiquadCoefficients_a1_get, _math.BiquadCoefficients_a1_set, doc=r"""a1 : double""")
    a2 = property(_math.BiquadCoefficients_a2_get, _math.BiquadCoefficients_a2_set, doc=r"""a2 : double""")
    __swig_destroy__ = _math.delete_BiquadCoefficients

# Register BiquadCoefficients in _math:
_math.BiquadCoefficients_swigregister(BiquadCoefficients)


def __lshift__(os, biq):
    r"""__lshift__(std::ostream & os, BiquadCoefficients biq) -> std::ostream &"""
    return _math.__lshift__(os, biq)
class BiquadCascadeF(InPlaceFilterF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::BiquadCascade< float > class."""

    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):
        r"""
        __init__(BiquadCascadeF self) -> BiquadCascadeF
        __init__(BiquadCascadeF self, BiquadCascadeF other) -> BiquadCascadeF
        """
        _math.BiquadCascadeF_swiginit(self, _math.new_BiquadCascadeF(*args))

    def size(self):
        r"""size(BiquadCascadeF self) -> int"""
        return _math.BiquadCascadeF_size(self)

    def reset(self):
        r"""reset(BiquadCascadeF self)"""
        return _math.BiquadCascadeF_reset(self)

    def append(self, biq):
        r"""append(BiquadCascadeF self, Seiscomp::Math::Filtering::IIR::Biquad< float > const & biq)"""
        return _math.BiquadCascadeF_append(self, biq)

    def set(self, biquads):
        r"""set(BiquadCascadeF self, Seiscomp::Math::Filtering::IIR::Biquads const & biquads)"""
        return _math.BiquadCascadeF_set(self, biquads)

    def clone(self):
        r"""clone(BiquadCascadeF self) -> InPlaceFilterF"""
        return _math.BiquadCascadeF_clone(self)

    def setSamplingFrequency(self, arg2):
        r"""setSamplingFrequency(BiquadCascadeF self, double arg2)"""
        return _math.BiquadCascadeF_setSamplingFrequency(self, arg2)

    def setParameters(self, n, params):
        r"""setParameters(BiquadCascadeF self, int n, double const * params) -> int"""
        return _math.BiquadCascadeF_setParameters(self, n, params)
    __swig_destroy__ = _math.delete_BiquadCascadeF

# Register BiquadCascadeF in _math:
_math.BiquadCascadeF_swigregister(BiquadCascadeF)

class BiquadCascadeD(InPlaceFilterD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::BiquadCascade< double > class."""

    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):
        r"""
        __init__(BiquadCascadeD self) -> BiquadCascadeD
        __init__(BiquadCascadeD self, BiquadCascadeD other) -> BiquadCascadeD
        """
        _math.BiquadCascadeD_swiginit(self, _math.new_BiquadCascadeD(*args))

    def size(self):
        r"""size(BiquadCascadeD self) -> int"""
        return _math.BiquadCascadeD_size(self)

    def reset(self):
        r"""reset(BiquadCascadeD self)"""
        return _math.BiquadCascadeD_reset(self)

    def append(self, biq):
        r"""append(BiquadCascadeD self, Seiscomp::Math::Filtering::IIR::Biquad< double > const & biq)"""
        return _math.BiquadCascadeD_append(self, biq)

    def set(self, biquads):
        r"""set(BiquadCascadeD self, Seiscomp::Math::Filtering::IIR::Biquads const & biquads)"""
        return _math.BiquadCascadeD_set(self, biquads)

    def clone(self):
        r"""clone(BiquadCascadeD self) -> InPlaceFilterD"""
        return _math.BiquadCascadeD_clone(self)

    def setSamplingFrequency(self, arg2):
        r"""setSamplingFrequency(BiquadCascadeD self, double arg2)"""
        return _math.BiquadCascadeD_setSamplingFrequency(self, arg2)

    def setParameters(self, n, params):
        r"""setParameters(BiquadCascadeD self, int n, double const * params) -> int"""
        return _math.BiquadCascadeD_setParameters(self, n, params)
    __swig_destroy__ = _math.delete_BiquadCascadeD

# Register BiquadCascadeD in _math:
_math.BiquadCascadeD_swigregister(BiquadCascadeD)

class ButterworthLowpassF(BiquadCascadeF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::ButterworthLowpass< float > class."""

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

    def __init__(self, order=3, fmax=0.7, fsamp=0):
        r"""__init__(ButterworthLowpassF self, int order=3, double fmax=0.7, double fsamp=0) -> ButterworthLowpassF"""
        _math.ButterworthLowpassF_swiginit(self, _math.new_ButterworthLowpassF(order, fmax, fsamp))

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(ButterworthLowpassF self, double fsamp)"""
        return _math.ButterworthLowpassF_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(ButterworthLowpassF self, int n, double const * params) -> int"""
        return _math.ButterworthLowpassF_setParameters(self, n, params)

    def clone(self):
        r"""clone(ButterworthLowpassF self) -> InPlaceFilterF"""
        return _math.ButterworthLowpassF_clone(self)
    __swig_destroy__ = _math.delete_ButterworthLowpassF

# Register ButterworthLowpassF in _math:
_math.ButterworthLowpassF_swigregister(ButterworthLowpassF)

class ButterworthLowpassD(BiquadCascadeD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::ButterworthLowpass< double > class."""

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

    def __init__(self, order=3, fmax=0.7, fsamp=0):
        r"""__init__(ButterworthLowpassD self, int order=3, double fmax=0.7, double fsamp=0) -> ButterworthLowpassD"""
        _math.ButterworthLowpassD_swiginit(self, _math.new_ButterworthLowpassD(order, fmax, fsamp))

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(ButterworthLowpassD self, double fsamp)"""
        return _math.ButterworthLowpassD_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(ButterworthLowpassD self, int n, double const * params) -> int"""
        return _math.ButterworthLowpassD_setParameters(self, n, params)

    def clone(self):
        r"""clone(ButterworthLowpassD self) -> InPlaceFilterD"""
        return _math.ButterworthLowpassD_clone(self)
    __swig_destroy__ = _math.delete_ButterworthLowpassD

# Register ButterworthLowpassD in _math:
_math.ButterworthLowpassD_swigregister(ButterworthLowpassD)

class ButterworthHighpassF(BiquadCascadeF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::ButterworthHighpass< float > class."""

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

    def __init__(self, order=3, fmin=2.0, fsamp=0):
        r"""__init__(ButterworthHighpassF self, int order=3, double fmin=2.0, double fsamp=0) -> ButterworthHighpassF"""
        _math.ButterworthHighpassF_swiginit(self, _math.new_ButterworthHighpassF(order, fmin, fsamp))

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(ButterworthHighpassF self, double fsamp)"""
        return _math.ButterworthHighpassF_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(ButterworthHighpassF self, int n, double const * params) -> int"""
        return _math.ButterworthHighpassF_setParameters(self, n, params)

    def clone(self):
        r"""clone(ButterworthHighpassF self) -> InPlaceFilterF"""
        return _math.ButterworthHighpassF_clone(self)
    __swig_destroy__ = _math.delete_ButterworthHighpassF

# Register ButterworthHighpassF in _math:
_math.ButterworthHighpassF_swigregister(ButterworthHighpassF)

class ButterworthHighpassD(BiquadCascadeD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::ButterworthHighpass< double > class."""

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

    def __init__(self, order=3, fmin=2.0, fsamp=0):
        r"""__init__(ButterworthHighpassD self, int order=3, double fmin=2.0, double fsamp=0) -> ButterworthHighpassD"""
        _math.ButterworthHighpassD_swiginit(self, _math.new_ButterworthHighpassD(order, fmin, fsamp))

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(ButterworthHighpassD self, double fsamp)"""
        return _math.ButterworthHighpassD_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(ButterworthHighpassD self, int n, double const * params) -> int"""
        return _math.ButterworthHighpassD_setParameters(self, n, params)

    def clone(self):
        r"""clone(ButterworthHighpassD self) -> InPlaceFilterD"""
        return _math.ButterworthHighpassD_clone(self)
    __swig_destroy__ = _math.delete_ButterworthHighpassD

# Register ButterworthHighpassD in _math:
_math.ButterworthHighpassD_swigregister(ButterworthHighpassD)

class ButterworthBandpassF(BiquadCascadeF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::ButterworthBandpass< float > class."""

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

    def __init__(self, order=3, fmin=0.7, fmax=2.0, fsamp=0):
        r"""__init__(ButterworthBandpassF self, int order=3, double fmin=0.7, double fmax=2.0, double fsamp=0) -> ButterworthBandpassF"""
        _math.ButterworthBandpassF_swiginit(self, _math.new_ButterworthBandpassF(order, fmin, fmax, fsamp))

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(ButterworthBandpassF self, double fsamp)"""
        return _math.ButterworthBandpassF_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(ButterworthBandpassF self, int n, double const * params) -> int"""
        return _math.ButterworthBandpassF_setParameters(self, n, params)

    def clone(self):
        r"""clone(ButterworthBandpassF self) -> InPlaceFilterF"""
        return _math.ButterworthBandpassF_clone(self)
    __swig_destroy__ = _math.delete_ButterworthBandpassF

# Register ButterworthBandpassF in _math:
_math.ButterworthBandpassF_swigregister(ButterworthBandpassF)

class ButterworthBandpassD(BiquadCascadeD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::ButterworthBandpass< double > class."""

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

    def __init__(self, order=3, fmin=0.7, fmax=2.0, fsamp=0):
        r"""__init__(ButterworthBandpassD self, int order=3, double fmin=0.7, double fmax=2.0, double fsamp=0) -> ButterworthBandpassD"""
        _math.ButterworthBandpassD_swiginit(self, _math.new_ButterworthBandpassD(order, fmin, fmax, fsamp))

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(ButterworthBandpassD self, double fsamp)"""
        return _math.ButterworthBandpassD_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(ButterworthBandpassD self, int n, double const * params) -> int"""
        return _math.ButterworthBandpassD_setParameters(self, n, params)

    def clone(self):
        r"""clone(ButterworthBandpassD self) -> InPlaceFilterD"""
        return _math.ButterworthBandpassD_clone(self)
    __swig_destroy__ = _math.delete_ButterworthBandpassD

# Register ButterworthBandpassD in _math:
_math.ButterworthBandpassD_swigregister(ButterworthBandpassD)

class ButterworthHighLowpassF(BiquadCascadeF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::ButterworthHighLowpass< float > class."""

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

    def __init__(self, order=3, fmin=0.7, fmax=2.0, fsamp=0):
        r"""__init__(ButterworthHighLowpassF self, int order=3, double fmin=0.7, double fmax=2.0, double fsamp=0) -> ButterworthHighLowpassF"""
        _math.ButterworthHighLowpassF_swiginit(self, _math.new_ButterworthHighLowpassF(order, fmin, fmax, fsamp))

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(ButterworthHighLowpassF self, double fsamp)"""
        return _math.ButterworthHighLowpassF_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(ButterworthHighLowpassF self, int n, double const * params) -> int"""
        return _math.ButterworthHighLowpassF_setParameters(self, n, params)

    def clone(self):
        r"""clone(ButterworthHighLowpassF self) -> InPlaceFilterF"""
        return _math.ButterworthHighLowpassF_clone(self)
    __swig_destroy__ = _math.delete_ButterworthHighLowpassF

# Register ButterworthHighLowpassF in _math:
_math.ButterworthHighLowpassF_swigregister(ButterworthHighLowpassF)

class ButterworthHighLowpassD(BiquadCascadeD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::ButterworthHighLowpass< double > class."""

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

    def __init__(self, order=3, fmin=0.7, fmax=2.0, fsamp=0):
        r"""__init__(ButterworthHighLowpassD self, int order=3, double fmin=0.7, double fmax=2.0, double fsamp=0) -> ButterworthHighLowpassD"""
        _math.ButterworthHighLowpassD_swiginit(self, _math.new_ButterworthHighLowpassD(order, fmin, fmax, fsamp))

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(ButterworthHighLowpassD self, double fsamp)"""
        return _math.ButterworthHighLowpassD_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(ButterworthHighLowpassD self, int n, double const * params) -> int"""
        return _math.ButterworthHighLowpassD_setParameters(self, n, params)

    def clone(self):
        r"""clone(ButterworthHighLowpassD self) -> InPlaceFilterD"""
        return _math.ButterworthHighLowpassD_clone(self)
    __swig_destroy__ = _math.delete_ButterworthHighLowpassD

# Register ButterworthHighLowpassD in _math:
_math.ButterworthHighLowpassD_swigregister(ButterworthHighLowpassD)

class ButterworthBandstopF(BiquadCascadeF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::ButterworthBandstop< float > class."""

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

    def __init__(self, order=3, fmin=0.7, fmax=2.0, fsamp=0):
        r"""__init__(ButterworthBandstopF self, int order=3, double fmin=0.7, double fmax=2.0, double fsamp=0) -> ButterworthBandstopF"""
        _math.ButterworthBandstopF_swiginit(self, _math.new_ButterworthBandstopF(order, fmin, fmax, fsamp))

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(ButterworthBandstopF self, double fsamp)"""
        return _math.ButterworthBandstopF_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(ButterworthBandstopF self, int n, double const * params) -> int"""
        return _math.ButterworthBandstopF_setParameters(self, n, params)

    def clone(self):
        r"""clone(ButterworthBandstopF self) -> InPlaceFilterF"""
        return _math.ButterworthBandstopF_clone(self)
    __swig_destroy__ = _math.delete_ButterworthBandstopF

# Register ButterworthBandstopF in _math:
_math.ButterworthBandstopF_swigregister(ButterworthBandstopF)

class ButterworthBandstopD(BiquadCascadeD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::ButterworthBandstop< double > class."""

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

    def __init__(self, order=3, fmin=0.7, fmax=2.0, fsamp=0):
        r"""__init__(ButterworthBandstopD self, int order=3, double fmin=0.7, double fmax=2.0, double fsamp=0) -> ButterworthBandstopD"""
        _math.ButterworthBandstopD_swiginit(self, _math.new_ButterworthBandstopD(order, fmin, fmax, fsamp))

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(ButterworthBandstopD self, double fsamp)"""
        return _math.ButterworthBandstopD_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(ButterworthBandstopD self, int n, double const * params) -> int"""
        return _math.ButterworthBandstopD_setParameters(self, n, params)

    def clone(self):
        r"""clone(ButterworthBandstopD self) -> InPlaceFilterD"""
        return _math.ButterworthBandstopD_clone(self)
    __swig_destroy__ = _math.delete_ButterworthBandstopD

# Register ButterworthBandstopD in _math:
_math.ButterworthBandstopD_swigregister(ButterworthBandstopD)

class ChainFilterF(InPlaceFilterF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::ChainFilter< float > class."""

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

    def __init__(self):
        r"""__init__(ChainFilterF self) -> ChainFilterF"""
        _math.ChainFilterF_swiginit(self, _math.new_ChainFilterF())
    __swig_destroy__ = _math.delete_ChainFilterF

    def add(self, filter):
        r"""add(ChainFilterF self, InPlaceFilterF filter) -> bool"""
        return _math.ChainFilterF_add(self, filter)

    def remove(self, pos):
        r"""remove(ChainFilterF self, size_t pos) -> bool"""
        return _math.ChainFilterF_remove(self, pos)

    def take(self, pos):
        r"""take(ChainFilterF self, size_t pos) -> InPlaceFilterF"""
        return _math.ChainFilterF_take(self, pos)

    def indexOf(self, filter):
        r"""indexOf(ChainFilterF self, InPlaceFilterF filter) -> size_t"""
        return _math.ChainFilterF_indexOf(self, filter)

    def filterCount(self):
        r"""filterCount(ChainFilterF self) -> size_t"""
        return _math.ChainFilterF_filterCount(self)

    def setStartTime(self, time):
        r"""setStartTime(ChainFilterF self, Time time)"""
        return _math.ChainFilterF_setStartTime(self, time)

    def setStreamID(self, net, sta, loc, cha):
        r"""setStreamID(ChainFilterF self, std::string const & net, std::string const & sta, std::string const & loc, std::string const & cha)"""
        return _math.ChainFilterF_setStreamID(self, net, sta, loc, cha)

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(ChainFilterF self, double fsamp)"""
        return _math.ChainFilterF_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(ChainFilterF self, int n, double const * params) -> int"""
        return _math.ChainFilterF_setParameters(self, n, params)

    def clone(self):
        r"""clone(ChainFilterF self) -> InPlaceFilterF"""
        return _math.ChainFilterF_clone(self)

# Register ChainFilterF in _math:
_math.ChainFilterF_swigregister(ChainFilterF)

class ChainFilterD(InPlaceFilterD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::ChainFilter< double > class."""

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

    def __init__(self):
        r"""__init__(ChainFilterD self) -> ChainFilterD"""
        _math.ChainFilterD_swiginit(self, _math.new_ChainFilterD())
    __swig_destroy__ = _math.delete_ChainFilterD

    def add(self, filter):
        r"""add(ChainFilterD self, InPlaceFilterD filter) -> bool"""
        return _math.ChainFilterD_add(self, filter)

    def remove(self, pos):
        r"""remove(ChainFilterD self, size_t pos) -> bool"""
        return _math.ChainFilterD_remove(self, pos)

    def take(self, pos):
        r"""take(ChainFilterD self, size_t pos) -> InPlaceFilterD"""
        return _math.ChainFilterD_take(self, pos)

    def indexOf(self, filter):
        r"""indexOf(ChainFilterD self, InPlaceFilterD filter) -> size_t"""
        return _math.ChainFilterD_indexOf(self, filter)

    def filterCount(self):
        r"""filterCount(ChainFilterD self) -> size_t"""
        return _math.ChainFilterD_filterCount(self)

    def setStartTime(self, time):
        r"""setStartTime(ChainFilterD self, Time time)"""
        return _math.ChainFilterD_setStartTime(self, time)

    def setStreamID(self, net, sta, loc, cha):
        r"""setStreamID(ChainFilterD self, std::string const & net, std::string const & sta, std::string const & loc, std::string const & cha)"""
        return _math.ChainFilterD_setStreamID(self, net, sta, loc, cha)

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(ChainFilterD self, double fsamp)"""
        return _math.ChainFilterD_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(ChainFilterD self, int n, double const * params) -> int"""
        return _math.ChainFilterD_setParameters(self, n, params)

    def clone(self):
        r"""clone(ChainFilterD self) -> InPlaceFilterD"""
        return _math.ChainFilterD_clone(self)

# Register ChainFilterD in _math:
_math.ChainFilterD_swigregister(ChainFilterD)

Displacement = _math.Displacement

Velocity = _math.Velocity

Acceleration = _math.Acceleration

class FAP(object):
    r"""Proxy of C++ Seiscomp::Math::SeismometerResponse::FAP class."""

    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):
        r"""
        __init__(FAP self) -> FAP
        __init__(FAP self, double f, double a, double p) -> FAP
        """
        _math.FAP_swiginit(self, _math.new_FAP(*args))

    def __lt__(self, other):
        r"""__lt__(FAP self, FAP other) -> bool"""
        return _math.FAP___lt__(self, other)
    frequency = property(_math.FAP_frequency_get, _math.FAP_frequency_set, doc=r"""frequency : double""")
    amplitude = property(_math.FAP_amplitude_get, _math.FAP_amplitude_set, doc=r"""amplitude : double""")
    phaseAngle = property(_math.FAP_phaseAngle_get, _math.FAP_phaseAngle_set, doc=r"""phaseAngle : double""")
    __swig_destroy__ = _math.delete_FAP

# Register FAP in _math:
_math.FAP_swigregister(FAP)

class PolesAndZeros(object):
    r"""Proxy of C++ Seiscomp::Math::SeismometerResponse::PolesAndZeros class."""

    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):
        r"""
        __init__(PolesAndZeros self) -> PolesAndZeros
        __init__(PolesAndZeros self, vectorc poles, vectorc zeros, double norm) -> PolesAndZeros
        __init__(PolesAndZeros self, PolesAndZeros other) -> PolesAndZeros
        """
        _math.PolesAndZeros_swiginit(self, _math.new_PolesAndZeros(*args))
    poles = property(_math.PolesAndZeros_poles_get, _math.PolesAndZeros_poles_set, doc=r"""poles : Seiscomp::Math::SeismometerResponse::Poles""")
    zeros = property(_math.PolesAndZeros_zeros_get, _math.PolesAndZeros_zeros_set, doc=r"""zeros : Seiscomp::Math::SeismometerResponse::Zeros""")
    norm = property(_math.PolesAndZeros_norm_get, _math.PolesAndZeros_norm_set, doc=r"""norm : double""")
    __swig_destroy__ = _math.delete_PolesAndZeros

# Register PolesAndZeros in _math:
_math.PolesAndZeros_swigregister(PolesAndZeros)

class WoodAnderson(PolesAndZeros):
    r"""Proxy of C++ Seiscomp::Math::SeismometerResponse::WoodAnderson class."""

    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):
        r"""__init__(WoodAnderson self, Seiscomp::Math::GroundMotion input, Seiscomp::Math::SeismometerResponse::WoodAnderson::Config config=Seiscomp::Math::SeismometerResponse::WoodAnderson::Config()) -> WoodAnderson"""
        _math.WoodAnderson_swiginit(self, _math.new_WoodAnderson(*args))
    __swig_destroy__ = _math.delete_WoodAnderson

# Register WoodAnderson in _math:
_math.WoodAnderson_swigregister(WoodAnderson)

class Seismometer5sec(PolesAndZeros):
    r"""Proxy of C++ Seiscomp::Math::SeismometerResponse::Seismometer5sec class."""

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

    def __init__(self, input):
        r"""__init__(Seismometer5sec self, Seiscomp::Math::GroundMotion input) -> Seismometer5sec"""
        _math.Seismometer5sec_swiginit(self, _math.new_Seismometer5sec(input))
    __swig_destroy__ = _math.delete_Seismometer5sec

# Register Seismometer5sec in _math:
_math.Seismometer5sec_swigregister(Seismometer5sec)

class SeismometerFilterF(PolesAndZeros, InPlaceFilterF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::Filter< float > class."""

    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):
        r"""
        __init__(SeismometerFilterF self) -> SeismometerFilterF
        __init__(SeismometerFilterF self, vectorc poles, vectorc zeros, double norm) -> SeismometerFilterF
        __init__(SeismometerFilterF self, SeismometerFilterF other) -> SeismometerFilterF
        """
        _math.SeismometerFilterF_swiginit(self, _math.new_SeismometerFilterF(*args))

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(SeismometerFilterF self, double fsamp)"""
        return _math.SeismometerFilterF_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(SeismometerFilterF self, int n, double const * params) -> int"""
        return _math.SeismometerFilterF_setParameters(self, n, params)

    def clone(self):
        r"""clone(SeismometerFilterF self) -> InPlaceFilterF"""
        return _math.SeismometerFilterF_clone(self)
    __swig_destroy__ = _math.delete_SeismometerFilterF

# Register SeismometerFilterF in _math:
_math.SeismometerFilterF_swigregister(SeismometerFilterF)

class SeismometerFilterD(PolesAndZeros, InPlaceFilterD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::Filter< double > class."""

    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):
        r"""
        __init__(SeismometerFilterD self) -> SeismometerFilterD
        __init__(SeismometerFilterD self, vectorc poles, vectorc zeros, double norm) -> SeismometerFilterD
        __init__(SeismometerFilterD self, SeismometerFilterD other) -> SeismometerFilterD
        """
        _math.SeismometerFilterD_swiginit(self, _math.new_SeismometerFilterD(*args))

    def setSamplingFrequency(self, fsamp):
        r"""setSamplingFrequency(SeismometerFilterD self, double fsamp)"""
        return _math.SeismometerFilterD_setSamplingFrequency(self, fsamp)

    def setParameters(self, n, params):
        r"""setParameters(SeismometerFilterD self, int n, double const * params) -> int"""
        return _math.SeismometerFilterD_setParameters(self, n, params)

    def clone(self):
        r"""clone(SeismometerFilterD self) -> InPlaceFilterD"""
        return _math.SeismometerFilterD_clone(self)
    __swig_destroy__ = _math.delete_SeismometerFilterD

# Register SeismometerFilterD in _math:
_math.SeismometerFilterD_swigregister(SeismometerFilterD)

class WWSSN_SPF(SeismometerFilterF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::WWSSN_SP_Filter< float > class."""

    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):
        r"""
        __init__(WWSSN_SPF self, Seiscomp::Math::GroundMotion input=Velocity) -> WWSSN_SPF
        __init__(WWSSN_SPF self, WWSSN_SPF other) -> WWSSN_SPF
        """
        _math.WWSSN_SPF_swiginit(self, _math.new_WWSSN_SPF(*args))

    def setParameters(self, n, params):
        r"""setParameters(WWSSN_SPF self, int n, double const * params) -> int"""
        return _math.WWSSN_SPF_setParameters(self, n, params)

    def clone(self):
        r"""clone(WWSSN_SPF self) -> InPlaceFilterF"""
        return _math.WWSSN_SPF_clone(self)

    def setInput(self, input):
        r"""setInput(WWSSN_SPF self, Seiscomp::Math::GroundMotion input)"""
        return _math.WWSSN_SPF_setInput(self, input)
    __swig_destroy__ = _math.delete_WWSSN_SPF

# Register WWSSN_SPF in _math:
_math.WWSSN_SPF_swigregister(WWSSN_SPF)

class WWSSN_SPD(SeismometerFilterD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::WWSSN_SP_Filter< double > class."""

    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):
        r"""
        __init__(WWSSN_SPD self, Seiscomp::Math::GroundMotion input=Velocity) -> WWSSN_SPD
        __init__(WWSSN_SPD self, WWSSN_SPD other) -> WWSSN_SPD
        """
        _math.WWSSN_SPD_swiginit(self, _math.new_WWSSN_SPD(*args))

    def setParameters(self, n, params):
        r"""setParameters(WWSSN_SPD self, int n, double const * params) -> int"""
        return _math.WWSSN_SPD_setParameters(self, n, params)

    def clone(self):
        r"""clone(WWSSN_SPD self) -> InPlaceFilterD"""
        return _math.WWSSN_SPD_clone(self)

    def setInput(self, input):
        r"""setInput(WWSSN_SPD self, Seiscomp::Math::GroundMotion input)"""
        return _math.WWSSN_SPD_setInput(self, input)
    __swig_destroy__ = _math.delete_WWSSN_SPD

# Register WWSSN_SPD in _math:
_math.WWSSN_SPD_swigregister(WWSSN_SPD)

class WWSSN_LPF(SeismometerFilterF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::WWSSN_LP_Filter< float > class."""

    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):
        r"""
        __init__(WWSSN_LPF self, Seiscomp::Math::GroundMotion input=Velocity) -> WWSSN_LPF
        __init__(WWSSN_LPF self, WWSSN_LPF other) -> WWSSN_LPF
        """
        _math.WWSSN_LPF_swiginit(self, _math.new_WWSSN_LPF(*args))

    def setParameters(self, n, params):
        r"""setParameters(WWSSN_LPF self, int n, double const * params) -> int"""
        return _math.WWSSN_LPF_setParameters(self, n, params)

    def clone(self):
        r"""clone(WWSSN_LPF self) -> InPlaceFilterF"""
        return _math.WWSSN_LPF_clone(self)

    def setInput(self, input):
        r"""setInput(WWSSN_LPF self, Seiscomp::Math::GroundMotion input)"""
        return _math.WWSSN_LPF_setInput(self, input)
    __swig_destroy__ = _math.delete_WWSSN_LPF

# Register WWSSN_LPF in _math:
_math.WWSSN_LPF_swigregister(WWSSN_LPF)

class WWSSN_LPD(SeismometerFilterD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::WWSSN_LP_Filter< double > class."""

    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):
        r"""
        __init__(WWSSN_LPD self, Seiscomp::Math::GroundMotion input=Velocity) -> WWSSN_LPD
        __init__(WWSSN_LPD self, WWSSN_LPD other) -> WWSSN_LPD
        """
        _math.WWSSN_LPD_swiginit(self, _math.new_WWSSN_LPD(*args))

    def setParameters(self, n, params):
        r"""setParameters(WWSSN_LPD self, int n, double const * params) -> int"""
        return _math.WWSSN_LPD_setParameters(self, n, params)

    def clone(self):
        r"""clone(WWSSN_LPD self) -> InPlaceFilterD"""
        return _math.WWSSN_LPD_clone(self)

    def setInput(self, input):
        r"""setInput(WWSSN_LPD self, Seiscomp::Math::GroundMotion input)"""
        return _math.WWSSN_LPD_setInput(self, input)
    __swig_destroy__ = _math.delete_WWSSN_LPD

# Register WWSSN_LPD in _math:
_math.WWSSN_LPD_swigregister(WWSSN_LPD)

class WoodAndersonFilterF(SeismometerFilterF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::WoodAndersonFilter< float > class."""

    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):
        r"""
        __init__(WoodAndersonFilterF self, Seiscomp::Math::GroundMotion input=Velocity, Seiscomp::Math::SeismometerResponse::WoodAnderson::Config config=Seiscomp::Math::SeismometerResponse::WoodAnderson::Config()) -> WoodAndersonFilterF
        __init__(WoodAndersonFilterF self, WoodAndersonFilterF other) -> WoodAndersonFilterF
        """
        _math.WoodAndersonFilterF_swiginit(self, _math.new_WoodAndersonFilterF(*args))

    def setParameters(self, n, params):
        r"""setParameters(WoodAndersonFilterF self, int n, double const * params) -> int"""
        return _math.WoodAndersonFilterF_setParameters(self, n, params)

    def clone(self):
        r"""clone(WoodAndersonFilterF self) -> InPlaceFilterF"""
        return _math.WoodAndersonFilterF_clone(self)

    def setInput(self, *args):
        r"""setInput(WoodAndersonFilterF self, Seiscomp::Math::GroundMotion input, Seiscomp::Math::SeismometerResponse::WoodAnderson::Config config=Seiscomp::Math::SeismometerResponse::WoodAnderson::Config())"""
        return _math.WoodAndersonFilterF_setInput(self, *args)
    __swig_destroy__ = _math.delete_WoodAndersonFilterF

# Register WoodAndersonFilterF in _math:
_math.WoodAndersonFilterF_swigregister(WoodAndersonFilterF)

class WoodAndersonFilterD(SeismometerFilterD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::WoodAndersonFilter< double > class."""

    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):
        r"""
        __init__(WoodAndersonFilterD self, Seiscomp::Math::GroundMotion input=Velocity, Seiscomp::Math::SeismometerResponse::WoodAnderson::Config config=Seiscomp::Math::SeismometerResponse::WoodAnderson::Config()) -> WoodAndersonFilterD
        __init__(WoodAndersonFilterD self, WoodAndersonFilterD other) -> WoodAndersonFilterD
        """
        _math.WoodAndersonFilterD_swiginit(self, _math.new_WoodAndersonFilterD(*args))

    def setParameters(self, n, params):
        r"""setParameters(WoodAndersonFilterD self, int n, double const * params) -> int"""
        return _math.WoodAndersonFilterD_setParameters(self, n, params)

    def clone(self):
        r"""clone(WoodAndersonFilterD self) -> InPlaceFilterD"""
        return _math.WoodAndersonFilterD_clone(self)

    def setInput(self, *args):
        r"""setInput(WoodAndersonFilterD self, Seiscomp::Math::GroundMotion input, Seiscomp::Math::SeismometerResponse::WoodAnderson::Config config=Seiscomp::Math::SeismometerResponse::WoodAnderson::Config())"""
        return _math.WoodAndersonFilterD_setInput(self, *args)
    __swig_destroy__ = _math.delete_WoodAndersonFilterD

# Register WoodAndersonFilterD in _math:
_math.WoodAndersonFilterD_swigregister(WoodAndersonFilterD)

class GenericSeismometerFilterF(SeismometerFilterF):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::GenericSeismometer< float > class."""

    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):
        r"""
        __init__(GenericSeismometerFilterF self, double cornerPeriod=1., Seiscomp::Math::GroundMotion input=Velocity) -> GenericSeismometerFilterF
        __init__(GenericSeismometerFilterF self, GenericSeismometerFilterF other) -> GenericSeismometerFilterF
        """
        _math.GenericSeismometerFilterF_swiginit(self, _math.new_GenericSeismometerFilterF(*args))

    def setParameters(self, n, params):
        r"""setParameters(GenericSeismometerFilterF self, int n, double const * params) -> int"""
        return _math.GenericSeismometerFilterF_setParameters(self, n, params)

    def clone(self):
        r"""clone(GenericSeismometerFilterF self) -> InPlaceFilterF"""
        return _math.GenericSeismometerFilterF_clone(self)

    def setInput(self, input):
        r"""setInput(GenericSeismometerFilterF self, Seiscomp::Math::GroundMotion input)"""
        return _math.GenericSeismometerFilterF_setInput(self, input)
    __swig_destroy__ = _math.delete_GenericSeismometerFilterF

# Register GenericSeismometerFilterF in _math:
_math.GenericSeismometerFilterF_swigregister(GenericSeismometerFilterF)

class GenericSeismometerFilterD(SeismometerFilterD):
    r"""Proxy of C++ Seiscomp::Math::Filtering::IIR::GenericSeismometer< double > class."""

    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):
        r"""
        __init__(GenericSeismometerFilterD self, double cornerPeriod=1., Seiscomp::Math::GroundMotion input=Velocity) -> GenericSeismometerFilterD
        __init__(GenericSeismometerFilterD self, GenericSeismometerFilterD other) -> GenericSeismometerFilterD
        """
        _math.GenericSeismometerFilterD_swiginit(self, _math.new_GenericSeismometerFilterD(*args))

    def setParameters(self, n, params):
        r"""setParameters(GenericSeismometerFilterD self, int n, double const * params) -> int"""
        return _math.GenericSeismometerFilterD_setParameters(self, n, params)

    def clone(self):
        r"""clone(GenericSeismometerFilterD self) -> InPlaceFilterD"""
        return _math.GenericSeismometerFilterD_clone(self)

    def setInput(self, input):
        r"""setInput(GenericSeismometerFilterD self, Seiscomp::Math::GroundMotion input)"""
        return _math.GenericSeismometerFilterD_setInput(self, input)
    __swig_destroy__ = _math.delete_GenericSeismometerFilterD

# Register GenericSeismometerFilterD in _math:
_math.GenericSeismometerFilterD_swigregister(GenericSeismometerFilterD)


def delazi(lat1, lon1, lat2, lon2):
    r"""delazi(double lat1, double lon1, double lat2, double lon2)"""
    return _math.delazi(lat1, lon1, lat2, lon2)

def delazi_wgs84(lat1, lon1, lat2, lon2):
    r"""delazi_wgs84(double lat1, double lon1, double lat2, double lon2)"""
    return _math.delazi_wgs84(lat1, lon1, lat2, lon2)

def delandaz2coord(dist, azi, lat0, lon0):
    r"""delandaz2coord(double dist, double azi, double lat0, double lon0)"""
    return _math.delandaz2coord(dist, azi, lat0, lon0)

def scxsc(lat1, lon1, r1, lat2, lon2, r2, latx1, lonx1, latx2, lonx2, epsilon=0):
    r"""scxsc(double lat1, double lon1, double r1, double lat2, double lon2, double r2, double * latx1, double * lonx1, double * latx2, double * lonx2, double epsilon=0) -> int"""
    return _math.scxsc(lat1, lon1, r1, lat2, lon2, r2, latx1, lonx1, latx2, lonx2, epsilon)

def scdraw(lat0, lon0, radius, n, lat, lon):
    r"""scdraw(double lat0, double lon0, double radius, int n, double * lat, double * lon) -> int"""
    return _math.scdraw(lat0, lon0, radius, n, lat, lon)
KM_OF_DEGREE = _math.KM_OF_DEGREE


def xyz2ltp(x, y, z, lat, lon, alt):
    r"""xyz2ltp(double const x, double const y, double const z, double * lat, double * lon, double * alt)"""
    return _math.xyz2ltp(x, y, z, lat, lon, alt)

def ltp2xyz(lat, lon, alt, x, y, z):
    r"""ltp2xyz(double lat, double lon, double alt, double * x, double * y, double * z)"""
    return _math.ltp2xyz(lat, lon, alt, x, y, z)

def nearestHotspot(lat, lon, maxDist, coords):
    r"""nearestHotspot(double lat, double lon, double maxDist, HotspotListD coords) -> NamedCoordD"""
    return _math.nearestHotspot(lat, lon, maxDist, coords)

def nearestCity(*args):
    r"""
    nearestCity(double lat, double lon, double maxDist, double minPopulation, int nCities, CityD cityArray) -> CityD
    nearestCity(double lat, double lon, double maxDist, double minPopulation, CityListD cities) -> CityD
    """
    return _math.nearestCity(*args)

def largestCity(lat, lon, maxDist, cities):
    r"""largestCity(double lat, double lon, double maxDist, CityListD cities) -> CityD"""
    return _math.largestCity(lat, lon, maxDist, cities)
class PositionInterpolator(object):
    r"""Proxy of C++ Seiscomp::Math::Geo::PositionInterpolator class."""

    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):
        r"""
        __init__(PositionInterpolator self, double lat1, double lon1, double lat2, double lon2, int steps) -> PositionInterpolator
        __init__(PositionInterpolator self, double lat1, double lon1, double lat2, double lon2, double stepsDistScale) -> PositionInterpolator
        """
        _math.PositionInterpolator_swiginit(self, _math.new_PositionInterpolator(*args))

    def end(self):
        r"""end(PositionInterpolator self) -> bool"""
        return _math.PositionInterpolator_end(self)

    def overallDistance(self):
        r"""overallDistance(PositionInterpolator self) -> double"""
        return _math.PositionInterpolator_overallDistance(self)

    def distance(self):
        r"""distance(PositionInterpolator self) -> double"""
        return _math.PositionInterpolator_distance(self)

    def azimuth(self):
        r"""azimuth(PositionInterpolator self) -> double"""
        return _math.PositionInterpolator_azimuth(self)

    def latitude(self):
        r"""latitude(PositionInterpolator self) -> double"""
        return _math.PositionInterpolator_latitude(self)

    def longitude(self):
        r"""longitude(PositionInterpolator self) -> double"""
        return _math.PositionInterpolator_longitude(self)
    __swig_destroy__ = _math.delete_PositionInterpolator

# Register PositionInterpolator in _math:
_math.PositionInterpolator_swigregister(PositionInterpolator)


def deg2km(deg):
    r"""deg2km(double deg) -> double"""
    return _math.deg2km(deg)
class TransferFunction(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::Math::Restitution::FFT::TransferFunction class."""

    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

    def __mul__(self, a):
        r"""__mul__(TransferFunction self, TransferFunction a) -> TransferFunction"""
        return _math.TransferFunction___mul__(self, a)

    def __truediv__(self, *args):
        return _math.TransferFunction___truediv__(self, *args)
    __div__ = __truediv__



    def evaluate(self, *args):
        r"""
        evaluate(TransferFunction self, Seiscomp::Math::Complex * out, int n, double const * x)
        evaluate(TransferFunction self, vectorc out, vectord x)
        """
        return _math.TransferFunction_evaluate(self, *args)

    def deconvolve(self, *args):
        r"""
        deconvolve(TransferFunction self, int n, Seiscomp::Math::Complex * spec, double startFreq, double df)
        deconvolve(TransferFunction self, vectorc spec, double startFreq, double df)
        """
        return _math.TransferFunction_deconvolve(self, *args)

    def convolve(self, *args):
        r"""
        convolve(TransferFunction self, int n, Seiscomp::Math::Complex * spec, double startFreq, double df)
        convolve(TransferFunction self, vectorc spec, double startFreq, double df)
        """
        return _math.TransferFunction_convolve(self, *args)
    __swig_destroy__ = _math.delete_TransferFunction

# Register TransferFunction in _math:
_math.TransferFunction_swigregister(TransferFunction)

class TransferFunctionPAZ(TransferFunction):
    r"""Proxy of C++ Seiscomp::Math::Restitution::FFT::PolesAndZeros class."""

    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):
        r"""
        PolesAndZeros(PolesAndZeros polesAndZeros) -> TransferFunctionPAZ
        PolesAndZeros(int n_poles, Seiscomp::Math::Restitution::Pole * poles, int n_zeros, Seiscomp::Math::Restitution::Zero * zeros, double k, int addZeros=0) -> TransferFunctionPAZ
        """
        _math.TransferFunctionPAZ_swiginit(self, _math.new_TransferFunctionPAZ(*args))
    paz = property(_math.TransferFunctionPAZ_paz_get, _math.TransferFunctionPAZ_paz_set, doc=r"""paz : Seiscomp::Math::SeismometerResponse::PolesAndZeros""")
    __swig_destroy__ = _math.delete_TransferFunctionPAZ

# Register TransferFunctionPAZ in _math:
_math.TransferFunctionPAZ_swigregister(TransferFunctionPAZ)

class ResponseList(TransferFunction):
    r"""Proxy of C++ Seiscomp::Math::Restitution::FFT::ResponseList class."""

    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):
        r"""
        __init__(ResponseList self, Seiscomp::Math::SeismometerResponse::FAPs const & faps, int addZeros=0) -> ResponseList
        __init__(ResponseList self, int n_tuples, FAP faps, int addZeros=0) -> ResponseList
        """
        _math.ResponseList_swiginit(self, _math.new_ResponseList(*args))
    faps = property(_math.ResponseList_faps_get, _math.ResponseList_faps_set, doc=r"""faps : Seiscomp::Math::SeismometerResponse::FAPs""")
    nZeros = property(_math.ResponseList_nZeros_get, _math.ResponseList_nZeros_set, doc=r"""nZeros : int""")
    __swig_destroy__ = _math.delete_ResponseList

# Register ResponseList in _math:
_math.ResponseList_swigregister(ResponseList)


def fft(spec, data):
    r"""fft(ComplexDoubleArray spec, DoubleArray data)"""
    return _math.fft(spec, data)

def ifft(out, spec):
    r"""ifft(DoubleArray out, ComplexDoubleArray spec)"""
    return _math.ifft(out, spec)
class vectorc(object):
    r"""Proxy of C++ std::vector< Seiscomp::Math::Complex > class."""

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

    def iterator(self):
        r"""iterator(vectorc self) -> SwigPyIterator"""
        return _math.vectorc_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vectorc self) -> bool"""
        return _math.vectorc___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vectorc self) -> bool"""
        return _math.vectorc___bool__(self)

    def __len__(self):
        r"""__len__(vectorc self) -> std::vector< std::complex< double > >::size_type"""
        return _math.vectorc___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vectorc self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j) -> vectorc"""
        return _math.vectorc___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vectorc self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)
        __setslice__(vectorc self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j, vectorc v)
        """
        return _math.vectorc___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vectorc self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)"""
        return _math.vectorc___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vectorc self, std::vector< std::complex< double > >::difference_type i)
        __delitem__(vectorc self, PySliceObject * slice)
        """
        return _math.vectorc___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vectorc self, PySliceObject * slice) -> vectorc
        __getitem__(vectorc self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &
        """
        return _math.vectorc___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vectorc self, PySliceObject * slice, vectorc v)
        __setitem__(vectorc self, PySliceObject * slice)
        __setitem__(vectorc self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)
        """
        return _math.vectorc___setitem__(self, *args)

    def pop(self):
        r"""pop(vectorc self) -> std::vector< std::complex< double > >::value_type"""
        return _math.vectorc_pop(self)

    def append(self, x):
        r"""append(vectorc self, std::vector< std::complex< double > >::value_type const & x)"""
        return _math.vectorc_append(self, x)

    def empty(self):
        r"""empty(vectorc self) -> bool"""
        return _math.vectorc_empty(self)

    def size(self):
        r"""size(vectorc self) -> std::vector< std::complex< double > >::size_type"""
        return _math.vectorc_size(self)

    def swap(self, v):
        r"""swap(vectorc self, vectorc v)"""
        return _math.vectorc_swap(self, v)

    def begin(self):
        r"""begin(vectorc self) -> std::vector< std::complex< double > >::iterator"""
        return _math.vectorc_begin(self)

    def end(self):
        r"""end(vectorc self) -> std::vector< std::complex< double > >::iterator"""
        return _math.vectorc_end(self)

    def rbegin(self):
        r"""rbegin(vectorc self) -> std::vector< std::complex< double > >::reverse_iterator"""
        return _math.vectorc_rbegin(self)

    def rend(self):
        r"""rend(vectorc self) -> std::vector< std::complex< double > >::reverse_iterator"""
        return _math.vectorc_rend(self)

    def clear(self):
        r"""clear(vectorc self)"""
        return _math.vectorc_clear(self)

    def get_allocator(self):
        r"""get_allocator(vectorc self) -> std::vector< std::complex< double > >::allocator_type"""
        return _math.vectorc_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vectorc self)"""
        return _math.vectorc_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vectorc self, std::vector< std::complex< double > >::iterator pos) -> std::vector< std::complex< double > >::iterator
        erase(vectorc self, std::vector< std::complex< double > >::iterator first, std::vector< std::complex< double > >::iterator last) -> std::vector< std::complex< double > >::iterator
        """
        return _math.vectorc_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vectorc self) -> vectorc
        __init__(vectorc self, vectorc other) -> vectorc
        __init__(vectorc self, std::vector< std::complex< double > >::size_type size) -> vectorc
        __init__(vectorc self, std::vector< std::complex< double > >::size_type size, std::vector< std::complex< double > >::value_type const & value) -> vectorc
        """
        _math.vectorc_swiginit(self, _math.new_vectorc(*args))

    def push_back(self, x):
        r"""push_back(vectorc self, std::vector< std::complex< double > >::value_type const & x)"""
        return _math.vectorc_push_back(self, x)

    def front(self):
        r"""front(vectorc self) -> std::vector< std::complex< double > >::value_type const &"""
        return _math.vectorc_front(self)

    def back(self):
        r"""back(vectorc self) -> std::vector< std::complex< double > >::value_type const &"""
        return _math.vectorc_back(self)

    def assign(self, n, x):
        r"""assign(vectorc self, std::vector< std::complex< double > >::size_type n, std::vector< std::complex< double > >::value_type const & x)"""
        return _math.vectorc_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vectorc self, std::vector< std::complex< double > >::size_type new_size)
        resize(vectorc self, std::vector< std::complex< double > >::size_type new_size, std::vector< std::complex< double > >::value_type const & x)
        """
        return _math.vectorc_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vectorc self, std::vector< std::complex< double > >::iterator pos, std::vector< std::complex< double > >::value_type const & x) -> std::vector< std::complex< double > >::iterator
        insert(vectorc self, std::vector< std::complex< double > >::iterator pos, std::vector< std::complex< double > >::size_type n, std::vector< std::complex< double > >::value_type const & x)
        """
        return _math.vectorc_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vectorc self, std::vector< std::complex< double > >::size_type n)"""
        return _math.vectorc_reserve(self, n)

    def capacity(self):
        r"""capacity(vectorc self) -> std::vector< std::complex< double > >::size_type"""
        return _math.vectorc_capacity(self)
    __swig_destroy__ = _math.delete_vectorc

# Register vectorc in _math:
_math.vectorc_swigregister(vectorc)