benjamin
/
seiscomp-training
1
0
Fork 0
Code Pull Requests Packages Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
main
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '906e9ccf6b'
${ noResults }
seiscomp-training/lib/python/seiscomp/math.py

3140 lines
131 KiB
Python
Raw Normal View History Unescape Escape

[installation] Initial commit with first config
1 year ago
# 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)