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.
3140 lines
131 KiB
Python
3140 lines
131 KiB
Python
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)
|
||
|
|
||
|
|
||
|
|