# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
raise RuntimeError("Python 2.7 or later required")
import _libBornAgainBase
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__)
import weakref
class SwigPyIterator(object):
r"""Proxy of C++ swig::SwigPyIterator 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__ = _libBornAgainBase.delete_SwigPyIterator
def value(self):
r"""value(SwigPyIterator self) -> PyObject *"""
return _libBornAgainBase.SwigPyIterator_value(self)
def incr(self, n=1):
r"""incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
return _libBornAgainBase.SwigPyIterator_incr(self, n)
def decr(self, n=1):
r"""decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
return _libBornAgainBase.SwigPyIterator_decr(self, n)
def distance(self, x):
r"""distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
return _libBornAgainBase.SwigPyIterator_distance(self, x)
def equal(self, x):
r"""equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
return _libBornAgainBase.SwigPyIterator_equal(self, x)
def copy(self):
r"""copy(SwigPyIterator self) -> SwigPyIterator"""
return _libBornAgainBase.SwigPyIterator_copy(self)
def next(self):
r"""next(SwigPyIterator self) -> PyObject *"""
return _libBornAgainBase.SwigPyIterator_next(self)
def __next__(self):
r"""__next__(SwigPyIterator self) -> PyObject *"""
return _libBornAgainBase.SwigPyIterator___next__(self)
def previous(self):
r"""previous(SwigPyIterator self) -> PyObject *"""
return _libBornAgainBase.SwigPyIterator_previous(self)
def advance(self, n):
r"""advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
return _libBornAgainBase.SwigPyIterator_advance(self, n)
def __eq__(self, x):
r"""__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
return _libBornAgainBase.SwigPyIterator___eq__(self, x)
def __ne__(self, x):
r"""__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
return _libBornAgainBase.SwigPyIterator___ne__(self, x)
def __iadd__(self, n):
r"""__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
return _libBornAgainBase.SwigPyIterator___iadd__(self, n)
def __isub__(self, n):
r"""__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
return _libBornAgainBase.SwigPyIterator___isub__(self, n)
def __add__(self, n):
r"""__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
return _libBornAgainBase.SwigPyIterator___add__(self, n)
def __sub__(self, *args):
r"""
__sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
__sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
"""
return _libBornAgainBase.SwigPyIterator___sub__(self, *args)
def __iter__(self):
return self
# Register SwigPyIterator in _libBornAgainBase:
_libBornAgainBase.SwigPyIterator_swigregister(SwigPyIterator)
SHARED_PTR_DISOWN = _libBornAgainBase.SHARED_PTR_DISOWN
import warnings
def deprecated(message):
def deprecated_decorator(func):
def deprecated_func(*args, **kwargs):
warnings.simplefilter('always', DeprecationWarning) # turn off filter
warnings.warn("{} is a deprecated function. {}".format(func.__name__, message),
category=DeprecationWarning,
stacklevel=2)
warnings.simplefilter('default', DeprecationWarning) # reset filter
return func(*args, **kwargs)
return deprecated_func
return deprecated_decorator
class arrayR3_t(object):
r"""Proxy of C++ std::array< double,3 > 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(arrayR3_t self) -> SwigPyIterator"""
return _libBornAgainBase.arrayR3_t_iterator(self)
def __iter__(self):
return self.iterator()
def __nonzero__(self):
r"""__nonzero__(arrayR3_t self) -> bool"""
return _libBornAgainBase.arrayR3_t___nonzero__(self)
def __bool__(self):
r"""__bool__(arrayR3_t self) -> bool"""
return _libBornAgainBase.arrayR3_t___bool__(self)
def __len__(self):
r"""__len__(arrayR3_t self) -> std::array< double,3 >::size_type"""
return _libBornAgainBase.arrayR3_t___len__(self)
def __getslice__(self, i, j):
r"""__getslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j) -> arrayR3_t"""
return _libBornAgainBase.arrayR3_t___getslice__(self, i, j)
def __setslice__(self, *args):
r"""
__setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)
__setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j, arrayR3_t v)
"""
return _libBornAgainBase.arrayR3_t___setslice__(self, *args)
def __delslice__(self, i, j):
r"""__delslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)"""
return _libBornAgainBase.arrayR3_t___delslice__(self, i, j)
def __delitem__(self, *args):
r"""
__delitem__(arrayR3_t self, std::array< double,3 >::difference_type i)
__delitem__(arrayR3_t self, PySliceObject * slice)
"""
return _libBornAgainBase.arrayR3_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
__getitem__(arrayR3_t self, PySliceObject * slice) -> arrayR3_t
__getitem__(arrayR3_t self, std::array< double,3 >::difference_type i) -> std::array< double,3 >::value_type const &
"""
return _libBornAgainBase.arrayR3_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
__setitem__(arrayR3_t self, PySliceObject * slice, arrayR3_t v)
__setitem__(arrayR3_t self, PySliceObject * slice)
__setitem__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::value_type const & x)
"""
return _libBornAgainBase.arrayR3_t___setitem__(self, *args)
def __init__(self, *args):
r"""
__init__(arrayR3_t self) -> arrayR3_t
__init__(arrayR3_t self, arrayR3_t other) -> arrayR3_t
"""
_libBornAgainBase.arrayR3_t_swiginit(self, _libBornAgainBase.new_arrayR3_t(*args))
def empty(self):
r"""empty(arrayR3_t self) -> bool"""
return _libBornAgainBase.arrayR3_t_empty(self)
def size(self):
r"""size(arrayR3_t self) -> std::array< double,3 >::size_type"""
return _libBornAgainBase.arrayR3_t_size(self)
def swap(self, v):
r"""swap(arrayR3_t self, arrayR3_t v)"""
return _libBornAgainBase.arrayR3_t_swap(self, v)
def begin(self):
r"""begin(arrayR3_t self) -> std::array< double,3 >::iterator"""
return _libBornAgainBase.arrayR3_t_begin(self)
def end(self):
r"""end(arrayR3_t self) -> std::array< double,3 >::iterator"""
return _libBornAgainBase.arrayR3_t_end(self)
def rbegin(self):
r"""rbegin(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"""
return _libBornAgainBase.arrayR3_t_rbegin(self)
def rend(self):
r"""rend(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"""
return _libBornAgainBase.arrayR3_t_rend(self)
def front(self):
r"""front(arrayR3_t self) -> std::array< double,3 >::value_type const &"""
return _libBornAgainBase.arrayR3_t_front(self)
def back(self):
r"""back(arrayR3_t self) -> std::array< double,3 >::value_type const &"""
return _libBornAgainBase.arrayR3_t_back(self)
def fill(self, u):
r"""fill(arrayR3_t self, std::array< double,3 >::value_type const & u)"""
return _libBornAgainBase.arrayR3_t_fill(self, u)
__swig_destroy__ = _libBornAgainBase.delete_arrayR3_t
# Register arrayR3_t in _libBornAgainBase:
_libBornAgainBase.arrayR3_t_swigregister(arrayR3_t)
class arrayC3_t(object):
r"""Proxy of C++ std::array< std::complex< double >,3 > 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(arrayC3_t self) -> SwigPyIterator"""
return _libBornAgainBase.arrayC3_t_iterator(self)
def __iter__(self):
return self.iterator()
def __nonzero__(self):
r"""__nonzero__(arrayC3_t self) -> bool"""
return _libBornAgainBase.arrayC3_t___nonzero__(self)
def __bool__(self):
r"""__bool__(arrayC3_t self) -> bool"""
return _libBornAgainBase.arrayC3_t___bool__(self)
def __len__(self):
r"""__len__(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"""
return _libBornAgainBase.arrayC3_t___len__(self)
def __getslice__(self, i, j):
r"""__getslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j) -> arrayC3_t"""
return _libBornAgainBase.arrayC3_t___getslice__(self, i, j)
def __setslice__(self, *args):
r"""
__setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)
__setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j, arrayC3_t v)
"""
return _libBornAgainBase.arrayC3_t___setslice__(self, *args)
def __delslice__(self, i, j):
r"""__delslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)"""
return _libBornAgainBase.arrayC3_t___delslice__(self, i, j)
def __delitem__(self, *args):
r"""
__delitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i)
__delitem__(arrayC3_t self, PySliceObject * slice)
"""
return _libBornAgainBase.arrayC3_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
__getitem__(arrayC3_t self, PySliceObject * slice) -> arrayC3_t
__getitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i) -> std::array< std::complex< double >,3 >::value_type const &
"""
return _libBornAgainBase.arrayC3_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
__setitem__(arrayC3_t self, PySliceObject * slice, arrayC3_t v)
__setitem__(arrayC3_t self, PySliceObject * slice)
__setitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::value_type const & x)
"""
return _libBornAgainBase.arrayC3_t___setitem__(self, *args)
def __init__(self, *args):
r"""
__init__(arrayC3_t self) -> arrayC3_t
__init__(arrayC3_t self, arrayC3_t other) -> arrayC3_t
"""
_libBornAgainBase.arrayC3_t_swiginit(self, _libBornAgainBase.new_arrayC3_t(*args))
def empty(self):
r"""empty(arrayC3_t self) -> bool"""
return _libBornAgainBase.arrayC3_t_empty(self)
def size(self):
r"""size(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"""
return _libBornAgainBase.arrayC3_t_size(self)
def swap(self, v):
r"""swap(arrayC3_t self, arrayC3_t v)"""
return _libBornAgainBase.arrayC3_t_swap(self, v)
def begin(self):
r"""begin(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"""
return _libBornAgainBase.arrayC3_t_begin(self)
def end(self):
r"""end(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"""
return _libBornAgainBase.arrayC3_t_end(self)
def rbegin(self):
r"""rbegin(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"""
return _libBornAgainBase.arrayC3_t_rbegin(self)
def rend(self):
r"""rend(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"""
return _libBornAgainBase.arrayC3_t_rend(self)
def front(self):
r"""front(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"""
return _libBornAgainBase.arrayC3_t_front(self)
def back(self):
r"""back(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"""
return _libBornAgainBase.arrayC3_t_back(self)
def fill(self, u):
r"""fill(arrayC3_t self, std::array< std::complex< double >,3 >::value_type const & u)"""
return _libBornAgainBase.arrayC3_t_fill(self, u)
__swig_destroy__ = _libBornAgainBase.delete_arrayC3_t
# Register arrayC3_t in _libBornAgainBase:
_libBornAgainBase.arrayC3_t_swigregister(arrayC3_t)
class vdouble1d_t(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(vdouble1d_t self) -> SwigPyIterator"""
return _libBornAgainBase.vdouble1d_t_iterator(self)
def __iter__(self):
return self.iterator()
def __nonzero__(self):
r"""__nonzero__(vdouble1d_t self) -> bool"""
return _libBornAgainBase.vdouble1d_t___nonzero__(self)
def __bool__(self):
r"""__bool__(vdouble1d_t self) -> bool"""
return _libBornAgainBase.vdouble1d_t___bool__(self)
def __len__(self):
r"""__len__(vdouble1d_t self) -> std::vector< double >::size_type"""
return _libBornAgainBase.vdouble1d_t___len__(self)
def __getslice__(self, i, j):
r"""__getslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> vdouble1d_t"""
return _libBornAgainBase.vdouble1d_t___getslice__(self, i, j)
def __setslice__(self, *args):
r"""
__setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
__setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, vdouble1d_t v)
"""
return _libBornAgainBase.vdouble1d_t___setslice__(self, *args)
def __delslice__(self, i, j):
r"""__delslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
return _libBornAgainBase.vdouble1d_t___delslice__(self, i, j)
def __delitem__(self, *args):
r"""
__delitem__(vdouble1d_t self, std::vector< double >::difference_type i)
__delitem__(vdouble1d_t self, PySliceObject * slice)
"""
return _libBornAgainBase.vdouble1d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
__getitem__(vdouble1d_t self, PySliceObject * slice) -> vdouble1d_t
__getitem__(vdouble1d_t self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
"""
return _libBornAgainBase.vdouble1d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
__setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)
__setitem__(vdouble1d_t self, PySliceObject * slice)
__setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
"""
return _libBornAgainBase.vdouble1d_t___setitem__(self, *args)
def pop(self):
r"""pop(vdouble1d_t self) -> std::vector< double >::value_type"""
return _libBornAgainBase.vdouble1d_t_pop(self)
def append(self, x):
r"""append(vdouble1d_t self, std::vector< double >::value_type const & x)"""
return _libBornAgainBase.vdouble1d_t_append(self, x)
def empty(self):
r"""empty(vdouble1d_t self) -> bool"""
return _libBornAgainBase.vdouble1d_t_empty(self)
def size(self):
r"""size(vdouble1d_t self) -> std::vector< double >::size_type"""
return _libBornAgainBase.vdouble1d_t_size(self)
def swap(self, v):
r"""swap(vdouble1d_t self, vdouble1d_t v)"""
return _libBornAgainBase.vdouble1d_t_swap(self, v)
def begin(self):
r"""begin(vdouble1d_t self) -> std::vector< double >::iterator"""
return _libBornAgainBase.vdouble1d_t_begin(self)
def end(self):
r"""end(vdouble1d_t self) -> std::vector< double >::iterator"""
return _libBornAgainBase.vdouble1d_t_end(self)
def rbegin(self):
r"""rbegin(vdouble1d_t self) -> std::vector< double >::reverse_iterator"""
return _libBornAgainBase.vdouble1d_t_rbegin(self)
def rend(self):
r"""rend(vdouble1d_t self) -> std::vector< double >::reverse_iterator"""
return _libBornAgainBase.vdouble1d_t_rend(self)
def clear(self):
r"""clear(vdouble1d_t self)"""
return _libBornAgainBase.vdouble1d_t_clear(self)
def get_allocator(self):
r"""get_allocator(vdouble1d_t self) -> std::vector< double >::allocator_type"""
return _libBornAgainBase.vdouble1d_t_get_allocator(self)
def pop_back(self):
r"""pop_back(vdouble1d_t self)"""
return _libBornAgainBase.vdouble1d_t_pop_back(self)
def erase(self, *args):
r"""
erase(vdouble1d_t self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
erase(vdouble1d_t self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
"""
return _libBornAgainBase.vdouble1d_t_erase(self, *args)
def __init__(self, *args):
r"""
__init__(vdouble1d_t self) -> vdouble1d_t
__init__(vdouble1d_t self, vdouble1d_t other) -> vdouble1d_t
__init__(vdouble1d_t self, std::vector< double >::size_type size) -> vdouble1d_t
__init__(vdouble1d_t self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> vdouble1d_t
"""
_libBornAgainBase.vdouble1d_t_swiginit(self, _libBornAgainBase.new_vdouble1d_t(*args))
def push_back(self, x):
r"""push_back(vdouble1d_t self, std::vector< double >::value_type const & x)"""
return _libBornAgainBase.vdouble1d_t_push_back(self, x)
def front(self):
r"""front(vdouble1d_t self) -> std::vector< double >::value_type const &"""
return _libBornAgainBase.vdouble1d_t_front(self)
def back(self):
r"""back(vdouble1d_t self) -> std::vector< double >::value_type const &"""
return _libBornAgainBase.vdouble1d_t_back(self)
def assign(self, n, x):
r"""assign(vdouble1d_t self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
return _libBornAgainBase.vdouble1d_t_assign(self, n, x)
def resize(self, *args):
r"""
resize(vdouble1d_t self, std::vector< double >::size_type new_size)
resize(vdouble1d_t self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
"""
return _libBornAgainBase.vdouble1d_t_resize(self, *args)
def insert(self, *args):
r"""
insert(vdouble1d_t self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
insert(vdouble1d_t self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
"""
return _libBornAgainBase.vdouble1d_t_insert(self, *args)
def reserve(self, n):
r"""reserve(vdouble1d_t self, std::vector< double >::size_type n)"""
return _libBornAgainBase.vdouble1d_t_reserve(self, n)
def capacity(self):
r"""capacity(vdouble1d_t self) -> std::vector< double >::size_type"""
return _libBornAgainBase.vdouble1d_t_capacity(self)
__swig_destroy__ = _libBornAgainBase.delete_vdouble1d_t
# Register vdouble1d_t in _libBornAgainBase:
_libBornAgainBase.vdouble1d_t_swigregister(vdouble1d_t)
class vdouble2d_t(object):
r"""Proxy of C++ std::vector< 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(vdouble2d_t self) -> SwigPyIterator"""
return _libBornAgainBase.vdouble2d_t_iterator(self)
def __iter__(self):
return self.iterator()
def __nonzero__(self):
r"""__nonzero__(vdouble2d_t self) -> bool"""
return _libBornAgainBase.vdouble2d_t___nonzero__(self)
def __bool__(self):
r"""__bool__(vdouble2d_t self) -> bool"""
return _libBornAgainBase.vdouble2d_t___bool__(self)
def __len__(self):
r"""__len__(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"""
return _libBornAgainBase.vdouble2d_t___len__(self)
def __getslice__(self, i, j):
r"""__getslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j) -> vdouble2d_t"""
return _libBornAgainBase.vdouble2d_t___getslice__(self, i, j)
def __setslice__(self, *args):
r"""
__setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)
__setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, vdouble2d_t v)
"""
return _libBornAgainBase.vdouble2d_t___setslice__(self, *args)
def __delslice__(self, i, j):
r"""__delslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"""
return _libBornAgainBase.vdouble2d_t___delslice__(self, i, j)
def __delitem__(self, *args):
r"""
__delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)
__delitem__(vdouble2d_t self, PySliceObject * slice)
"""
return _libBornAgainBase.vdouble2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
__getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t
__getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t
"""
return _libBornAgainBase.vdouble2d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
__setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)
__setitem__(vdouble2d_t self, PySliceObject * slice)
__setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)
"""
return _libBornAgainBase.vdouble2d_t___setitem__(self, *args)
def pop(self):
r"""pop(vdouble2d_t self) -> vdouble1d_t"""
return _libBornAgainBase.vdouble2d_t_pop(self)
def append(self, x):
r"""append(vdouble2d_t self, vdouble1d_t x)"""
return _libBornAgainBase.vdouble2d_t_append(self, x)
def empty(self):
r"""empty(vdouble2d_t self) -> bool"""
return _libBornAgainBase.vdouble2d_t_empty(self)
def size(self):
r"""size(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"""
return _libBornAgainBase.vdouble2d_t_size(self)
def swap(self, v):
r"""swap(vdouble2d_t self, vdouble2d_t v)"""
return _libBornAgainBase.vdouble2d_t_swap(self, v)
def begin(self):
r"""begin(vdouble2d_t self) -> std::vector< std::vector< double > >::iterator"""
return _libBornAgainBase.vdouble2d_t_begin(self)
def end(self):
r"""end(vdouble2d_t self) -> std::vector< std::vector< double > >::iterator"""
return _libBornAgainBase.vdouble2d_t_end(self)
def rbegin(self):
r"""rbegin(vdouble2d_t self) -> std::vector< std::vector< double > >::reverse_iterator"""
return _libBornAgainBase.vdouble2d_t_rbegin(self)
def rend(self):
r"""rend(vdouble2d_t self) -> std::vector< std::vector< double > >::reverse_iterator"""
return _libBornAgainBase.vdouble2d_t_rend(self)
def clear(self):
r"""clear(vdouble2d_t self)"""
return _libBornAgainBase.vdouble2d_t_clear(self)
def get_allocator(self):
r"""get_allocator(vdouble2d_t self) -> std::vector< std::vector< double > >::allocator_type"""
return _libBornAgainBase.vdouble2d_t_get_allocator(self)
def pop_back(self):
r"""pop_back(vdouble2d_t self)"""
return _libBornAgainBase.vdouble2d_t_pop_back(self)
def erase(self, *args):
r"""
erase(vdouble2d_t self, std::vector< std::vector< double > >::iterator pos) -> std::vector< std::vector< double > >::iterator
erase(vdouble2d_t self, std::vector< std::vector< double > >::iterator first, std::vector< std::vector< double > >::iterator last) -> std::vector< std::vector< double > >::iterator
"""
return _libBornAgainBase.vdouble2d_t_erase(self, *args)
def __init__(self, *args):
r"""
__init__(vdouble2d_t self) -> vdouble2d_t
__init__(vdouble2d_t self, vdouble2d_t other) -> vdouble2d_t
__init__(vdouble2d_t self, std::vector< std::vector< double > >::size_type size) -> vdouble2d_t
__init__(vdouble2d_t self, std::vector< std::vector< double > >::size_type size, vdouble1d_t value) -> vdouble2d_t
"""
_libBornAgainBase.vdouble2d_t_swiginit(self, _libBornAgainBase.new_vdouble2d_t(*args))
def push_back(self, x):
r"""push_back(vdouble2d_t self, vdouble1d_t x)"""
return _libBornAgainBase.vdouble2d_t_push_back(self, x)
def front(self):
r"""front(vdouble2d_t self) -> vdouble1d_t"""
return _libBornAgainBase.vdouble2d_t_front(self)
def back(self):
r"""back(vdouble2d_t self) -> vdouble1d_t"""
return _libBornAgainBase.vdouble2d_t_back(self)
def assign(self, n, x):
r"""assign(vdouble2d_t self, std::vector< std::vector< double > >::size_type n, vdouble1d_t x)"""
return _libBornAgainBase.vdouble2d_t_assign(self, n, x)
def resize(self, *args):
r"""
resize(vdouble2d_t self, std::vector< std::vector< double > >::size_type new_size)
resize(vdouble2d_t self, std::vector< std::vector< double > >::size_type new_size, vdouble1d_t x)
"""
return _libBornAgainBase.vdouble2d_t_resize(self, *args)
def insert(self, *args):
r"""
insert(vdouble2d_t self, std::vector< std::vector< double > >::iterator pos, vdouble1d_t x) -> std::vector< std::vector< double > >::iterator
insert(vdouble2d_t self, std::vector< std::vector< double > >::iterator pos, std::vector< std::vector< double > >::size_type n, vdouble1d_t x)
"""
return _libBornAgainBase.vdouble2d_t_insert(self, *args)
def reserve(self, n):
r"""reserve(vdouble2d_t self, std::vector< std::vector< double > >::size_type n)"""
return _libBornAgainBase.vdouble2d_t_reserve(self, n)
def capacity(self):
r"""capacity(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"""
return _libBornAgainBase.vdouble2d_t_capacity(self)
__swig_destroy__ = _libBornAgainBase.delete_vdouble2d_t
# Register vdouble2d_t in _libBornAgainBase:
_libBornAgainBase.vdouble2d_t_swigregister(vdouble2d_t)
class vector_integer_t(object):
r"""Proxy of C++ std::vector< int > 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(vector_integer_t self) -> SwigPyIterator"""
return _libBornAgainBase.vector_integer_t_iterator(self)
def __iter__(self):
return self.iterator()
def __nonzero__(self):
r"""__nonzero__(vector_integer_t self) -> bool"""
return _libBornAgainBase.vector_integer_t___nonzero__(self)
def __bool__(self):
r"""__bool__(vector_integer_t self) -> bool"""
return _libBornAgainBase.vector_integer_t___bool__(self)
def __len__(self):
r"""__len__(vector_integer_t self) -> std::vector< int >::size_type"""
return _libBornAgainBase.vector_integer_t___len__(self)
def __getslice__(self, i, j):
r"""__getslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> vector_integer_t"""
return _libBornAgainBase.vector_integer_t___getslice__(self, i, j)
def __setslice__(self, *args):
r"""
__setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
__setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, vector_integer_t v)
"""
return _libBornAgainBase.vector_integer_t___setslice__(self, *args)
def __delslice__(self, i, j):
r"""__delslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
return _libBornAgainBase.vector_integer_t___delslice__(self, i, j)
def __delitem__(self, *args):
r"""
__delitem__(vector_integer_t self, std::vector< int >::difference_type i)
__delitem__(vector_integer_t self, PySliceObject * slice)
"""
return _libBornAgainBase.vector_integer_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
__getitem__(vector_integer_t self, PySliceObject * slice) -> vector_integer_t
__getitem__(vector_integer_t self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
"""
return _libBornAgainBase.vector_integer_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
__setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)
__setitem__(vector_integer_t self, PySliceObject * slice)
__setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
"""
return _libBornAgainBase.vector_integer_t___setitem__(self, *args)
def pop(self):
r"""pop(vector_integer_t self) -> std::vector< int >::value_type"""
return _libBornAgainBase.vector_integer_t_pop(self)
def append(self, x):
r"""append(vector_integer_t self, std::vector< int >::value_type const & x)"""
return _libBornAgainBase.vector_integer_t_append(self, x)
def empty(self):
r"""empty(vector_integer_t self) -> bool"""
return _libBornAgainBase.vector_integer_t_empty(self)
def size(self):
r"""size(vector_integer_t self) -> std::vector< int >::size_type"""
return _libBornAgainBase.vector_integer_t_size(self)
def swap(self, v):
r"""swap(vector_integer_t self, vector_integer_t v)"""
return _libBornAgainBase.vector_integer_t_swap(self, v)
def begin(self):
r"""begin(vector_integer_t self) -> std::vector< int >::iterator"""
return _libBornAgainBase.vector_integer_t_begin(self)
def end(self):
r"""end(vector_integer_t self) -> std::vector< int >::iterator"""
return _libBornAgainBase.vector_integer_t_end(self)
def rbegin(self):
r"""rbegin(vector_integer_t self) -> std::vector< int >::reverse_iterator"""
return _libBornAgainBase.vector_integer_t_rbegin(self)
def rend(self):
r"""rend(vector_integer_t self) -> std::vector< int >::reverse_iterator"""
return _libBornAgainBase.vector_integer_t_rend(self)
def clear(self):
r"""clear(vector_integer_t self)"""
return _libBornAgainBase.vector_integer_t_clear(self)
def get_allocator(self):
r"""get_allocator(vector_integer_t self) -> std::vector< int >::allocator_type"""
return _libBornAgainBase.vector_integer_t_get_allocator(self)
def pop_back(self):
r"""pop_back(vector_integer_t self)"""
return _libBornAgainBase.vector_integer_t_pop_back(self)
def erase(self, *args):
r"""
erase(vector_integer_t self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
erase(vector_integer_t self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
"""
return _libBornAgainBase.vector_integer_t_erase(self, *args)
def __init__(self, *args):
r"""
__init__(vector_integer_t self) -> vector_integer_t
__init__(vector_integer_t self, vector_integer_t other) -> vector_integer_t
__init__(vector_integer_t self, std::vector< int >::size_type size) -> vector_integer_t
__init__(vector_integer_t self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> vector_integer_t
"""
_libBornAgainBase.vector_integer_t_swiginit(self, _libBornAgainBase.new_vector_integer_t(*args))
def push_back(self, x):
r"""push_back(vector_integer_t self, std::vector< int >::value_type const & x)"""
return _libBornAgainBase.vector_integer_t_push_back(self, x)
def front(self):
r"""front(vector_integer_t self) -> std::vector< int >::value_type const &"""
return _libBornAgainBase.vector_integer_t_front(self)
def back(self):
r"""back(vector_integer_t self) -> std::vector< int >::value_type const &"""
return _libBornAgainBase.vector_integer_t_back(self)
def assign(self, n, x):
r"""assign(vector_integer_t self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
return _libBornAgainBase.vector_integer_t_assign(self, n, x)
def resize(self, *args):
r"""
resize(vector_integer_t self, std::vector< int >::size_type new_size)
resize(vector_integer_t self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
"""
return _libBornAgainBase.vector_integer_t_resize(self, *args)
def insert(self, *args):
r"""
insert(vector_integer_t self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator
insert(vector_integer_t self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
"""
return _libBornAgainBase.vector_integer_t_insert(self, *args)
def reserve(self, n):
r"""reserve(vector_integer_t self, std::vector< int >::size_type n)"""
return _libBornAgainBase.vector_integer_t_reserve(self, n)
def capacity(self):
r"""capacity(vector_integer_t self) -> std::vector< int >::size_type"""
return _libBornAgainBase.vector_integer_t_capacity(self)
__swig_destroy__ = _libBornAgainBase.delete_vector_integer_t
# Register vector_integer_t in _libBornAgainBase:
_libBornAgainBase.vector_integer_t_swigregister(vector_integer_t)
class vinteger2d_t(object):
r"""Proxy of C++ std::vector< std::vector< int > > 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(vinteger2d_t self) -> SwigPyIterator"""
return _libBornAgainBase.vinteger2d_t_iterator(self)
def __iter__(self):
return self.iterator()
def __nonzero__(self):
r"""__nonzero__(vinteger2d_t self) -> bool"""
return _libBornAgainBase.vinteger2d_t___nonzero__(self)
def __bool__(self):
r"""__bool__(vinteger2d_t self) -> bool"""
return _libBornAgainBase.vinteger2d_t___bool__(self)
def __len__(self):
r"""__len__(vinteger2d_t self) -> std::vector< std::vector< int > >::size_type"""
return _libBornAgainBase.vinteger2d_t___len__(self)
def __getslice__(self, i, j):
r"""__getslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j) -> vinteger2d_t"""
return _libBornAgainBase.vinteger2d_t___getslice__(self, i, j)
def __setslice__(self, *args):
r"""
__setslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)
__setslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j, vinteger2d_t v)
"""
return _libBornAgainBase.vinteger2d_t___setslice__(self, *args)
def __delslice__(self, i, j):
r"""__delslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)"""
return _libBornAgainBase.vinteger2d_t___delslice__(self, i, j)
def __delitem__(self, *args):
r"""
__delitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i)
__delitem__(vinteger2d_t self, PySliceObject * slice)
"""
return _libBornAgainBase.vinteger2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
__getitem__(vinteger2d_t self, PySliceObject * slice) -> vinteger2d_t
__getitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_t
"""
return _libBornAgainBase.vinteger2d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
__setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)
__setitem__(vinteger2d_t self, PySliceObject * slice)
__setitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, vector_integer_t x)
"""
return _libBornAgainBase.vinteger2d_t___setitem__(self, *args)
def pop(self):
r"""pop(vinteger2d_t self) -> vector_integer_t"""
return _libBornAgainBase.vinteger2d_t_pop(self)
def append(self, x):
r"""append(vinteger2d_t self, vector_integer_t x)"""
return _libBornAgainBase.vinteger2d_t_append(self, x)
def empty(self):
r"""empty(vinteger2d_t self) -> bool"""
return _libBornAgainBase.vinteger2d_t_empty(self)
def size(self):
r"""size(vinteger2d_t self) -> std::vector< std::vector< int > >::size_type"""
return _libBornAgainBase.vinteger2d_t_size(self)
def swap(self, v):
r"""swap(vinteger2d_t self, vinteger2d_t v)"""
return _libBornAgainBase.vinteger2d_t_swap(self, v)
def begin(self):
r"""begin(vinteger2d_t self) -> std::vector< std::vector< int > >::iterator"""
return _libBornAgainBase.vinteger2d_t_begin(self)
def end(self):
r"""end(vinteger2d_t self) -> std::vector< std::vector< int > >::iterator"""
return _libBornAgainBase.vinteger2d_t_end(self)
def rbegin(self):
r"""rbegin(vinteger2d_t self) -> std::vector< std::vector< int > >::reverse_iterator"""
return _libBornAgainBase.vinteger2d_t_rbegin(self)
def rend(self):
r"""rend(vinteger2d_t self) -> std::vector< std::vector< int > >::reverse_iterator"""
return _libBornAgainBase.vinteger2d_t_rend(self)
def clear(self):
r"""clear(vinteger2d_t self)"""
return _libBornAgainBase.vinteger2d_t_clear(self)
def get_allocator(self):
r"""get_allocator(vinteger2d_t self) -> std::vector< std::vector< int > >::allocator_type"""
return _libBornAgainBase.vinteger2d_t_get_allocator(self)
def pop_back(self):
r"""pop_back(vinteger2d_t self)"""
return _libBornAgainBase.vinteger2d_t_pop_back(self)
def erase(self, *args):
r"""
erase(vinteger2d_t self, std::vector< std::vector< int > >::iterator pos) -> std::vector< std::vector< int > >::iterator
erase(vinteger2d_t self, std::vector< std::vector< int > >::iterator first, std::vector< std::vector< int > >::iterator last) -> std::vector< std::vector< int > >::iterator
"""
return _libBornAgainBase.vinteger2d_t_erase(self, *args)
def __init__(self, *args):
r"""
__init__(vinteger2d_t self) -> vinteger2d_t
__init__(vinteger2d_t self, vinteger2d_t other) -> vinteger2d_t
__init__(vinteger2d_t self, std::vector< std::vector< int > >::size_type size) -> vinteger2d_t
__init__(vinteger2d_t self, std::vector< std::vector< int > >::size_type size, vector_integer_t value) -> vinteger2d_t
"""
_libBornAgainBase.vinteger2d_t_swiginit(self, _libBornAgainBase.new_vinteger2d_t(*args))
def push_back(self, x):
r"""push_back(vinteger2d_t self, vector_integer_t x)"""
return _libBornAgainBase.vinteger2d_t_push_back(self, x)
def front(self):
r"""front(vinteger2d_t self) -> vector_integer_t"""
return _libBornAgainBase.vinteger2d_t_front(self)
def back(self):
r"""back(vinteger2d_t self) -> vector_integer_t"""
return _libBornAgainBase.vinteger2d_t_back(self)
def assign(self, n, x):
r"""assign(vinteger2d_t self, std::vector< std::vector< int > >::size_type n, vector_integer_t x)"""
return _libBornAgainBase.vinteger2d_t_assign(self, n, x)
def resize(self, *args):
r"""
resize(vinteger2d_t self, std::vector< std::vector< int > >::size_type new_size)
resize(vinteger2d_t self, std::vector< std::vector< int > >::size_type new_size, vector_integer_t x)
"""
return _libBornAgainBase.vinteger2d_t_resize(self, *args)
def insert(self, *args):
r"""
insert(vinteger2d_t self, std::vector< std::vector< int > >::iterator pos, vector_integer_t x) -> std::vector< std::vector< int > >::iterator
insert(vinteger2d_t self, std::vector< std::vector< int > >::iterator pos, std::vector< std::vector< int > >::size_type n, vector_integer_t x)
"""
return _libBornAgainBase.vinteger2d_t_insert(self, *args)
def reserve(self, n):
r"""reserve(vinteger2d_t self, std::vector< std::vector< int > >::size_type n)"""
return _libBornAgainBase.vinteger2d_t_reserve(self, n)
def capacity(self):
r"""capacity(vinteger2d_t self) -> std::vector< std::vector< int > >::size_type"""
return _libBornAgainBase.vinteger2d_t_capacity(self)
__swig_destroy__ = _libBornAgainBase.delete_vinteger2d_t
# Register vinteger2d_t in _libBornAgainBase:
_libBornAgainBase.vinteger2d_t_swigregister(vinteger2d_t)
class vector_longinteger_t(object):
r"""Proxy of C++ std::vector< unsigned long > 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(vector_longinteger_t self) -> SwigPyIterator"""
return _libBornAgainBase.vector_longinteger_t_iterator(self)
def __iter__(self):
return self.iterator()
def __nonzero__(self):
r"""__nonzero__(vector_longinteger_t self) -> bool"""
return _libBornAgainBase.vector_longinteger_t___nonzero__(self)
def __bool__(self):
r"""__bool__(vector_longinteger_t self) -> bool"""
return _libBornAgainBase.vector_longinteger_t___bool__(self)
def __len__(self):
r"""__len__(vector_longinteger_t self) -> std::vector< unsigned long >::size_type"""
return _libBornAgainBase.vector_longinteger_t___len__(self)
def __getslice__(self, i, j):
r"""__getslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j) -> vector_longinteger_t"""
return _libBornAgainBase.vector_longinteger_t___getslice__(self, i, j)
def __setslice__(self, *args):
r"""
__setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)
__setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j, vector_longinteger_t v)
"""
return _libBornAgainBase.vector_longinteger_t___setslice__(self, *args)
def __delslice__(self, i, j):
r"""__delslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)"""
return _libBornAgainBase.vector_longinteger_t___delslice__(self, i, j)
def __delitem__(self, *args):
r"""
__delitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i)
__delitem__(vector_longinteger_t self, PySliceObject * slice)
"""
return _libBornAgainBase.vector_longinteger_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
__getitem__(vector_longinteger_t self, PySliceObject * slice) -> vector_longinteger_t
__getitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &
"""
return _libBornAgainBase.vector_longinteger_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
__setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)
__setitem__(vector_longinteger_t self, PySliceObject * slice)
__setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)
"""
return _libBornAgainBase.vector_longinteger_t___setitem__(self, *args)
def pop(self):
r"""pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"""
return _libBornAgainBase.vector_longinteger_t_pop(self)
def append(self, x):
r"""append(vector_longinteger_t self, std::vector< unsigned long >::value_type const & x)"""
return _libBornAgainBase.vector_longinteger_t_append(self, x)
def empty(self):
r"""empty(vector_longinteger_t self) -> bool"""
return _libBornAgainBase.vector_longinteger_t_empty(self)
def size(self):
r"""size(vector_longinteger_t self) -> std::vector< unsigned long >::size_type"""
return _libBornAgainBase.vector_longinteger_t_size(self)
def swap(self, v):
r"""swap(vector_longinteger_t self, vector_longinteger_t v)"""
return _libBornAgainBase.vector_longinteger_t_swap(self, v)
def begin(self):
r"""begin(vector_longinteger_t self) -> std::vector< unsigned long >::iterator"""
return _libBornAgainBase.vector_longinteger_t_begin(self)
def end(self):
r"""end(vector_longinteger_t self) -> std::vector< unsigned long >::iterator"""
return _libBornAgainBase.vector_longinteger_t_end(self)
def rbegin(self):
r"""rbegin(vector_longinteger_t self) -> std::vector< unsigned long >::reverse_iterator"""
return _libBornAgainBase.vector_longinteger_t_rbegin(self)
def rend(self):
r"""rend(vector_longinteger_t self) -> std::vector< unsigned long >::reverse_iterator"""
return _libBornAgainBase.vector_longinteger_t_rend(self)
def clear(self):
r"""clear(vector_longinteger_t self)"""
return _libBornAgainBase.vector_longinteger_t_clear(self)
def get_allocator(self):
r"""get_allocator(vector_longinteger_t self) -> std::vector< unsigned long >::allocator_type"""
return _libBornAgainBase.vector_longinteger_t_get_allocator(self)
def pop_back(self):
r"""pop_back(vector_longinteger_t self)"""
return _libBornAgainBase.vector_longinteger_t_pop_back(self)
def erase(self, *args):
r"""
erase(vector_longinteger_t self, std::vector< unsigned long >::iterator pos) -> std::vector< unsigned long >::iterator
erase(vector_longinteger_t self, std::vector< unsigned long >::iterator first, std::vector< unsigned long >::iterator last) -> std::vector< unsigned long >::iterator
"""
return _libBornAgainBase.vector_longinteger_t_erase(self, *args)
def __init__(self, *args):
r"""
__init__(vector_longinteger_t self) -> vector_longinteger_t
__init__(vector_longinteger_t self, vector_longinteger_t other) -> vector_longinteger_t
__init__(vector_longinteger_t self, std::vector< unsigned long >::size_type size) -> vector_longinteger_t
__init__(vector_longinteger_t self, std::vector< unsigned long >::size_type size, std::vector< unsigned long >::value_type const & value) -> vector_longinteger_t
"""
_libBornAgainBase.vector_longinteger_t_swiginit(self, _libBornAgainBase.new_vector_longinteger_t(*args))
def push_back(self, x):
r"""push_back(vector_longinteger_t self, std::vector< unsigned long >::value_type const & x)"""
return _libBornAgainBase.vector_longinteger_t_push_back(self, x)
def front(self):
r"""front(vector_longinteger_t self) -> std::vector< unsigned long >::value_type const &"""
return _libBornAgainBase.vector_longinteger_t_front(self)
def back(self):
r"""back(vector_longinteger_t self) -> std::vector< unsigned long >::value_type const &"""
return _libBornAgainBase.vector_longinteger_t_back(self)
def assign(self, n, x):
r"""assign(vector_longinteger_t self, std::vector< unsigned long >::size_type n, std::vector< unsigned long >::value_type const & x)"""
return _libBornAgainBase.vector_longinteger_t_assign(self, n, x)
def resize(self, *args):
r"""
resize(vector_longinteger_t self, std::vector< unsigned long >::size_type new_size)
resize(vector_longinteger_t self, std::vector< unsigned long >::size_type new_size, std::vector< unsigned long >::value_type const & x)
"""
return _libBornAgainBase.vector_longinteger_t_resize(self, *args)
def insert(self, *args):
r"""
insert(vector_longinteger_t self, std::vector< unsigned long >::iterator pos, std::vector< unsigned long >::value_type const & x) -> std::vector< unsigned long >::iterator
insert(vector_longinteger_t self, std::vector< unsigned long >::iterator pos, std::vector< unsigned long >::size_type n, std::vector< unsigned long >::value_type const & x)
"""
return _libBornAgainBase.vector_longinteger_t_insert(self, *args)
def reserve(self, n):
r"""reserve(vector_longinteger_t self, std::vector< unsigned long >::size_type n)"""
return _libBornAgainBase.vector_longinteger_t_reserve(self, n)
def capacity(self):
r"""capacity(vector_longinteger_t self) -> std::vector< unsigned long >::size_type"""
return _libBornAgainBase.vector_longinteger_t_capacity(self)
__swig_destroy__ = _libBornAgainBase.delete_vector_longinteger_t
# Register vector_longinteger_t in _libBornAgainBase:
_libBornAgainBase.vector_longinteger_t_swigregister(vector_longinteger_t)
class vector_complex_t(object):
r"""Proxy of C++ std::vector< std::complex< 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(vector_complex_t self) -> SwigPyIterator"""
return _libBornAgainBase.vector_complex_t_iterator(self)
def __iter__(self):
return self.iterator()
def __nonzero__(self):
r"""__nonzero__(vector_complex_t self) -> bool"""
return _libBornAgainBase.vector_complex_t___nonzero__(self)
def __bool__(self):
r"""__bool__(vector_complex_t self) -> bool"""
return _libBornAgainBase.vector_complex_t___bool__(self)
def __len__(self):
r"""__len__(vector_complex_t self) -> std::vector< std::complex< double > >::size_type"""
return _libBornAgainBase.vector_complex_t___len__(self)
def __getslice__(self, i, j):
r"""__getslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j) -> vector_complex_t"""
return _libBornAgainBase.vector_complex_t___getslice__(self, i, j)
def __setslice__(self, *args):
r"""
__setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)
__setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j, vector_complex_t v)
"""
return _libBornAgainBase.vector_complex_t___setslice__(self, *args)
def __delslice__(self, i, j):
r"""__delslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)"""
return _libBornAgainBase.vector_complex_t___delslice__(self, i, j)
def __delitem__(self, *args):
r"""
__delitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i)
__delitem__(vector_complex_t self, PySliceObject * slice)
"""
return _libBornAgainBase.vector_complex_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
__getitem__(vector_complex_t self, PySliceObject * slice) -> vector_complex_t
__getitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &
"""
return _libBornAgainBase.vector_complex_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
__setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)
__setitem__(vector_complex_t self, PySliceObject * slice)
__setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)
"""
return _libBornAgainBase.vector_complex_t___setitem__(self, *args)
def pop(self):
r"""pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"""
return _libBornAgainBase.vector_complex_t_pop(self)
def append(self, x):
r"""append(vector_complex_t self, std::vector< std::complex< double > >::value_type const & x)"""
return _libBornAgainBase.vector_complex_t_append(self, x)
def empty(self):
r"""empty(vector_complex_t self) -> bool"""
return _libBornAgainBase.vector_complex_t_empty(self)
def size(self):
r"""size(vector_complex_t self) -> std::vector< std::complex< double > >::size_type"""
return _libBornAgainBase.vector_complex_t_size(self)
def swap(self, v):
r"""swap(vector_complex_t self, vector_complex_t v)"""
return _libBornAgainBase.vector_complex_t_swap(self, v)
def begin(self):
r"""begin(vector_complex_t self) -> std::vector< std::complex< double > >::iterator"""
return _libBornAgainBase.vector_complex_t_begin(self)
def end(self):
r"""end(vector_complex_t self) -> std::vector< std::complex< double > >::iterator"""
return _libBornAgainBase.vector_complex_t_end(self)
def rbegin(self):
r"""rbegin(vector_complex_t self) -> std::vector< std::complex< double > >::reverse_iterator"""
return _libBornAgainBase.vector_complex_t_rbegin(self)
def rend(self):
r"""rend(vector_complex_t self) -> std::vector< std::complex< double > >::reverse_iterator"""
return _libBornAgainBase.vector_complex_t_rend(self)
def clear(self):
r"""clear(vector_complex_t self)"""
return _libBornAgainBase.vector_complex_t_clear(self)
def get_allocator(self):
r"""get_allocator(vector_complex_t self) -> std::vector< std::complex< double > >::allocator_type"""
return _libBornAgainBase.vector_complex_t_get_allocator(self)
def pop_back(self):
r"""pop_back(vector_complex_t self)"""
return _libBornAgainBase.vector_complex_t_pop_back(self)
def erase(self, *args):
r"""
erase(vector_complex_t self, std::vector< std::complex< double > >::iterator pos) -> std::vector< std::complex< double > >::iterator
erase(vector_complex_t self, std::vector< std::complex< double > >::iterator first, std::vector< std::complex< double > >::iterator last) -> std::vector< std::complex< double > >::iterator
"""
return _libBornAgainBase.vector_complex_t_erase(self, *args)
def __init__(self, *args):
r"""
__init__(vector_complex_t self) -> vector_complex_t
__init__(vector_complex_t self, vector_complex_t other) -> vector_complex_t
__init__(vector_complex_t self, std::vector< std::complex< double > >::size_type size) -> vector_complex_t
__init__(vector_complex_t self, std::vector< std::complex< double > >::size_type size, std::vector< std::complex< double > >::value_type const & value) -> vector_complex_t
"""
_libBornAgainBase.vector_complex_t_swiginit(self, _libBornAgainBase.new_vector_complex_t(*args))
def push_back(self, x):
r"""push_back(vector_complex_t self, std::vector< std::complex< double > >::value_type const & x)"""
return _libBornAgainBase.vector_complex_t_push_back(self, x)
def front(self):
r"""front(vector_complex_t self) -> std::vector< std::complex< double > >::value_type const &"""
return _libBornAgainBase.vector_complex_t_front(self)
def back(self):
r"""back(vector_complex_t self) -> std::vector< std::complex< double > >::value_type const &"""
return _libBornAgainBase.vector_complex_t_back(self)
def assign(self, n, x):
r"""assign(vector_complex_t self, std::vector< std::complex< double > >::size_type n, std::vector< std::complex< double > >::value_type const & x)"""
return _libBornAgainBase.vector_complex_t_assign(self, n, x)
def resize(self, *args):
r"""
resize(vector_complex_t self, std::vector< std::complex< double > >::size_type new_size)
resize(vector_complex_t self, std::vector< std::complex< double > >::size_type new_size, std::vector< std::complex< double > >::value_type const & x)
"""
return _libBornAgainBase.vector_complex_t_resize(self, *args)
def insert(self, *args):
r"""
insert(vector_complex_t self, std::vector< std::complex< double > >::iterator pos, std::vector< std::complex< double > >::value_type const & x) -> std::vector< std::complex< double > >::iterator
insert(vector_complex_t 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 _libBornAgainBase.vector_complex_t_insert(self, *args)
def reserve(self, n):
r"""reserve(vector_complex_t self, std::vector< std::complex< double > >::size_type n)"""
return _libBornAgainBase.vector_complex_t_reserve(self, n)
def capacity(self):
r"""capacity(vector_complex_t self) -> std::vector< std::complex< double > >::size_type"""
return _libBornAgainBase.vector_complex_t_capacity(self)
__swig_destroy__ = _libBornAgainBase.delete_vector_complex_t
# Register vector_complex_t in _libBornAgainBase:
_libBornAgainBase.vector_complex_t_swigregister(vector_complex_t)
class vector_string_t(object):
r"""Proxy of C++ std::vector< std::string > 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(vector_string_t self) -> SwigPyIterator"""
return _libBornAgainBase.vector_string_t_iterator(self)
def __iter__(self):
return self.iterator()
def __nonzero__(self):
r"""__nonzero__(vector_string_t self) -> bool"""
return _libBornAgainBase.vector_string_t___nonzero__(self)
def __bool__(self):
r"""__bool__(vector_string_t self) -> bool"""
return _libBornAgainBase.vector_string_t___bool__(self)
def __len__(self):
r"""__len__(vector_string_t self) -> std::vector< std::string >::size_type"""
return _libBornAgainBase.vector_string_t___len__(self)
def __getslice__(self, i, j):
r"""__getslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> vector_string_t"""
return _libBornAgainBase.vector_string_t___getslice__(self, i, j)
def __setslice__(self, *args):
r"""
__setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
__setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, vector_string_t v)
"""
return _libBornAgainBase.vector_string_t___setslice__(self, *args)
def __delslice__(self, i, j):
r"""__delslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
return _libBornAgainBase.vector_string_t___delslice__(self, i, j)
def __delitem__(self, *args):
r"""
__delitem__(vector_string_t self, std::vector< std::string >::difference_type i)
__delitem__(vector_string_t self, PySliceObject * slice)
"""
return _libBornAgainBase.vector_string_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
__getitem__(vector_string_t self, PySliceObject * slice) -> vector_string_t
__getitem__(vector_string_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
"""
return _libBornAgainBase.vector_string_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
__setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)
__setitem__(vector_string_t self, PySliceObject * slice)
__setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
"""
return _libBornAgainBase.vector_string_t___setitem__(self, *args)
def pop(self):
r"""pop(vector_string_t self) -> std::vector< std::string >::value_type"""
return _libBornAgainBase.vector_string_t_pop(self)
def append(self, x):
r"""append(vector_string_t self, std::vector< std::string >::value_type const & x)"""
return _libBornAgainBase.vector_string_t_append(self, x)
def empty(self):
r"""empty(vector_string_t self) -> bool"""
return _libBornAgainBase.vector_string_t_empty(self)
def size(self):
r"""size(vector_string_t self) -> std::vector< std::string >::size_type"""
return _libBornAgainBase.vector_string_t_size(self)
def swap(self, v):
r"""swap(vector_string_t self, vector_string_t v)"""
return _libBornAgainBase.vector_string_t_swap(self, v)
def begin(self):
r"""begin(vector_string_t self) -> std::vector< std::string >::iterator"""
return _libBornAgainBase.vector_string_t_begin(self)
def end(self):
r"""end(vector_string_t self) -> std::vector< std::string >::iterator"""
return _libBornAgainBase.vector_string_t_end(self)
def rbegin(self):
r"""rbegin(vector_string_t self) -> std::vector< std::string >::reverse_iterator"""
return _libBornAgainBase.vector_string_t_rbegin(self)
def rend(self):
r"""rend(vector_string_t self) -> std::vector< std::string >::reverse_iterator"""
return _libBornAgainBase.vector_string_t_rend(self)
def clear(self):
r"""clear(vector_string_t self)"""
return _libBornAgainBase.vector_string_t_clear(self)
def get_allocator(self):
r"""get_allocator(vector_string_t self) -> std::vector< std::string >::allocator_type"""
return _libBornAgainBase.vector_string_t_get_allocator(self)
def pop_back(self):
r"""pop_back(vector_string_t self)"""
return _libBornAgainBase.vector_string_t_pop_back(self)
def erase(self, *args):
r"""
erase(vector_string_t self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
erase(vector_string_t self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
"""
return _libBornAgainBase.vector_string_t_erase(self, *args)
def __init__(self, *args):
r"""
__init__(vector_string_t self) -> vector_string_t
__init__(vector_string_t self, vector_string_t other) -> vector_string_t
__init__(vector_string_t self, std::vector< std::string >::size_type size) -> vector_string_t
__init__(vector_string_t self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> vector_string_t
"""
_libBornAgainBase.vector_string_t_swiginit(self, _libBornAgainBase.new_vector_string_t(*args))
def push_back(self, x):
r"""push_back(vector_string_t self, std::vector< std::string >::value_type const & x)"""
return _libBornAgainBase.vector_string_t_push_back(self, x)
def front(self):
r"""front(vector_string_t self) -> std::vector< std::string >::value_type const &"""
return _libBornAgainBase.vector_string_t_front(self)
def back(self):
r"""back(vector_string_t self) -> std::vector< std::string >::value_type const &"""
return _libBornAgainBase.vector_string_t_back(self)
def assign(self, n, x):
r"""assign(vector_string_t self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
return _libBornAgainBase.vector_string_t_assign(self, n, x)
def resize(self, *args):
r"""
resize(vector_string_t self, std::vector< std::string >::size_type new_size)
resize(vector_string_t self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
"""
return _libBornAgainBase.vector_string_t_resize(self, *args)
def insert(self, *args):
r"""
insert(vector_string_t self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
insert(vector_string_t self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)
"""
return _libBornAgainBase.vector_string_t_insert(self, *args)
def reserve(self, n):
r"""reserve(vector_string_t self, std::vector< std::string >::size_type n)"""
return _libBornAgainBase.vector_string_t_reserve(self, n)
def capacity(self):
r"""capacity(vector_string_t self) -> std::vector< std::string >::size_type"""
return _libBornAgainBase.vector_string_t_capacity(self)
__swig_destroy__ = _libBornAgainBase.delete_vector_string_t
# Register vector_string_t in _libBornAgainBase:
_libBornAgainBase.vector_string_t_swigregister(vector_string_t)
class map_string_double_t(object):
r"""Proxy of C++ std::map< std::string,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(map_string_double_t self) -> SwigPyIterator"""
return _libBornAgainBase.map_string_double_t_iterator(self)
def __iter__(self):
return self.iterator()
def __nonzero__(self):
r"""__nonzero__(map_string_double_t self) -> bool"""
return _libBornAgainBase.map_string_double_t___nonzero__(self)
def __bool__(self):
r"""__bool__(map_string_double_t self) -> bool"""
return _libBornAgainBase.map_string_double_t___bool__(self)
def __len__(self):
r"""__len__(map_string_double_t self) -> std::map< std::string,double >::size_type"""
return _libBornAgainBase.map_string_double_t___len__(self)
def __iter__(self):
return self.key_iterator()
def iterkeys(self):
return self.key_iterator()
def itervalues(self):
return self.value_iterator()
def iteritems(self):
return self.iterator()
def __getitem__(self, key):
r"""__getitem__(map_string_double_t self, std::map< std::string,double >::key_type const & key) -> std::map< std::string,double >::mapped_type const &"""
return _libBornAgainBase.map_string_double_t___getitem__(self, key)
def __delitem__(self, key):
r"""__delitem__(map_string_double_t self, std::map< std::string,double >::key_type const & key)"""
return _libBornAgainBase.map_string_double_t___delitem__(self, key)
def has_key(self, key):
r"""has_key(map_string_double_t self, std::map< std::string,double >::key_type const & key) -> bool"""
return _libBornAgainBase.map_string_double_t_has_key(self, key)
def keys(self):
r"""keys(map_string_double_t self) -> PyObject *"""
return _libBornAgainBase.map_string_double_t_keys(self)
def values(self):
r"""values(map_string_double_t self) -> PyObject *"""
return _libBornAgainBase.map_string_double_t_values(self)
def items(self):
r"""items(map_string_double_t self) -> PyObject *"""
return _libBornAgainBase.map_string_double_t_items(self)
def __contains__(self, key):
r"""__contains__(map_string_double_t self, std::map< std::string,double >::key_type const & key) -> bool"""
return _libBornAgainBase.map_string_double_t___contains__(self, key)
def key_iterator(self):
r"""key_iterator(map_string_double_t self) -> SwigPyIterator"""
return _libBornAgainBase.map_string_double_t_key_iterator(self)
def value_iterator(self):
r"""value_iterator(map_string_double_t self) -> SwigPyIterator"""
return _libBornAgainBase.map_string_double_t_value_iterator(self)
def __setitem__(self, *args):
r"""
__setitem__(map_string_double_t self, std::map< std::string,double >::key_type const & key)
__setitem__(map_string_double_t self, std::map< std::string,double >::key_type const & key, std::map< std::string,double >::mapped_type const & x)
"""
return _libBornAgainBase.map_string_double_t___setitem__(self, *args)
def asdict(self):
r"""asdict(map_string_double_t self) -> PyObject *"""
return _libBornAgainBase.map_string_double_t_asdict(self)
def __init__(self, *args):
r"""
__init__(map_string_double_t self, std::less< std::string > const & other) -> map_string_double_t
__init__(map_string_double_t self) -> map_string_double_t
__init__(map_string_double_t self, map_string_double_t other) -> map_string_double_t
"""
_libBornAgainBase.map_string_double_t_swiginit(self, _libBornAgainBase.new_map_string_double_t(*args))
def empty(self):
r"""empty(map_string_double_t self) -> bool"""
return _libBornAgainBase.map_string_double_t_empty(self)
def size(self):
r"""size(map_string_double_t self) -> std::map< std::string,double >::size_type"""
return _libBornAgainBase.map_string_double_t_size(self)
def swap(self, v):
r"""swap(map_string_double_t self, map_string_double_t v)"""
return _libBornAgainBase.map_string_double_t_swap(self, v)
def begin(self):
r"""begin(map_string_double_t self) -> std::map< std::string,double >::iterator"""
return _libBornAgainBase.map_string_double_t_begin(self)
def end(self):
r"""end(map_string_double_t self) -> std::map< std::string,double >::iterator"""
return _libBornAgainBase.map_string_double_t_end(self)
def rbegin(self):
r"""rbegin(map_string_double_t self) -> std::map< std::string,double >::reverse_iterator"""
return _libBornAgainBase.map_string_double_t_rbegin(self)
def rend(self):
r"""rend(map_string_double_t self) -> std::map< std::string,double >::reverse_iterator"""
return _libBornAgainBase.map_string_double_t_rend(self)
def clear(self):
r"""clear(map_string_double_t self)"""
return _libBornAgainBase.map_string_double_t_clear(self)
def get_allocator(self):
r"""get_allocator(map_string_double_t self) -> std::map< std::string,double >::allocator_type"""
return _libBornAgainBase.map_string_double_t_get_allocator(self)
def count(self, x):
r"""count(map_string_double_t self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::size_type"""
return _libBornAgainBase.map_string_double_t_count(self, x)
def erase(self, *args):
r"""
erase(map_string_double_t self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::size_type
erase(map_string_double_t self, std::map< std::string,double >::iterator position)
erase(map_string_double_t self, std::map< std::string,double >::iterator first, std::map< std::string,double >::iterator last)
"""
return _libBornAgainBase.map_string_double_t_erase(self, *args)
def find(self, x):
r"""find(map_string_double_t self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::iterator"""
return _libBornAgainBase.map_string_double_t_find(self, x)
def lower_bound(self, x):
r"""lower_bound(map_string_double_t self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::iterator"""
return _libBornAgainBase.map_string_double_t_lower_bound(self, x)
def upper_bound(self, x):
r"""upper_bound(map_string_double_t self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::iterator"""
return _libBornAgainBase.map_string_double_t_upper_bound(self, x)
__swig_destroy__ = _libBornAgainBase.delete_map_string_double_t
# Register map_string_double_t in _libBornAgainBase:
_libBornAgainBase.map_string_double_t_swigregister(map_string_double_t)
class pvacuum_double_t(object):
r"""Proxy of C++ std::pair< double,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__(pvacuum_double_t self) -> pvacuum_double_t
__init__(pvacuum_double_t self, double first, double second) -> pvacuum_double_t
__init__(pvacuum_double_t self, pvacuum_double_t other) -> pvacuum_double_t
"""
_libBornAgainBase.pvacuum_double_t_swiginit(self, _libBornAgainBase.new_pvacuum_double_t(*args))
first = property(_libBornAgainBase.pvacuum_double_t_first_get, _libBornAgainBase.pvacuum_double_t_first_set, doc=r"""first : double""")
second = property(_libBornAgainBase.pvacuum_double_t_second_get, _libBornAgainBase.pvacuum_double_t_second_set, doc=r"""second : double""")
def __len__(self):
return 2
def __repr__(self):
return str((self.first, self.second))
def __getitem__(self, index):
if not (index % 2):
return self.first
else:
return self.second
def __setitem__(self, index, val):
if not (index % 2):
self.first = val
else:
self.second = val
__swig_destroy__ = _libBornAgainBase.delete_pvacuum_double_t
# Register pvacuum_double_t in _libBornAgainBase:
_libBornAgainBase.pvacuum_double_t_swigregister(pvacuum_double_t)
class vector_pvacuum_double_t(object):
r"""Proxy of C++ std::vector< std::pair< double,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(vector_pvacuum_double_t self) -> SwigPyIterator"""
return _libBornAgainBase.vector_pvacuum_double_t_iterator(self)
def __iter__(self):
return self.iterator()
def __nonzero__(self):
r"""__nonzero__(vector_pvacuum_double_t self) -> bool"""
return _libBornAgainBase.vector_pvacuum_double_t___nonzero__(self)
def __bool__(self):
r"""__bool__(vector_pvacuum_double_t self) -> bool"""
return _libBornAgainBase.vector_pvacuum_double_t___bool__(self)
def __len__(self):
r"""__len__(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::size_type"""
return _libBornAgainBase.vector_pvacuum_double_t___len__(self)
def __getslice__(self, i, j):
r"""__getslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j) -> vector_pvacuum_double_t"""
return _libBornAgainBase.vector_pvacuum_double_t___getslice__(self, i, j)
def __setslice__(self, *args):
r"""
__setslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)
__setslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j, vector_pvacuum_double_t v)
"""
return _libBornAgainBase.vector_pvacuum_double_t___setslice__(self, *args)
def __delslice__(self, i, j):
r"""__delslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)"""
return _libBornAgainBase.vector_pvacuum_double_t___delslice__(self, i, j)
def __delitem__(self, *args):
r"""
__delitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i)
__delitem__(vector_pvacuum_double_t self, PySliceObject * slice)
"""
return _libBornAgainBase.vector_pvacuum_double_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
__getitem__(vector_pvacuum_double_t self, PySliceObject * slice) -> vector_pvacuum_double_t
__getitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_t
"""
return _libBornAgainBase.vector_pvacuum_double_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
__setitem__(vector_pvacuum_double_t self, PySliceObject * slice, vector_pvacuum_double_t v)
__setitem__(vector_pvacuum_double_t self, PySliceObject * slice)
__setitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_t x)
"""
return _libBornAgainBase.vector_pvacuum_double_t___setitem__(self, *args)
def pop(self):
r"""pop(vector_pvacuum_double_t self) -> pvacuum_double_t"""
return _libBornAgainBase.vector_pvacuum_double_t_pop(self)
def append(self, x):
r"""append(vector_pvacuum_double_t self, pvacuum_double_t x)"""
return _libBornAgainBase.vector_pvacuum_double_t_append(self, x)
def empty(self):
r"""empty(vector_pvacuum_double_t self) -> bool"""
return _libBornAgainBase.vector_pvacuum_double_t_empty(self)
def size(self):
r"""size(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::size_type"""
return _libBornAgainBase.vector_pvacuum_double_t_size(self)
def swap(self, v):
r"""swap(vector_pvacuum_double_t self, vector_pvacuum_double_t v)"""
return _libBornAgainBase.vector_pvacuum_double_t_swap(self, v)
def begin(self):
r"""begin(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::iterator"""
return _libBornAgainBase.vector_pvacuum_double_t_begin(self)
def end(self):
r"""end(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::iterator"""
return _libBornAgainBase.vector_pvacuum_double_t_end(self)
def rbegin(self):
r"""rbegin(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::reverse_iterator"""
return _libBornAgainBase.vector_pvacuum_double_t_rbegin(self)
def rend(self):
r"""rend(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::reverse_iterator"""
return _libBornAgainBase.vector_pvacuum_double_t_rend(self)
def clear(self):
r"""clear(vector_pvacuum_double_t self)"""
return _libBornAgainBase.vector_pvacuum_double_t_clear(self)
def get_allocator(self):
r"""get_allocator(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::allocator_type"""
return _libBornAgainBase.vector_pvacuum_double_t_get_allocator(self)
def pop_back(self):
r"""pop_back(vector_pvacuum_double_t self)"""
return _libBornAgainBase.vector_pvacuum_double_t_pop_back(self)
def erase(self, *args):
r"""
erase(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::iterator pos) -> std::vector< std::pair< double,double > >::iterator
erase(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::iterator first, std::vector< std::pair< double,double > >::iterator last) -> std::vector< std::pair< double,double > >::iterator
"""
return _libBornAgainBase.vector_pvacuum_double_t_erase(self, *args)
def __init__(self, *args):
r"""
__init__(vector_pvacuum_double_t self) -> vector_pvacuum_double_t
__init__(vector_pvacuum_double_t self, vector_pvacuum_double_t other) -> vector_pvacuum_double_t
__init__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type size) -> vector_pvacuum_double_t
__init__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type size, pvacuum_double_t value) -> vector_pvacuum_double_t
"""
_libBornAgainBase.vector_pvacuum_double_t_swiginit(self, _libBornAgainBase.new_vector_pvacuum_double_t(*args))
def push_back(self, x):
r"""push_back(vector_pvacuum_double_t self, pvacuum_double_t x)"""
return _libBornAgainBase.vector_pvacuum_double_t_push_back(self, x)
def front(self):
r"""front(vector_pvacuum_double_t self) -> pvacuum_double_t"""
return _libBornAgainBase.vector_pvacuum_double_t_front(self)
def back(self):
r"""back(vector_pvacuum_double_t self) -> pvacuum_double_t"""
return _libBornAgainBase.vector_pvacuum_double_t_back(self)
def assign(self, n, x):
r"""assign(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type n, pvacuum_double_t x)"""
return _libBornAgainBase.vector_pvacuum_double_t_assign(self, n, x)
def resize(self, *args):
r"""
resize(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type new_size)
resize(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type new_size, pvacuum_double_t x)
"""
return _libBornAgainBase.vector_pvacuum_double_t_resize(self, *args)
def insert(self, *args):
r"""
insert(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::iterator pos, pvacuum_double_t x) -> std::vector< std::pair< double,double > >::iterator
insert(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::iterator pos, std::vector< std::pair< double,double > >::size_type n, pvacuum_double_t x)
"""
return _libBornAgainBase.vector_pvacuum_double_t_insert(self, *args)
def reserve(self, n):
r"""reserve(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type n)"""
return _libBornAgainBase.vector_pvacuum_double_t_reserve(self, n)
def capacity(self):
r"""capacity(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::size_type"""
return _libBornAgainBase.vector_pvacuum_double_t_capacity(self)
__swig_destroy__ = _libBornAgainBase.delete_vector_pvacuum_double_t
# Register vector_pvacuum_double_t in _libBornAgainBase:
_libBornAgainBase.vector_pvacuum_double_t_swigregister(vector_pvacuum_double_t)
def mul_I(z):
r"""
mul_I(complex_t z) -> complex_t
complex_t mul_I(complex_t z)
Returns product I*z, where I is the imaginary unit.
"""
return _libBornAgainBase.mul_I(z)
def exp_I(z):
r"""
exp_I(complex_t z) -> complex_t
complex_t exp_I(complex_t z)
Returns exp(I*z), where I is the imaginary unit.
"""
return _libBornAgainBase.exp_I(z)
class ICloneable(object):
r"""
Interface for polymorphic classes that should not be copied, except by explicit cloning.
Child classes of ICloneable must provide clone().
C++ includes: ICloneable.h
"""
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__ = _libBornAgainBase.delete_ICloneable
def clone(self):
r"""
clone(ICloneable self) -> ICloneable
virtual ICloneable* ICloneable::clone() const =0
"""
return _libBornAgainBase.ICloneable_clone(self)
def transferToCPP(self):
r"""
transferToCPP(ICloneable self)
virtual void ICloneable::transferToCPP()
Used for Python overriding of clone (see swig/tweaks.py)
"""
return self.__disown__()
# Register ICloneable in _libBornAgainBase:
_libBornAgainBase.ICloneable_swigregister(ICloneable)
cvar = _libBornAgainBase.cvar
I = cvar.I
class ThreadInfo(object):
r"""
Information to run simulation with dedicated number of threads.
C++ includes: ThreadInfo.h
"""
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__(ThreadInfo self) -> ThreadInfo
ThreadInfo::ThreadInfo()
"""
_libBornAgainBase.ThreadInfo_swiginit(self, _libBornAgainBase.new_ThreadInfo())
n_threads = property(_libBornAgainBase.ThreadInfo_n_threads_get, _libBornAgainBase.ThreadInfo_n_threads_set, doc=r"""n_threads : unsigned int""")
n_batches = property(_libBornAgainBase.ThreadInfo_n_batches_get, _libBornAgainBase.ThreadInfo_n_batches_set, doc=r"""n_batches : unsigned int""")
current_batch = property(_libBornAgainBase.ThreadInfo_current_batch_get, _libBornAgainBase.ThreadInfo_current_batch_set, doc=r"""current_batch : unsigned int""")
__swig_destroy__ = _libBornAgainBase.delete_ThreadInfo
# Register ThreadInfo in _libBornAgainBase:
_libBornAgainBase.ThreadInfo_swigregister(ThreadInfo)
def vecOfLambdaAlphaPhi(_lambda, _alpha, _phi):
r"""
vecOfLambdaAlphaPhi(double _lambda, double _alpha, double _phi) -> R3
R3 vecOfLambdaAlphaPhi(double _lambda, double _alpha, double _phi)
"""
return _libBornAgainBase.vecOfLambdaAlphaPhi(_lambda, _alpha, _phi)
class Direction(object):
r"""
A direction in three-dimensional space.
C++ includes: Direction.h
"""
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__(Direction self, double alpha, double phi) -> Direction
__init__(Direction self) -> Direction
Direction::Direction()
"""
_libBornAgainBase.Direction_swiginit(self, _libBornAgainBase.new_Direction(*args))
def alpha(self):
r"""
alpha(Direction self) -> double
double Direction::alpha() const
"""
return _libBornAgainBase.Direction_alpha(self)
def phi(self):
r"""
phi(Direction self) -> double
double Direction::phi() const
"""
return _libBornAgainBase.Direction_phi(self)
def vector(self):
r"""
vector(Direction self) -> R3
R3 Direction::vector() const
Returns Cartesian 3D vector.
"""
return _libBornAgainBase.Direction_vector(self)
def zReflected(self):
r"""
zReflected(Direction self) -> Direction
Direction Direction::zReflected() const
"""
return _libBornAgainBase.Direction_zReflected(self)
__swig_destroy__ = _libBornAgainBase.delete_Direction
# Register Direction in _libBornAgainBase:
_libBornAgainBase.Direction_swigregister(Direction)
nanometer = cvar.nanometer
angstrom = cvar.angstrom
micrometer = cvar.micrometer
millimeter = cvar.millimeter
nm = cvar.nm
nm2 = cvar.nm2
rad = cvar.rad
deg = cvar.deg
tesla = cvar.tesla
gauss = cvar.gauss
class Transform3D(object):
r"""
Vector transformations in three dimensions.
C++ includes: Transform3D.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
EULER = _libBornAgainBase.Transform3D_EULER
XAXIS = _libBornAgainBase.Transform3D_XAXIS
YAXIS = _libBornAgainBase.Transform3D_YAXIS
ZAXIS = _libBornAgainBase.Transform3D_ZAXIS
def __init__(self):
r"""
__init__(Transform3D self) -> Transform3D
Transform3D::Transform3D(Eigen::Matrix3d matrix)
Constructor from matrix (no checks if this is an element of SO(3)!)
"""
_libBornAgainBase.Transform3D_swiginit(self, _libBornAgainBase.new_Transform3D())
__swig_destroy__ = _libBornAgainBase.delete_Transform3D
def clone(self):
r"""
clone(Transform3D self) -> Transform3D
Transform3D * Transform3D::clone() const
Clones the transformation.
"""
return _libBornAgainBase.Transform3D_clone(self)
@staticmethod
def createRotateX(phi):
r"""createRotateX(double phi) -> Transform3D"""
return _libBornAgainBase.Transform3D_createRotateX(phi)
@staticmethod
def createRotateY(phi):
r"""createRotateY(double phi) -> Transform3D"""
return _libBornAgainBase.Transform3D_createRotateY(phi)
@staticmethod
def createRotateZ(phi):
r"""createRotateZ(double phi) -> Transform3D"""
return _libBornAgainBase.Transform3D_createRotateZ(phi)
@staticmethod
def createRotateEuler(alpha, beta, gamma):
r"""createRotateEuler(double alpha, double beta, double gamma) -> Transform3D"""
return _libBornAgainBase.Transform3D_createRotateEuler(alpha, beta, gamma)
def calculateEulerAngles(self, p_alpha, p_beta, p_gamma):
r"""
calculateEulerAngles(Transform3D self, double * p_alpha, double * p_beta, double * p_gamma)
void Transform3D::calculateEulerAngles(double *p_alpha, double *p_beta, double *p_gamma) const
Calculates the Euler angles corresponding to the rotation.
"""
return _libBornAgainBase.Transform3D_calculateEulerAngles(self, p_alpha, p_beta, p_gamma)
def calculateRotateXAngle(self):
r"""
calculateRotateXAngle(Transform3D self) -> double
double Transform3D::calculateRotateXAngle() const
Calculates the rotation angle for a rotation around the x-axis alone Only meaningfull if the actual rotation is around the x-axis
"""
return _libBornAgainBase.Transform3D_calculateRotateXAngle(self)
def calculateRotateYAngle(self):
r"""
calculateRotateYAngle(Transform3D self) -> double
double Transform3D::calculateRotateYAngle() const
Calculates the rotation angle for a rotation around the y-axis alone Only meaningfull if the actual rotation is around the y-axis
"""
return _libBornAgainBase.Transform3D_calculateRotateYAngle(self)
def calculateRotateZAngle(self):
r"""
calculateRotateZAngle(Transform3D self) -> double
double Transform3D::calculateRotateZAngle() const
Calculates the rotation angle for a rotation around the z-axis alone Only meaningfull if the actual rotation is around the z-axis
"""
return _libBornAgainBase.Transform3D_calculateRotateZAngle(self)
def getInverse(self):
r"""
getInverse(Transform3D self) -> Transform3D
Transform3D Transform3D::getInverse() const
Returns the inverse transformation.
"""
return _libBornAgainBase.Transform3D_getInverse(self)
def __mul__(self, other):
r"""__mul__(Transform3D self, Transform3D other) -> Transform3D"""
return _libBornAgainBase.Transform3D___mul__(self, other)
def __eq__(self, other):
r"""__eq__(Transform3D self, Transform3D other) -> bool"""
return _libBornAgainBase.Transform3D___eq__(self, other)
def getRotationType(self):
r"""
getRotationType(Transform3D self) -> Transform3D::ERotationType
Transform3D::ERotationType Transform3D::getRotationType() const
Retrieve the rotation type (general, around x, y or z-axis)
"""
return _libBornAgainBase.Transform3D_getRotationType(self)
def isIdentity(self):
r"""
isIdentity(Transform3D self) -> bool
bool Transform3D::isIdentity() const
Determine if the transformation is trivial (identity)
"""
return _libBornAgainBase.Transform3D_isIdentity(self)
def _print(self, ostr):
r"""
_print(Transform3D self, std::ostream & ostr)
void Transform3D::print(std::ostream &ostr) const
"""
return _libBornAgainBase.Transform3D__print(self, ostr)
def isXRotation(self):
r"""
isXRotation(Transform3D self) -> bool
bool Transform3D::isXRotation() const
"""
return _libBornAgainBase.Transform3D_isXRotation(self)
def isYRotation(self):
r"""
isYRotation(Transform3D self) -> bool
bool Transform3D::isYRotation() const
"""
return _libBornAgainBase.Transform3D_isYRotation(self)
def isZRotation(self):
r"""
isZRotation(Transform3D self) -> bool
bool Transform3D::isZRotation() const
"""
return _libBornAgainBase.Transform3D_isZRotation(self)
# Register Transform3D in _libBornAgainBase:
_libBornAgainBase.Transform3D_swigregister(Transform3D)
def Transform3D_createRotateX(phi):
r"""Transform3D_createRotateX(double phi) -> Transform3D"""
return _libBornAgainBase.Transform3D_createRotateX(phi)
def Transform3D_createRotateY(phi):
r"""Transform3D_createRotateY(double phi) -> Transform3D"""
return _libBornAgainBase.Transform3D_createRotateY(phi)
def Transform3D_createRotateZ(phi):
r"""Transform3D_createRotateZ(double phi) -> Transform3D"""
return _libBornAgainBase.Transform3D_createRotateZ(phi)
def Transform3D_createRotateEuler(alpha, beta, gamma):
r"""Transform3D_createRotateEuler(double alpha, double beta, double gamma) -> Transform3D"""
return _libBornAgainBase.Transform3D_createRotateEuler(alpha, beta, gamma)
class Bin1D(object):
r"""Proxy of C++ Bin1D 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__(Bin1D self) -> Bin1D
__init__(Bin1D self, double lower, double upper) -> Bin1D
Bin1D::Bin1D(double lower, double upper)
"""
_libBornAgainBase.Bin1D_swiginit(self, _libBornAgainBase.new_Bin1D(*args))
m_lower = property(_libBornAgainBase.Bin1D_m_lower_get, _libBornAgainBase.Bin1D_m_lower_set, doc=r"""m_lower : double""")
m_upper = property(_libBornAgainBase.Bin1D_m_upper_get, _libBornAgainBase.Bin1D_m_upper_set, doc=r"""m_upper : double""")
def center(self):
r"""
center(Bin1D self) -> double
double Bin1D::center() const
"""
return _libBornAgainBase.Bin1D_center(self)
def binSize(self):
r"""
binSize(Bin1D self) -> double
double Bin1D::binSize() const
"""
return _libBornAgainBase.Bin1D_binSize(self)
__swig_destroy__ = _libBornAgainBase.delete_Bin1D
# Register Bin1D in _libBornAgainBase:
_libBornAgainBase.Bin1D_swigregister(Bin1D)
def BinContains(bin, value):
r"""
BinContains(Bin1D bin, double value) -> bool
bool BinContains(const Bin1D &bin, double value)
Checks if value is contained in bin: value in [m_lower, m_upper)
"""
return _libBornAgainBase.BinContains(bin, value)
class Bin1DKVector(object):
r"""
An one-dimensional range of R3's.
C++ includes: Bin.h
"""
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__(Bin1DKVector self) -> Bin1DKVector
__init__(Bin1DKVector self, R3 lower, R3 upper) -> Bin1DKVector
__init__(Bin1DKVector self, double wavelength, Bin1D alpha_bin, Bin1D phi_bin) -> Bin1DKVector
Bin1DKVector::Bin1DKVector(double wavelength, const Bin1D &alpha_bin, const Bin1D &phi_bin)
creation on Bin1DKVector from alpha and phi bins
"""
_libBornAgainBase.Bin1DKVector_swiginit(self, _libBornAgainBase.new_Bin1DKVector(*args))
def center(self):
r"""
center(Bin1DKVector self) -> R3
R3 Bin1DKVector::center() const
"""
return _libBornAgainBase.Bin1DKVector_center(self)
def span(self):
r"""
span(Bin1DKVector self) -> R3
R3 Bin1DKVector::span() const
"""
return _libBornAgainBase.Bin1DKVector_span(self)
m_q_lower = property(_libBornAgainBase.Bin1DKVector_m_q_lower_get, _libBornAgainBase.Bin1DKVector_m_q_lower_set, doc=r"""m_q_lower : R3""")
m_q_upper = property(_libBornAgainBase.Bin1DKVector_m_q_upper_get, _libBornAgainBase.Bin1DKVector_m_q_upper_set, doc=r"""m_q_upper : R3""")
__swig_destroy__ = _libBornAgainBase.delete_Bin1DKVector
# Register Bin1DKVector in _libBornAgainBase:
_libBornAgainBase.Bin1DKVector_swigregister(Bin1DKVector)
class Bin1DCVector(object):
r"""
An one-dimensional range of C3's.
C++ includes: Bin.h
"""
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__(Bin1DCVector self) -> Bin1DCVector
__init__(Bin1DCVector self, C3 lower, C3 upper) -> Bin1DCVector
__init__(Bin1DCVector self, double wavelength, Bin1D alpha_bin, Bin1D phi_bin) -> Bin1DCVector
Bin1DCVector::Bin1DCVector(double wavelength, const Bin1D &alpha_bin, const Bin1D &phi_bin)
creation on Bin1DCVector from alpha and phi bins
"""
_libBornAgainBase.Bin1DCVector_swiginit(self, _libBornAgainBase.new_Bin1DCVector(*args))
def center(self):
r"""
center(Bin1DCVector self) -> C3
C3 Bin1DCVector::center() const
"""
return _libBornAgainBase.Bin1DCVector_center(self)
def span(self):
r"""
span(Bin1DCVector self) -> C3
C3 Bin1DCVector::span() const
"""
return _libBornAgainBase.Bin1DCVector_span(self)
m_q_lower = property(_libBornAgainBase.Bin1DCVector_m_q_lower_get, _libBornAgainBase.Bin1DCVector_m_q_lower_set, doc=r"""m_q_lower : C3""")
m_q_upper = property(_libBornAgainBase.Bin1DCVector_m_q_upper_get, _libBornAgainBase.Bin1DCVector_m_q_upper_set, doc=r"""m_q_upper : C3""")
__swig_destroy__ = _libBornAgainBase.delete_Bin1DCVector
# Register Bin1DCVector in _libBornAgainBase:
_libBornAgainBase.Bin1DCVector_swigregister(Bin1DCVector)
class IAxis(object):
r"""
Abstract base class for one-dimensional axes.
C++ includes: IAxis.h
"""
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__ = _libBornAgainBase.delete_IAxis
def clone(self):
r"""
clone(IAxis self) -> IAxis
virtual IAxis* IAxis::clone() const =0
"""
return _libBornAgainBase.IAxis_clone(self)
def setAxisName(self, name):
r"""
setAxisName(IAxis self, std::string name)
void IAxis::setAxisName(std::string name)
Sets the axis label.
"""
return _libBornAgainBase.IAxis_setAxisName(self, name)
def size(self):
r"""
size(IAxis self) -> size_t
virtual size_t IAxis::size() const =0
Returns the number of bins.
"""
return _libBornAgainBase.IAxis_size(self)
def lowerBound(self):
r"""
lowerBound(IAxis self) -> double
virtual double IAxis::lowerBound() const =0
Returns value of first point of axis.
"""
return _libBornAgainBase.IAxis_lowerBound(self)
def upperBound(self):
r"""
upperBound(IAxis self) -> double
virtual double IAxis::upperBound() const =0
Returns value of last point of axis.
"""
return _libBornAgainBase.IAxis_upperBound(self)
def bounds(self):
r"""
bounds(IAxis self) -> pvacuum_double_t
std::pair< double, double > IAxis::bounds() const
Returns lower and upper bound in a pair. first is lower, second is upper.
"""
return _libBornAgainBase.IAxis_bounds(self)
def span(self):
r"""
span(IAxis self) -> double
double IAxis::span() const
Returns distance from first to last point.
"""
return _libBornAgainBase.IAxis_span(self)
def center(self):
r"""
center(IAxis self) -> double
double IAxis::center() const
Returns midpoint of axis.
"""
return _libBornAgainBase.IAxis_center(self)
def axisName(self):
r"""
axisName(IAxis self) -> std::string
std::string IAxis::axisName() const
Returns the label of the axis.
"""
return _libBornAgainBase.IAxis_axisName(self)
def binCenters(self):
r"""
binCenters(IAxis self) -> vdouble1d_t
std::vector< double > IAxis::binCenters() const
"""
return _libBornAgainBase.IAxis_binCenters(self)
def binBoundaries(self):
r"""
binBoundaries(IAxis self) -> vdouble1d_t
std::vector< double > IAxis::binBoundaries() const
"""
return _libBornAgainBase.IAxis_binBoundaries(self)
def bin(self, index):
r"""
bin(IAxis self, size_t index) -> Bin1D
virtual Bin1D IAxis::bin(size_t index) const =0
retrieve a 1d bin for the given index
"""
return _libBornAgainBase.IAxis_bin(self, index)
def binCenter(self, index):
r"""
binCenter(IAxis self, size_t index) -> double
virtual double IAxis::binCenter(size_t index) const =0
"""
return _libBornAgainBase.IAxis_binCenter(self, index)
def findClosestIndex(self, value):
r"""
findClosestIndex(IAxis self, double value) -> size_t
virtual size_t IAxis::findClosestIndex(double value) const =0
find bin index which is best match for given value
"""
return _libBornAgainBase.IAxis_findClosestIndex(self, value)
def contains(self, value):
r"""
contains(IAxis self, double value) -> bool
bool IAxis::contains(double value) const
Returns true if axis contains given point.
"""
return _libBornAgainBase.IAxis_contains(self, value)
def clip(self, *args):
r"""
clip(IAxis self, double lower, double upper)
clip(IAxis self, pvacuum_double_t bounds)
void IAxis::clip(std::pair< double, double > bounds)
Convenience overload to clip this axis to the given values. bounds.first is lower, bounds.second is upper value.
"""
return _libBornAgainBase.IAxis_clip(self, *args)
def __eq__(self, right):
r"""__eq__(IAxis self, IAxis right) -> bool"""
return _libBornAgainBase.IAxis___eq__(self, right)
def __ne__(self, right):
r"""__ne__(IAxis self, IAxis right) -> bool"""
return _libBornAgainBase.IAxis___ne__(self, right)
# Register IAxis in _libBornAgainBase:
_libBornAgainBase.IAxis_swigregister(IAxis)
class VariableBinAxis(IAxis):
r"""
Axis with variable bin size.
C++ includes: VariableBinAxis.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
def __init__(self, name, nbins, bin_boundaries):
r"""
__init__(VariableBinAxis self, std::string const & name, size_t nbins, vdouble1d_t bin_boundaries) -> VariableBinAxis
VariableBinAxis::VariableBinAxis(const std::string &name, size_t nbins, const std::vector< double > &bin_boundaries)
VariableBinAxis constructor.
Parameters:
-----------
name:
Axis name
nbins:
number of bins
bin_boundaries:
Array of size nbins+1 containing low-edges for each bin and upper edge of last bin.
"""
_libBornAgainBase.VariableBinAxis_swiginit(self, _libBornAgainBase.new_VariableBinAxis(name, nbins, bin_boundaries))
__swig_destroy__ = _libBornAgainBase.delete_VariableBinAxis
def clone(self):
r"""
clone(VariableBinAxis self) -> VariableBinAxis
VariableBinAxis * VariableBinAxis::clone() const override
"""
return _libBornAgainBase.VariableBinAxis_clone(self)
def size(self):
r"""
size(VariableBinAxis self) -> size_t
size_t VariableBinAxis::size() const override
Returns the number of bins.
"""
return _libBornAgainBase.VariableBinAxis_size(self)
def bin(self, index):
r"""
bin(VariableBinAxis self, size_t index) -> Bin1D
Bin1D VariableBinAxis::bin(size_t index) const override
retrieve a 1d bin for the given index
"""
return _libBornAgainBase.VariableBinAxis_bin(self, index)
def lowerBound(self):
r"""
lowerBound(VariableBinAxis self) -> double
double VariableBinAxis::lowerBound() const override
Returns value of first point of axis.
"""
return _libBornAgainBase.VariableBinAxis_lowerBound(self)
def upperBound(self):
r"""
upperBound(VariableBinAxis self) -> double
double VariableBinAxis::upperBound() const override
Returns value of last point of axis.
"""
return _libBornAgainBase.VariableBinAxis_upperBound(self)
def binCenter(self, index):
r"""
binCenter(VariableBinAxis self, size_t index) -> double
double VariableBinAxis::binCenter(size_t index) const override
"""
return _libBornAgainBase.VariableBinAxis_binCenter(self, index)
def findClosestIndex(self, value):
r"""
findClosestIndex(VariableBinAxis self, double value) -> size_t
size_t VariableBinAxis::findClosestIndex(double value) const override
find bin index which is best match for given value
"""
return _libBornAgainBase.VariableBinAxis_findClosestIndex(self, value)
def binCenters(self):
r"""
binCenters(VariableBinAxis self) -> vdouble1d_t
std::vector< double > VariableBinAxis::binCenters() const override
"""
return _libBornAgainBase.VariableBinAxis_binCenters(self)
def binBoundaries(self):
r"""
binBoundaries(VariableBinAxis self) -> vdouble1d_t
std::vector<double> VariableBinAxis::binBoundaries() const override
"""
return _libBornAgainBase.VariableBinAxis_binBoundaries(self)
def clip(self, lower, upper):
r"""
clip(VariableBinAxis self, double lower, double upper)
void VariableBinAxis::clip(double lower, double upper) override
Clips this axis to the given values.
"""
return _libBornAgainBase.VariableBinAxis_clip(self, lower, upper)
def __getitem__(self, i):
r"""__getitem__(VariableBinAxis self, unsigned int i) -> double"""
return _libBornAgainBase.VariableBinAxis___getitem__(self, i)
# Register VariableBinAxis in _libBornAgainBase:
_libBornAgainBase.VariableBinAxis_swigregister(VariableBinAxis)
class ConstKBinAxis(VariableBinAxis):
r"""
Axis with fixed bin size in sin(angle) space.
C++ includes: ConstKBinAxis.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
def __init__(self, name, nbins, start, end):
r"""
__init__(ConstKBinAxis self, std::string const & name, size_t nbins, double start, double end) -> ConstKBinAxis
ConstKBinAxis::ConstKBinAxis(const std::string &name, size_t nbins, double start, double end)
ConstKBinAxis constructor.
Parameters:
-----------
name:
Axis name
nbins:
number of bins
start:
low edge of first bin
end:
upper edge of last bin
"""
_libBornAgainBase.ConstKBinAxis_swiginit(self, _libBornAgainBase.new_ConstKBinAxis(name, nbins, start, end))
__swig_destroy__ = _libBornAgainBase.delete_ConstKBinAxis
def clone(self):
r"""
clone(ConstKBinAxis self) -> ConstKBinAxis
ConstKBinAxis * ConstKBinAxis::clone() const override
"""
return _libBornAgainBase.ConstKBinAxis_clone(self)
def clip(self, lower, upper):
r"""
clip(ConstKBinAxis self, double lower, double upper)
void ConstKBinAxis::clip(double lower, double upper) override
Clips this axis to the given values.
"""
return _libBornAgainBase.ConstKBinAxis_clip(self, lower, upper)
# Register ConstKBinAxis in _libBornAgainBase:
_libBornAgainBase.ConstKBinAxis_swigregister(ConstKBinAxis)
class CustomBinAxis(VariableBinAxis):
r"""
Axis with fixed bin size in sin(angle) space used for numerical comparison with IsGisaxs. The main feature of the axis is that it produces zero bin sizes.
C++ includes: CustomBinAxis.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
def __init__(self, name, nbins, start, end):
r"""
__init__(CustomBinAxis self, std::string const & name, size_t nbins, double start, double end) -> CustomBinAxis
CustomBinAxis::CustomBinAxis(const std::string &name, size_t nbins, double start, double end)
CustomBinAxis constructor.
Parameters:
-----------
name:
Axis name
nbins:
number of bins
start:
center of first bin (IsGisaxs convention)
end:
center of last bin (IsGisaxs convention)
"""
_libBornAgainBase.CustomBinAxis_swiginit(self, _libBornAgainBase.new_CustomBinAxis(name, nbins, start, end))
__swig_destroy__ = _libBornAgainBase.delete_CustomBinAxis
def clone(self):
r"""
clone(CustomBinAxis self) -> CustomBinAxis
CustomBinAxis * CustomBinAxis::clone() const override
"""
return _libBornAgainBase.CustomBinAxis_clone(self)
def bin(self, index):
r"""
bin(CustomBinAxis self, size_t index) -> Bin1D
Bin1D CustomBinAxis::bin(size_t index) const override
retrieve a 1d bin for the given index
"""
return _libBornAgainBase.CustomBinAxis_bin(self, index)
def binCenters(self):
r"""
binCenters(CustomBinAxis self) -> vdouble1d_t
std::vector< double > CustomBinAxis::binCenters() const override
"""
return _libBornAgainBase.CustomBinAxis_binCenters(self)
def clip(self, lower, upper):
r"""
clip(CustomBinAxis self, double lower, double upper)
void CustomBinAxis::clip(double lower, double upper) override
Clips this axis to the given values.
"""
return _libBornAgainBase.CustomBinAxis_clip(self, lower, upper)
# Register CustomBinAxis in _libBornAgainBase:
_libBornAgainBase.CustomBinAxis_swigregister(CustomBinAxis)
class FixedBinAxis(IAxis):
r"""
Axis with fixed bin size.
C++ includes: FixedBinAxis.h
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
def __init__(self, name, nbins, start, end):
r"""
__init__(FixedBinAxis self, std::string const & name, size_t nbins, double start, double end) -> FixedBinAxis
FixedBinAxis::FixedBinAxis(const std::string &name, size_t nbins, double start, double end)
FixedBinAxis constructor.
Parameters:
-----------
name:
Axis name
nbins:
number of bins
start:
low edge of first bin
end:
upper edge of last bin
"""
_libBornAgainBase.FixedBinAxis_swiginit(self, _libBornAgainBase.new_FixedBinAxis(name, nbins, start, end))
__swig_destroy__ = _libBornAgainBase.delete_FixedBinAxis
def clone(self):
r"""
clone(FixedBinAxis self) -> FixedBinAxis
FixedBinAxis * FixedBinAxis::clone() const override
"""
return _libBornAgainBase.FixedBinAxis_clone(self)
def size(self):
r"""
size(FixedBinAxis self) -> size_t
size_t FixedBinAxis::size() const override
Returns the number of bins.
"""
return _libBornAgainBase.FixedBinAxis_size(self)
def bin(self, index):
r"""
bin(FixedBinAxis self, size_t index) -> Bin1D
Bin1D FixedBinAxis::bin(size_t index) const override
retrieve a 1d bin for the given index
"""
return _libBornAgainBase.FixedBinAxis_bin(self, index)
def lowerBound(self):
r"""
lowerBound(FixedBinAxis self) -> double
double FixedBinAxis::lowerBound() const override
Returns value of first point of axis.
"""
return _libBornAgainBase.FixedBinAxis_lowerBound(self)
def upperBound(self):
r"""
upperBound(FixedBinAxis self) -> double
double FixedBinAxis::upperBound() const override
Returns value of last point of axis.
"""
return _libBornAgainBase.FixedBinAxis_upperBound(self)
def binCenter(self, index):
r"""
binCenter(FixedBinAxis self, size_t index) -> double
double FixedBinAxis::binCenter(size_t index) const override
"""
return _libBornAgainBase.FixedBinAxis_binCenter(self, index)
def findClosestIndex(self, value):
r"""
findClosestIndex(FixedBinAxis self, double value) -> size_t
size_t FixedBinAxis::findClosestIndex(double value) const override
find bin index which is best match for given value
"""
return _libBornAgainBase.FixedBinAxis_findClosestIndex(self, value)
def binCenters(self):
r"""
binCenters(FixedBinAxis self) -> vdouble1d_t
std::vector< double > FixedBinAxis::binCenters() const override
"""
return _libBornAgainBase.FixedBinAxis_binCenters(self)
def binBoundaries(self):
r"""
binBoundaries(FixedBinAxis self) -> vdouble1d_t
std::vector< double > FixedBinAxis::binBoundaries() const override
"""
return _libBornAgainBase.FixedBinAxis_binBoundaries(self)
def clip(self, lower, upper):
r"""
clip(FixedBinAxis self, double lower, double upper)
void FixedBinAxis::clip(double lower, double upper) override
Clips this axis to the given values.
"""
return _libBornAgainBase.FixedBinAxis_clip(self, lower, upper)
def __getitem__(self, i):
r"""__getitem__(FixedBinAxis self, unsigned int i) -> double"""
return _libBornAgainBase.FixedBinAxis___getitem__(self, i)
# Register FixedBinAxis in _libBornAgainBase:
_libBornAgainBase.FixedBinAxis_swigregister(FixedBinAxis)
class R3(arrayR3_t):
r"""
Three-dimensional vector template, for use with integer, double, or complex components.
C++ includes: Vectors3D.h
"""
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__(R3 self) -> R3
__init__(R3 self, double const x, double const y, double const z) -> R3
Vec3< T >::Vec3(const T x, const T y, const T z)
Constructs a vector from cartesian components.
"""
_libBornAgainBase.R3_swiginit(self, _libBornAgainBase.new_R3(*args))
def x(self):
r"""
x(R3 self) -> double
T Vec3< T >::x() const
Returns x-component in cartesian coordinate system.
"""
return _libBornAgainBase.R3_x(self)
def y(self):
r"""
y(R3 self) -> double
T Vec3< T >::y() const
Returns y-component in cartesian coordinate system.
"""
return _libBornAgainBase.R3_y(self)
def z(self):
r"""
z(R3 self) -> double
T Vec3< T >::z() const
Returns z-component in cartesian coordinate system.
"""
return _libBornAgainBase.R3_z(self)
def setX(self, a):
r"""
setX(R3 self, double const & a)
void Vec3< T >::setX(const T &a)
Sets x-component in cartesian coordinate system.
"""
return _libBornAgainBase.R3_setX(self, a)
def setY(self, a):
r"""
setY(R3 self, double const & a)
void Vec3< T >::setY(const T &a)
Sets y-component in cartesian coordinate system.
"""
return _libBornAgainBase.R3_setY(self, a)
def setZ(self, a):
r"""
setZ(R3 self, double const & a)
void Vec3< T >::setZ(const T &a)
Sets z-component in cartesian coordinate system.
"""
return _libBornAgainBase.R3_setZ(self, a)
def __iadd__(self, v):
r"""__iadd__(R3 self, R3 v) -> R3"""
return _libBornAgainBase.R3___iadd__(self, v)
def __isub__(self, v):
r"""__isub__(R3 self, R3 v) -> R3"""
return _libBornAgainBase.R3___isub__(self, v)
def conj(self):
r"""
conj(R3 self) -> R3
Vec3<T> Vec3< T >::conj() const
Returns complex conjugate vector.
"""
return _libBornAgainBase.R3_conj(self)
def mag2(self):
r"""
mag2(R3 self) -> double
double Vec3< T >::mag2() const
Returns magnitude squared of the vector.
"""
return _libBornAgainBase.R3_mag2(self)
def mag(self):
r"""
mag(R3 self) -> double
double Vec3< T >::mag() const
Returns magnitude of the vector.
"""
return _libBornAgainBase.R3_mag(self)
def magxy2(self):
r"""
magxy2(R3 self) -> double
double Vec3< T >::magxy2() const
Returns squared distance from z axis.
"""
return _libBornAgainBase.R3_magxy2(self)
def magxy(self):
r"""
magxy(R3 self) -> double
double Vec3< T >::magxy() const
Returns distance from z axis.
"""
return _libBornAgainBase.R3_magxy(self)
def phi(self):
r"""
phi(R3 self) -> double
double Vec3< T >::phi() const
Returns azimuth angle.
"""
return _libBornAgainBase.R3_phi(self)
def theta(self):
r"""
theta(R3 self) -> double
double Vec3< T >::theta() const
Returns polar angle.
"""
return _libBornAgainBase.R3_theta(self)
def cosTheta(self):
r"""
cosTheta(R3 self) -> double
double Vec3< T >::cosTheta() const
Returns cosine of polar angle.
"""
return _libBornAgainBase.R3_cosTheta(self)
def sin2Theta(self):
r"""
sin2Theta(R3 self) -> double
double Vec3< T >::sin2Theta() const
Returns squared sine of polar angle.
"""
return _libBornAgainBase.R3_sin2Theta(self)
def unit(self):
r"""
unit(R3 self) -> R3
Vec3<T> Vec3< T >::unit() const
Returns unit vector in direction of this. Throws for null vector.
"""
return _libBornAgainBase.R3_unit(self)
def complex(self):
r"""
complex(R3 self) -> C3
C3 Vec3< T >::complex() const
Returns this, trivially converted to complex type.
"""
return _libBornAgainBase.R3_complex(self)
def real(self):
r"""
real(R3 self) -> R3
R3 Vec3< T >::real() const
Returns real parts.
"""
return _libBornAgainBase.R3_real(self)
def angle(self, v):
r"""
angle(R3 self, R3 v) -> double
double Vec3< T >::angle(const Vec3< T > &v) const
Returns angle with respect to another vector.
"""
return _libBornAgainBase.R3_angle(self, v)
def project(self, v):
r"""
project(R3 self, R3 v) -> R3
Vec3<T> Vec3< T >::project(const Vec3< T > &v) const
Returns projection of this onto other vector: (this*v)*v/|v|^2.
"""
return _libBornAgainBase.R3_project(self, v)
__swig_destroy__ = _libBornAgainBase.delete_R3
# Register R3 in _libBornAgainBase:
_libBornAgainBase.R3_swigregister(R3)
class vector_R3(object):
r"""Proxy of C++ std::vector< Vec3< 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(vector_R3 self) -> SwigPyIterator"""
return _libBornAgainBase.vector_R3_iterator(self)
def __iter__(self):
return self.iterator()
def __nonzero__(self):
r"""__nonzero__(vector_R3 self) -> bool"""
return _libBornAgainBase.vector_R3___nonzero__(self)
def __bool__(self):
r"""__bool__(vector_R3 self) -> bool"""
return _libBornAgainBase.vector_R3___bool__(self)
def __len__(self):
r"""__len__(vector_R3 self) -> std::vector< Vec3< double > >::size_type"""
return _libBornAgainBase.vector_R3___len__(self)
def __getslice__(self, i, j):
r"""__getslice__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, std::vector< Vec3< double > >::difference_type j) -> vector_R3"""
return _libBornAgainBase.vector_R3___getslice__(self, i, j)
def __setslice__(self, *args):
r"""
__setslice__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, std::vector< Vec3< double > >::difference_type j)
__setslice__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, std::vector< Vec3< double > >::difference_type j, vector_R3 v)
"""
return _libBornAgainBase.vector_R3___setslice__(self, *args)
def __delslice__(self, i, j):
r"""__delslice__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, std::vector< Vec3< double > >::difference_type j)"""
return _libBornAgainBase.vector_R3___delslice__(self, i, j)
def __delitem__(self, *args):
r"""
__delitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i)
__delitem__(vector_R3 self, PySliceObject * slice)
"""
return _libBornAgainBase.vector_R3___delitem__(self, *args)
def __getitem__(self, *args):
r"""
__getitem__(vector_R3 self, PySliceObject * slice) -> vector_R3
__getitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i) -> R3
"""
return _libBornAgainBase.vector_R3___getitem__(self, *args)
def __setitem__(self, *args):
r"""
__setitem__(vector_R3 self, PySliceObject * slice, vector_R3 v)
__setitem__(vector_R3 self, PySliceObject * slice)
__setitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, R3 x)
"""
return _libBornAgainBase.vector_R3___setitem__(self, *args)
def pop(self):
r"""pop(vector_R3 self) -> R3"""
return _libBornAgainBase.vector_R3_pop(self)
def append(self, x):
r"""append(vector_R3 self, R3 x)"""
return _libBornAgainBase.vector_R3_append(self, x)
def empty(self):
r"""empty(vector_R3 self) -> bool"""
return _libBornAgainBase.vector_R3_empty(self)
def size(self):
r"""size(vector_R3 self) -> std::vector< Vec3< double > >::size_type"""
return _libBornAgainBase.vector_R3_size(self)
def swap(self, v):
r"""swap(vector_R3 self, vector_R3 v)"""
return _libBornAgainBase.vector_R3_swap(self, v)
def begin(self):
r"""begin(vector_R3 self) -> std::vector< Vec3< double > >::iterator"""
return _libBornAgainBase.vector_R3_begin(self)
def end(self):
r"""end(vector_R3 self) -> std::vector< Vec3< double > >::iterator"""
return _libBornAgainBase.vector_R3_end(self)
def rbegin(self):
r"""rbegin(vector_R3 self) -> std::vector< Vec3< double > >::reverse_iterator"""
return _libBornAgainBase.vector_R3_rbegin(self)
def rend(self):
r"""rend(vector_R3 self) -> std::vector< Vec3< double > >::reverse_iterator"""
return _libBornAgainBase.vector_R3_rend(self)
def clear(self):
r"""clear(vector_R3 self)"""
return _libBornAgainBase.vector_R3_clear(self)
def get_allocator(self):
r"""get_allocator(vector_R3 self) -> std::vector< Vec3< double > >::allocator_type"""
return _libBornAgainBase.vector_R3_get_allocator(self)
def pop_back(self):
r"""pop_back(vector_R3 self)"""
return _libBornAgainBase.vector_R3_pop_back(self)
def erase(self, *args):
r"""
erase(vector_R3 self, std::vector< Vec3< double > >::iterator pos) -> std::vector< Vec3< double > >::iterator
erase(vector_R3 self, std::vector< Vec3< double > >::iterator first, std::vector< Vec3< double > >::iterator last) -> std::vector< Vec3< double > >::iterator
"""
return _libBornAgainBase.vector_R3_erase(self, *args)
def __init__(self, *args):
r"""
__init__(vector_R3 self) -> vector_R3
__init__(vector_R3 self, vector_R3 other) -> vector_R3
__init__(vector_R3 self, std::vector< Vec3< double > >::size_type size) -> vector_R3
__init__(vector_R3 self, std::vector< Vec3< double > >::size_type size, R3 value) -> vector_R3
"""
_libBornAgainBase.vector_R3_swiginit(self, _libBornAgainBase.new_vector_R3(*args))
def push_back(self, x):
r"""push_back(vector_R3 self, R3 x)"""
return _libBornAgainBase.vector_R3_push_back(self, x)
def front(self):
r"""front(vector_R3 self) -> R3"""
return _libBornAgainBase.vector_R3_front(self)
def back(self):
r"""back(vector_R3 self) -> R3"""
return _libBornAgainBase.vector_R3_back(self)
def assign(self, n, x):
r"""assign(vector_R3 self, std::vector< Vec3< double > >::size_type n, R3 x)"""
return _libBornAgainBase.vector_R3_assign(self, n, x)
def resize(self, *args):
r"""
resize(vector_R3 self, std::vector< Vec3< double > >::size_type new_size)
resize(vector_R3 self, std::vector< Vec3< double > >::size_type new_size, R3 x)
"""
return _libBornAgainBase.vector_R3_resize(self, *args)
def insert(self, *args):
r"""
insert(vector_R3 self, std::vector< Vec3< double > >::iterator pos, R3 x) -> std::vector< Vec3< double > >::iterator
insert(vector_R3 self, std::vector< Vec3< double > >::iterator pos, std::vector< Vec3< double > >::size_type n, R3 x)
"""
return _libBornAgainBase.vector_R3_insert(self, *args)
def reserve(self, n):
r"""reserve(vector_R3 self, std::vector< Vec3< double > >::size_type n)"""
return _libBornAgainBase.vector_R3_reserve(self, n)
def capacity(self):
r"""capacity(vector_R3 self) -> std::vector< Vec3< double > >::size_type"""
return _libBornAgainBase.vector_R3_capacity(self)
__swig_destroy__ = _libBornAgainBase.delete_vector_R3
# Register vector_R3 in _libBornAgainBase:
_libBornAgainBase.vector_R3_swigregister(vector_R3)
class C3(arrayC3_t):
r"""
Three-dimensional vector template, for use with integer, double, or complex components.
C++ includes: Vectors3D.h
"""
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__(C3 self) -> C3
__init__(C3 self, std::complex< double > const x, std::complex< double > const y, std::complex< double > const z) -> C3
Vec3< T >::Vec3(const T x, const T y, const T z)
Constructs a vector from cartesian components.
"""
_libBornAgainBase.C3_swiginit(self, _libBornAgainBase.new_C3(*args))
def x(self):
r"""
x(C3 self) -> std::complex< double >
T Vec3< T >::x() const
Returns x-component in cartesian coordinate system.
"""
return _libBornAgainBase.C3_x(self)
def y(self):
r"""
y(C3 self) -> std::complex< double >
T Vec3< T >::y() const
Returns y-component in cartesian coordinate system.
"""
return _libBornAgainBase.C3_y(self)
def z(self):
r"""
z(C3 self) -> std::complex< double >
T Vec3< T >::z() const
Returns z-component in cartesian coordinate system.
"""
return _libBornAgainBase.C3_z(self)
def setX(self, a):
r"""
setX(C3 self, std::complex< double > const & a)
void Vec3< T >::setX(const T &a)
Sets x-component in cartesian coordinate system.
"""
return _libBornAgainBase.C3_setX(self, a)
def setY(self, a):
r"""
setY(C3 self, std::complex< double > const & a)
void Vec3< T >::setY(const T &a)
Sets y-component in cartesian coordinate system.
"""
return _libBornAgainBase.C3_setY(self, a)
def setZ(self, a):
r"""
setZ(C3 self, std::complex< double > const & a)
void Vec3< T >::setZ(const T &a)
Sets z-component in cartesian coordinate system.
"""
return _libBornAgainBase.C3_setZ(self, a)
def __iadd__(self, v):
r"""__iadd__(C3 self, C3 v) -> C3"""
return _libBornAgainBase.C3___iadd__(self, v)
def __isub__(self, v):
r"""__isub__(C3 self, C3 v) -> C3"""
return _libBornAgainBase.C3___isub__(self, v)
def conj(self):
r"""
conj(C3 self) -> C3
Vec3<T> Vec3< T >::conj() const
Returns complex conjugate vector.
"""
return _libBornAgainBase.C3_conj(self)
def mag2(self):
r"""
mag2(C3 self) -> double
double Vec3< T >::mag2() const
Returns magnitude squared of the vector.
"""
return _libBornAgainBase.C3_mag2(self)
def mag(self):
r"""
mag(C3 self) -> double
double Vec3< T >::mag() const
Returns magnitude of the vector.
"""
return _libBornAgainBase.C3_mag(self)
def magxy2(self):
r"""
magxy2(C3 self) -> double
double Vec3< T >::magxy2() const
Returns squared distance from z axis.
"""
return _libBornAgainBase.C3_magxy2(self)
def magxy(self):
r"""
magxy(C3 self) -> double
double Vec3< T >::magxy() const
Returns distance from z axis.
"""
return _libBornAgainBase.C3_magxy(self)
def unit(self):
r"""
unit(C3 self) -> C3
Vec3<T> Vec3< T >::unit() const
Returns unit vector in direction of this. Throws for null vector.
"""
return _libBornAgainBase.C3_unit(self)
def real(self):
r"""
real(C3 self) -> R3
R3 Vec3< T >::real() const
Returns real parts.
"""
return _libBornAgainBase.C3_real(self)
def project(self, v):
r"""
project(C3 self, C3 v) -> C3
Vec3<T> Vec3< T >::project(const Vec3< T > &v) const
Returns projection of this onto other vector: (this*v)*v/|v|^2.
"""
return _libBornAgainBase.C3_project(self, v)
__swig_destroy__ = _libBornAgainBase.delete_C3
# Register C3 in _libBornAgainBase:
_libBornAgainBase.C3_swigregister(C3)
class vector_C3(object):
r"""Proxy of C++ std::vector< Vec3< std::complex< 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(vector_C3 self) -> SwigPyIterator"""
return _libBornAgainBase.vector_C3_iterator(self)
def __iter__(self):
return self.iterator()
def __nonzero__(self):
r"""__nonzero__(vector_C3 self) -> bool"""
return _libBornAgainBase.vector_C3___nonzero__(self)
def __bool__(self):
r"""__bool__(vector_C3 self) -> bool"""
return _libBornAgainBase.vector_C3___bool__(self)
def __len__(self):
r"""__len__(vector_C3 self) -> std::vector< Vec3< std::complex< double > > >::size_type"""
return _libBornAgainBase.vector_C3___len__(self)
def __getslice__(self, i, j):
r"""__getslice__(vector_C3 self, std::vector< Vec3< std::complex< double > > >::difference_type i, std::vector< Vec3< std::complex< double > > >::difference_type j) -> vector_C3"""
return _libBornAgainBase.vector_C3___getslice__(self, i, j)
def __setslice__(self, *args):
r"""
__setslice__(vector_C3 self, std::vector< Vec3< std::complex< double > > >::difference_type i, std::vector< Vec3< std::complex< double > > >::difference_type j)
__setslice__(vector_C3 self, std::vector< Vec3< std::complex< double > > >::difference_type i, std::vector< Vec3< std::complex< double > > >::difference_type j, vector_C3 v)
"""
return _libBornAgainBase.vector_C3___setslice__(self, *args)
def __delslice__(self, i, j):
r"""__delslice__(vector_C3 self, std::vector< Vec3< std::complex< double > > >::difference_type i, std::vector< Vec3< std::complex< double > > >::difference_type j)"""
return _libBornAgainBase.vector_C3___delslice__(self, i, j)
def __delitem__(self, *args):
r"""
__delitem__(vector_C3 self, std::vector< Vec3< std::complex< double > > >::difference_type i)
__delitem__(vector_C3 self, PySliceObject * slice)
"""
return _libBornAgainBase.vector_C3___delitem__(self, *args)
def __getitem__(self, *args):
r"""
__getitem__(vector_C3 self, PySliceObject * slice) -> vector_C3
__getitem__(vector_C3 self, std::vector< Vec3< std::complex< double > > >::difference_type i) -> C3
"""
return _libBornAgainBase.vector_C3___getitem__(self, *args)
def __setitem__(self, *args):
r"""
__setitem__(vector_C3 self, PySliceObject * slice, vector_C3 v)
__setitem__(vector_C3 self, PySliceObject * slice)
__setitem__(vector_C3 self, std::vector< Vec3< std::complex< double > > >::difference_type i, C3 x)
"""
return _libBornAgainBase.vector_C3___setitem__(self, *args)
def pop(self):
r"""pop(vector_C3 self) -> C3"""
return _libBornAgainBase.vector_C3_pop(self)
def append(self, x):
r"""append(vector_C3 self, C3 x)"""
return _libBornAgainBase.vector_C3_append(self, x)
def empty(self):
r"""empty(vector_C3 self) -> bool"""
return _libBornAgainBase.vector_C3_empty(self)
def size(self):
r"""size(vector_C3 self) -> std::vector< Vec3< std::complex< double > > >::size_type"""
return _libBornAgainBase.vector_C3_size(self)
def swap(self, v):
r"""swap(vector_C3 self, vector_C3 v)"""
return _libBornAgainBase.vector_C3_swap(self, v)
def begin(self):
r"""begin(vector_C3 self) -> std::vector< Vec3< std::complex< double > > >::iterator"""
return _libBornAgainBase.vector_C3_begin(self)
def end(self):
r"""end(vector_C3 self) -> std::vector< Vec3< std::complex< double > > >::iterator"""
return _libBornAgainBase.vector_C3_end(self)
def rbegin(self):
r"""rbegin(vector_C3 self) -> std::vector< Vec3< std::complex< double > > >::reverse_iterator"""
return _libBornAgainBase.vector_C3_rbegin(self)
def rend(self):
r"""rend(vector_C3 self) -> std::vector< Vec3< std::complex< double > > >::reverse_iterator"""
return _libBornAgainBase.vector_C3_rend(self)
def clear(self):
r"""clear(vector_C3 self)"""
return _libBornAgainBase.vector_C3_clear(self)
def get_allocator(self):
r"""get_allocator(vector_C3 self) -> std::vector< Vec3< std::complex< double > > >::allocator_type"""
return _libBornAgainBase.vector_C3_get_allocator(self)
def pop_back(self):
r"""pop_back(vector_C3 self)"""
return _libBornAgainBase.vector_C3_pop_back(self)
def erase(self, *args):
r"""
erase(vector_C3 self, std::vector< Vec3< std::complex< double > > >::iterator pos) -> std::vector< Vec3< std::complex< double > > >::iterator
erase(vector_C3 self, std::vector< Vec3< std::complex< double > > >::iterator first, std::vector< Vec3< std::complex< double > > >::iterator last) -> std::vector< Vec3< std::complex< double > > >::iterator
"""
return _libBornAgainBase.vector_C3_erase(self, *args)
def __init__(self, *args):
r"""
__init__(vector_C3 self) -> vector_C3
__init__(vector_C3 self, vector_C3 other) -> vector_C3
__init__(vector_C3 self, std::vector< Vec3< std::complex< double > > >::size_type size) -> vector_C3
__init__(vector_C3 self, std::vector< Vec3< std::complex< double > > >::size_type size, C3 value) -> vector_C3
"""
_libBornAgainBase.vector_C3_swiginit(self, _libBornAgainBase.new_vector_C3(*args))
def push_back(self, x):
r"""push_back(vector_C3 self, C3 x)"""
return _libBornAgainBase.vector_C3_push_back(self, x)
def front(self):
r"""front(vector_C3 self) -> C3"""
return _libBornAgainBase.vector_C3_front(self)
def back(self):
r"""back(vector_C3 self) -> C3"""
return _libBornAgainBase.vector_C3_back(self)
def assign(self, n, x):
r"""assign(vector_C3 self, std::vector< Vec3< std::complex< double > > >::size_type n, C3 x)"""
return _libBornAgainBase.vector_C3_assign(self, n, x)
def resize(self, *args):
r"""
resize(vector_C3 self, std::vector< Vec3< std::complex< double > > >::size_type new_size)
resize(vector_C3 self, std::vector< Vec3< std::complex< double > > >::size_type new_size, C3 x)
"""
return _libBornAgainBase.vector_C3_resize(self, *args)
def insert(self, *args):
r"""
insert(vector_C3 self, std::vector< Vec3< std::complex< double > > >::iterator pos, C3 x) -> std::vector< Vec3< std::complex< double > > >::iterator
insert(vector_C3 self, std::vector< Vec3< std::complex< double > > >::iterator pos, std::vector< Vec3< std::complex< double > > >::size_type n, C3 x)
"""
return _libBornAgainBase.vector_C3_insert(self, *args)
def reserve(self, n):
r"""reserve(vector_C3 self, std::vector< Vec3< std::complex< double > > >::size_type n)"""
return _libBornAgainBase.vector_C3_reserve(self, n)
def capacity(self):
r"""capacity(vector_C3 self) -> std::vector< Vec3< std::complex< double > > >::size_type"""
return _libBornAgainBase.vector_C3_capacity(self)
__swig_destroy__ = _libBornAgainBase.delete_vector_C3
# Register vector_C3 in _libBornAgainBase:
_libBornAgainBase.vector_C3_swigregister(vector_C3)