# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.2.1
#
# 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
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 == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


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


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


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


class SwigPyIterator(object):
    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)

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 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, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainBase.vdouble1d_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vdouble1d_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, vdouble1d_T v)
        __setitem__(vdouble1d_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainBase.vdouble2d_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vdouble2d_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, vdouble2d_T v)
        __setitem__(vdouble2d_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainBase.vector_integer_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_integer_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, vector_integer_T v)
        __setitem__(vector_integer_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainBase.vinteger2d_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vinteger2d_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, vinteger2d_T v)
        __setitem__(vinteger2d_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainBase.vector_longinteger_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_longinteger_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, vector_longinteger_T v)
        __setitem__(vector_longinteger_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainBase.vector_complex_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_complex_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, vector_complex_T v)
        __setitem__(vector_complex_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainBase.vector_string_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_string_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, vector_string_T v)
        __setitem__(vector_string_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainBase.vector_pvacuum_double_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_pvacuum_double_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_T v)
        __setitem__(vector_pvacuum_double_T self, SWIGPY_SLICEOBJECT * 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""" Returns product I*z, where I is the imaginary unit."""
    return _libBornAgainBase.mul_I(z)

def exp_I(z):
    r""" Returns exp(I*z), where I is the imaginary unit."""
    return _libBornAgainBase.exp_I(z)

def isfinite(z):
    r"""isfinite(complex_t z) -> bool"""
    return _libBornAgainBase.isfinite(z)
class Span(object):
    r""" Defines class Span. http://www.bornagainproject.org GNU General Public License v3 or higher (see COPYING) Copyright: Forschungszentrum Jülich GmbH 2018 Authors: Scientific Computing Group at MLZ (see CITATION, AUTHORS) An interval. Limits are of type double, and may be infinite. Used for the z-coordinate, especially when slicing form factors."""

    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__(Span self) -> Span
        __init__(Span self, double low, double hig) -> Span
        """
        _libBornAgainBase.Span_swiginit(self, _libBornAgainBase.new_Span(*args))
    __swig_destroy__ = _libBornAgainBase.delete_Span

# Register Span in _libBornAgainBase:
_libBornAgainBase.Span_swigregister(Span)
cvar = _libBornAgainBase.cvar
I = cvar.I


def rad2deg(angle):
    r"""rad2deg(double angle) -> double"""
    return _libBornAgainBase.rad2deg(angle)

def deg2rad(angle):
    r"""deg2rad(double angle) -> double"""
    return _libBornAgainBase.deg2rad(angle)

def checkScalar(a, b, ulp):
    r""" Defines constants and "almost equal" in namespace Numeric. http://www.bornagainproject.org GNU General Public License v3 or higher (see COPYING) Copyright: Forschungszentrum Jülich GmbH 2018 Authors: Scientific Computing Group at MLZ (see CITATION, AUTHORS) Floating-point approximations."""
    return _libBornAgainBase.checkScalar(a, b, ulp)

def theta(a):
    r""" Returns polar angle."""
    return _libBornAgainBase.theta(a)

def phi(a):
    r"""phi(R3 a) -> double"""
    return _libBornAgainBase.phi(a)

def cosTheta(a):
    r"""cosTheta(R3 a) -> double"""
    return _libBornAgainBase.cosTheta(a)

def sin2Theta(a):
    r"""sin2Theta(R3 a) -> double"""
    return _libBornAgainBase.sin2Theta(a)

def angle(a, b):
    r"""angle(R3 a, R3 b) -> double"""
    return _libBornAgainBase.angle(a, b)
class Scale(object):
    r""" An axis, with coordinate and bins."""

    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__(Scale self, Coordinate const & coord, std::vector< Bin1D,std::allocator< Bin1D > > const & bins) -> Scale
        __init__(Scale self, Scale other) -> Scale
        """
        _libBornAgainBase.Scale_swiginit(self, _libBornAgainBase.new_Scale(*args))
    __swig_destroy__ = _libBornAgainBase.delete_Scale

    def binCenter(self, i):
        r"""binCenter(Scale self, size_t i) -> double"""
        return _libBornAgainBase.Scale_binCenter(self, i)

    def binCenters(self):
        r"""binCenters(Scale self) -> vdouble1d_T"""
        return _libBornAgainBase.Scale_binCenters(self)

    def size(self):
        r""" Number of bins"""
        return _libBornAgainBase.Scale_size(self)

    def min(self):
        r""" minimum value in first bin"""
        return _libBornAgainBase.Scale_min(self)

    def max(self):
        r""" maximum value in last bin"""
        return _libBornAgainBase.Scale_max(self)

    def bounds(self):
        r"""bounds(Scale self) -> pvacuum_double_T"""
        return _libBornAgainBase.Scale_bounds(self)

    def rangeComprises(self, value):
        r"""rangeComprises(Scale self, double value) -> bool"""
        return _libBornAgainBase.Scale_rangeComprises(self, value)

    def span(self):
        r"""span(Scale self) -> double"""
        return _libBornAgainBase.Scale_span(self)

    def axisLabel(self):
        r"""axisLabel(Scale self) -> std::string"""
        return _libBornAgainBase.Scale_axisLabel(self)

# Register Scale in _libBornAgainBase:
_libBornAgainBase.Scale_swigregister(Scale)
nm = cvar.nm
angstrom = cvar.angstrom
micrometer = cvar.micrometer
millimeter = cvar.millimeter
nm2 = cvar.nm2
nm3 = cvar.nm3
rad = cvar.rad
deg = cvar.deg
tesla = cvar.tesla
gauss = cvar.gauss


def GenericScale(name, limits):
    r"""GenericScale(std::string name, vdouble1d_T limits) -> Scale"""
    return _libBornAgainBase.GenericScale(name, limits)

def ListScan(name, points):
    r"""ListScan(std::string name, vdouble1d_T points) -> Scale"""
    return _libBornAgainBase.ListScan(name, points)

def EquiDivision(name, N, start, end):
    r""" Returns axis with fixed bin size."""
    return _libBornAgainBase.EquiDivision(name, N, start, end)

def EquiScan(name, N, start, end):
    r""" Returns axis with equidistant points (zero bin width)."""
    return _libBornAgainBase.EquiScan(name, N, start, end)
class Frame(object):
    r""" Holds one or two axes."""

    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__(Frame self, std::vector< Scale const *,std::allocator< Scale const * > > const & axes) -> Frame
        __init__(Frame self, Scale ax0) -> Frame
        __init__(Frame self, Scale ax0, Scale ax1) -> Frame
        __init__(Frame self, Frame arg2) -> Frame
        """
        _libBornAgainBase.Frame_swiginit(self, _libBornAgainBase.new_Frame(*args))
    __swig_destroy__ = _libBornAgainBase.delete_Frame

    def rank(self):
        r""" Returns number of dimensions."""
        return _libBornAgainBase.Frame_rank(self)

    def size(self):
        r""" Returns total number of bins."""
        return _libBornAgainBase.Frame_size(self)

    def axis(self, k_axis):
        r""" Returns axis with given serial number"""
        return _libBornAgainBase.Frame_axis(self, k_axis)

    def xAxis(self):
        r"""xAxis(Frame self) -> Scale"""
        return _libBornAgainBase.Frame_xAxis(self)

    def yAxis(self):
        r"""yAxis(Frame self) -> Scale"""
        return _libBornAgainBase.Frame_yAxis(self)

    def projectedCoord(self, i_flat, k_axis):
        r"""
         Returns the value of selected axis for given i_flat. :type i_flat: int
        :param i_flat: The global index of this data structure. :type k_axis: int
        :param k_axis: Serial number of selected axis. :rtype: float
        :return: corresponding bin center of selected axis
        """
        return _libBornAgainBase.Frame_projectedCoord(self, i_flat, k_axis)

    def projectedBin(self, i_flat, k_axis):
        r"""
         Returns the bin of selected axis for given i_flat. :type i_flat: int
        :param i_flat: The global index of this data structure. :type k_axis: int
        :param k_axis: Serial number of selected axis. :rtype: Bin1D
        :return: corresponding bin of selected axis
        """
        return _libBornAgainBase.Frame_projectedBin(self, i_flat, k_axis)

    def allIndices(self, i_flat):
        r"""
         Returns vector of axes indices for given global index :type i_flat: int
        :param i_flat: The global index of this data structure. :rtype: std::vector< int,std::allocator< int > >
        :return: Vector of bin indices for all axes defined
        """
        return _libBornAgainBase.Frame_allIndices(self, i_flat)

    def projectedIndex(self, i, k_axis):
        r"""
         Returns axis bin index for given global index :type i: int
        :param i: The flat index of this data structure. :type k_axis: int
        :param k_axis: Serial number of selected axis. :rtype: int
        :return: Corresponding bin index for selected axis
        """
        return _libBornAgainBase.Frame_projectedIndex(self, i, k_axis)

    def hasSameSizes(self, arg2):
        r""" Returns true if both Frame%s have same rank, and all axes have same sizes."""
        return _libBornAgainBase.Frame_hasSameSizes(self, arg2)

    def __eq__(self, arg2):
        r""" Returns true if both Frame%s have same rank, and all axes are equal."""
        return _libBornAgainBase.Frame___eq__(self, arg2)

    def plottableFrame(self):
        r""" Applies transform plottableScale to each scale."""
        return _libBornAgainBase.Frame_plottableFrame(self)

    def flat(self):
        r""" Removes scales of size 1."""
        return _libBornAgainBase.Frame_flat(self)

# Register Frame in _libBornAgainBase:
_libBornAgainBase.Frame_swigregister(Frame)
class Arrayf64Wrapper(object):
    r""" Defines ArrayWrapper classes. The array descriptors are required to pass            the type and size information of a C-Array to Python. http://www.bornagainproject.org GNU General Public License v3 or higher (see COPYING) Copyright: Forschungszentrum Jülich GmbH 2018 Authors: Scientific Computing Group at MLZ (see CITATION, AUTHORS) Descriptor of a C-array to be passed to Python to construct a Numpy array."""

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

    def __init__(self, *args):
        r"""
        __init__(Arrayf64Wrapper self, std::size_t const rank, int const * dims, vdouble1d_T array_ptr, bool const copy_data) -> Arrayf64Wrapper
        __init__(Arrayf64Wrapper self) -> Arrayf64Wrapper
        __init__(Arrayf64Wrapper self, Arrayf64Wrapper other) -> Arrayf64Wrapper
        """
        _libBornAgainBase.Arrayf64Wrapper_swiginit(self, _libBornAgainBase.new_Arrayf64Wrapper(*args))

    def size(self):
        r""" Total size of the array."""
        return _libBornAgainBase.Arrayf64Wrapper_size(self)

    def rank(self):
        r""" Returns the rank (= number of dimensions) of the array."""
        return _libBornAgainBase.Arrayf64Wrapper_rank(self)

    def dimensions(self):
        r""" Raw pointer to the array which stores the size of the underlying C-Array on each dimension."""
        return _libBornAgainBase.Arrayf64Wrapper_dimensions(self)

    def array(self):
        r""" Reference to the underlying array."""
        return _libBornAgainBase.Arrayf64Wrapper_array(self)

    def ownData(self):
        r""" Returns true if the array owns its data."""
        return _libBornAgainBase.Arrayf64Wrapper_ownData(self)


    def to_numpy(self):
        import numpy
        asize = len(self.array())
        if asize > 0 and asize == int(numpy.prod(self.dimensions())):
            return numpy.array(self.array(), dtype=float).reshape(self.dimensions())

        return None


# Register Arrayf64Wrapper in _libBornAgainBase:
_libBornAgainBase.Arrayf64Wrapper_swigregister(Arrayf64Wrapper)
class vector_parsample_t(object):
    r"""Proxy of C++ std::vector< ParameterSample > 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_parsample_t self) -> SwigPyIterator"""
        return _libBornAgainBase.vector_parsample_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_parsample_t self) -> bool"""
        return _libBornAgainBase.vector_parsample_t___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_parsample_t self) -> bool"""
        return _libBornAgainBase.vector_parsample_t___bool__(self)

    def __len__(self):
        r"""__len__(vector_parsample_t self) -> std::vector< ParameterSample >::size_type"""
        return _libBornAgainBase.vector_parsample_t___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vector_parsample_t self, std::vector< ParameterSample >::difference_type i, std::vector< ParameterSample >::difference_type j) -> vector_parsample_t"""
        return _libBornAgainBase.vector_parsample_t___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_parsample_t self, std::vector< ParameterSample >::difference_type i, std::vector< ParameterSample >::difference_type j)
        __setslice__(vector_parsample_t self, std::vector< ParameterSample >::difference_type i, std::vector< ParameterSample >::difference_type j, vector_parsample_t v)
        """
        return _libBornAgainBase.vector_parsample_t___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vector_parsample_t self, std::vector< ParameterSample >::difference_type i, std::vector< ParameterSample >::difference_type j)"""
        return _libBornAgainBase.vector_parsample_t___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_parsample_t self, std::vector< ParameterSample >::difference_type i)
        __delitem__(vector_parsample_t self, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainBase.vector_parsample_t___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_parsample_t self, SWIGPY_SLICEOBJECT * slice) -> vector_parsample_t
        __getitem__(vector_parsample_t self, std::vector< ParameterSample >::difference_type i) -> ParameterSample
        """
        return _libBornAgainBase.vector_parsample_t___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_parsample_t self, SWIGPY_SLICEOBJECT * slice, vector_parsample_t v)
        __setitem__(vector_parsample_t self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(vector_parsample_t self, std::vector< ParameterSample >::difference_type i, ParameterSample x)
        """
        return _libBornAgainBase.vector_parsample_t___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_parsample_t self) -> ParameterSample"""
        return _libBornAgainBase.vector_parsample_t_pop(self)

    def append(self, x):
        r"""append(vector_parsample_t self, ParameterSample x)"""
        return _libBornAgainBase.vector_parsample_t_append(self, x)

    def empty(self):
        r"""empty(vector_parsample_t self) -> bool"""
        return _libBornAgainBase.vector_parsample_t_empty(self)

    def size(self):
        r"""size(vector_parsample_t self) -> std::vector< ParameterSample >::size_type"""
        return _libBornAgainBase.vector_parsample_t_size(self)

    def swap(self, v):
        r"""swap(vector_parsample_t self, vector_parsample_t v)"""
        return _libBornAgainBase.vector_parsample_t_swap(self, v)

    def begin(self):
        r"""begin(vector_parsample_t self) -> std::vector< ParameterSample >::iterator"""
        return _libBornAgainBase.vector_parsample_t_begin(self)

    def end(self):
        r"""end(vector_parsample_t self) -> std::vector< ParameterSample >::iterator"""
        return _libBornAgainBase.vector_parsample_t_end(self)

    def rbegin(self):
        r"""rbegin(vector_parsample_t self) -> std::vector< ParameterSample >::reverse_iterator"""
        return _libBornAgainBase.vector_parsample_t_rbegin(self)

    def rend(self):
        r"""rend(vector_parsample_t self) -> std::vector< ParameterSample >::reverse_iterator"""
        return _libBornAgainBase.vector_parsample_t_rend(self)

    def clear(self):
        r"""clear(vector_parsample_t self)"""
        return _libBornAgainBase.vector_parsample_t_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_parsample_t self) -> std::vector< ParameterSample >::allocator_type"""
        return _libBornAgainBase.vector_parsample_t_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_parsample_t self)"""
        return _libBornAgainBase.vector_parsample_t_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vector_parsample_t self, std::vector< ParameterSample >::iterator pos) -> std::vector< ParameterSample >::iterator
        erase(vector_parsample_t self, std::vector< ParameterSample >::iterator first, std::vector< ParameterSample >::iterator last) -> std::vector< ParameterSample >::iterator
        """
        return _libBornAgainBase.vector_parsample_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vector_parsample_t self) -> vector_parsample_t
        __init__(vector_parsample_t self, vector_parsample_t other) -> vector_parsample_t
        __init__(vector_parsample_t self, std::vector< ParameterSample >::size_type size) -> vector_parsample_t
        __init__(vector_parsample_t self, std::vector< ParameterSample >::size_type size, ParameterSample value) -> vector_parsample_t
        """
        _libBornAgainBase.vector_parsample_t_swiginit(self, _libBornAgainBase.new_vector_parsample_t(*args))

    def push_back(self, x):
        r"""push_back(vector_parsample_t self, ParameterSample x)"""
        return _libBornAgainBase.vector_parsample_t_push_back(self, x)

    def front(self):
        r"""front(vector_parsample_t self) -> ParameterSample"""
        return _libBornAgainBase.vector_parsample_t_front(self)

    def back(self):
        r"""back(vector_parsample_t self) -> ParameterSample"""
        return _libBornAgainBase.vector_parsample_t_back(self)

    def assign(self, n, x):
        r"""assign(vector_parsample_t self, std::vector< ParameterSample >::size_type n, ParameterSample x)"""
        return _libBornAgainBase.vector_parsample_t_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vector_parsample_t self, std::vector< ParameterSample >::size_type new_size)
        resize(vector_parsample_t self, std::vector< ParameterSample >::size_type new_size, ParameterSample x)
        """
        return _libBornAgainBase.vector_parsample_t_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vector_parsample_t self, std::vector< ParameterSample >::iterator pos, ParameterSample x) -> std::vector< ParameterSample >::iterator
        insert(vector_parsample_t self, std::vector< ParameterSample >::iterator pos, std::vector< ParameterSample >::size_type n, ParameterSample x)
        """
        return _libBornAgainBase.vector_parsample_t_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vector_parsample_t self, std::vector< ParameterSample >::size_type n)"""
        return _libBornAgainBase.vector_parsample_t_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_parsample_t self) -> std::vector< ParameterSample >::size_type"""
        return _libBornAgainBase.vector_parsample_t_capacity(self)
    __swig_destroy__ = _libBornAgainBase.delete_vector_parsample_t

# Register vector_parsample_t in _libBornAgainBase:
_libBornAgainBase.vector_parsample_t_swigregister(vector_parsample_t)
class ParameterSample(object):
    r""" Defines struct ParameterSample. http://www.bornagainproject.org GNU General Public License v3 or higher (see COPYING) Copyright: Forschungszentrum Jülich GmbH 2018 Authors: Scientific Computing Group at MLZ (see CITATION, AUTHORS) A parameter value with a weight, as obtained when sampling from a distribution."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    value = property(_libBornAgainBase.ParameterSample_value_get, _libBornAgainBase.ParameterSample_value_set, doc=r"""value : double""")
    weight = property(_libBornAgainBase.ParameterSample_weight_get, _libBornAgainBase.ParameterSample_weight_set, doc=r"""weight : double""")

    def __init__(self):
        r"""__init__(ParameterSample self) -> ParameterSample"""
        _libBornAgainBase.ParameterSample_swiginit(self, _libBornAgainBase.new_ParameterSample())
    __swig_destroy__ = _libBornAgainBase.delete_ParameterSample

# Register ParameterSample in _libBornAgainBase:
_libBornAgainBase.ParameterSample_swigregister(ParameterSample)
class Distribution1D(object):
    r""" Interface for one-dimensional distributions."""

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

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

    def setNSamples(self, n):
        r"""setNSamples(Distribution1D self, size_t n)"""
        return _libBornAgainBase.Distribution1D_setNSamples(self, n)

    def setRelSamplingWidth(self, w):
        r"""setRelSamplingWidth(Distribution1D self, double w)"""
        return _libBornAgainBase.Distribution1D_setRelSamplingWidth(self, w)

    def distributionSamples(self):
        r"""distributionSamples(Distribution1D self) -> vector_parsample_t"""
        return _libBornAgainBase.Distribution1D_distributionSamples(self)
    __swig_destroy__ = _libBornAgainBase.delete_Distribution1D

# Register Distribution1D in _libBornAgainBase:
_libBornAgainBase.Distribution1D_swigregister(Distribution1D)
class DistributionGate(Distribution1D):
    r""" Uniform distribution function with half width hwhm."""

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

    def __init__(self, min, max, n_samples=25):
        r"""__init__(DistributionGate self, double min, double max, size_t n_samples=25) -> DistributionGate"""
        _libBornAgainBase.DistributionGate_swiginit(self, _libBornAgainBase.new_DistributionGate(min, max, n_samples))

    def distributionSamples(self):
        r"""distributionSamples(DistributionGate self) -> vector_parsample_t"""
        return _libBornAgainBase.DistributionGate_distributionSamples(self)
    __swig_destroy__ = _libBornAgainBase.delete_DistributionGate

# Register DistributionGate in _libBornAgainBase:
_libBornAgainBase.DistributionGate_swigregister(DistributionGate)
class DistributionLorentz(Distribution1D):
    r""" Lorentz distribution with half width hwhm."""

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

    def __init__(self, mean, hwhm, n_samples=25, rel_sampling_width=2.):
        r"""__init__(DistributionLorentz self, double mean, double hwhm, size_t n_samples=25, double rel_sampling_width=2.) -> DistributionLorentz"""
        _libBornAgainBase.DistributionLorentz_swiginit(self, _libBornAgainBase.new_DistributionLorentz(mean, hwhm, n_samples, rel_sampling_width))

    def distributionSamples(self):
        r"""distributionSamples(DistributionLorentz self) -> vector_parsample_t"""
        return _libBornAgainBase.DistributionLorentz_distributionSamples(self)
    __swig_destroy__ = _libBornAgainBase.delete_DistributionLorentz

# Register DistributionLorentz in _libBornAgainBase:
_libBornAgainBase.DistributionLorentz_swigregister(DistributionLorentz)
class DistributionGaussian(Distribution1D):
    r""" Gaussian distribution with standard deviation std_dev."""

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

    def __init__(self, mean, std_dev, n_samples=25, rel_sampling_width=2.):
        r"""__init__(DistributionGaussian self, double mean, double std_dev, size_t n_samples=25, double rel_sampling_width=2.) -> DistributionGaussian"""
        _libBornAgainBase.DistributionGaussian_swiginit(self, _libBornAgainBase.new_DistributionGaussian(mean, std_dev, n_samples, rel_sampling_width))

    def distributionSamples(self):
        r"""distributionSamples(DistributionGaussian self) -> vector_parsample_t"""
        return _libBornAgainBase.DistributionGaussian_distributionSamples(self)
    __swig_destroy__ = _libBornAgainBase.delete_DistributionGaussian

# Register DistributionGaussian in _libBornAgainBase:
_libBornAgainBase.DistributionGaussian_swigregister(DistributionGaussian)
class DistributionLogNormal(Distribution1D):
    r""" Log-normal distribution."""

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

    def __init__(self, median, scale_param, n_samples=25, rel_sampling_width=2.):
        r"""__init__(DistributionLogNormal self, double median, double scale_param, size_t n_samples=25, double rel_sampling_width=2.) -> DistributionLogNormal"""
        _libBornAgainBase.DistributionLogNormal_swiginit(self, _libBornAgainBase.new_DistributionLogNormal(median, scale_param, n_samples, rel_sampling_width))

    def distributionSamples(self):
        r"""distributionSamples(DistributionLogNormal self) -> vector_parsample_t"""
        return _libBornAgainBase.DistributionLogNormal_distributionSamples(self)
    __swig_destroy__ = _libBornAgainBase.delete_DistributionLogNormal

# Register DistributionLogNormal in _libBornAgainBase:
_libBornAgainBase.DistributionLogNormal_swigregister(DistributionLogNormal)
class DistributionCosine(Distribution1D):
    r""" Cosine distribution."""

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

    def __init__(self, mean, sigma, n_samples=25):
        r"""__init__(DistributionCosine self, double mean, double sigma, size_t n_samples=25) -> DistributionCosine"""
        _libBornAgainBase.DistributionCosine_swiginit(self, _libBornAgainBase.new_DistributionCosine(mean, sigma, n_samples))

    def distributionSamples(self):
        r"""distributionSamples(DistributionCosine self) -> vector_parsample_t"""
        return _libBornAgainBase.DistributionCosine_distributionSamples(self)
    __swig_destroy__ = _libBornAgainBase.delete_DistributionCosine

# Register DistributionCosine in _libBornAgainBase:
_libBornAgainBase.DistributionCosine_swigregister(DistributionCosine)
class ParameterDistribution(object):
    r""" A parametric distribution function, for use with any model parameter."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    _None = _libBornAgainBase.ParameterDistribution__None
    
    BeamWavelength = _libBornAgainBase.ParameterDistribution_BeamWavelength
    
    BeamGrazingAngle = _libBornAgainBase.ParameterDistribution_BeamGrazingAngle
    
    BeamAzimuthalAngle = _libBornAgainBase.ParameterDistribution_BeamAzimuthalAngle
    

    def __init__(self, *args):
        r"""
        __init__(ParameterDistribution self, ParameterDistribution::WhichParameter whichParameter, Distribution1D distribution) -> ParameterDistribution
        __init__(ParameterDistribution self, ParameterDistribution other) -> ParameterDistribution
        """
        _libBornAgainBase.ParameterDistribution_swiginit(self, _libBornAgainBase.new_ParameterDistribution(*args))
    __swig_destroy__ = _libBornAgainBase.delete_ParameterDistribution

# Register ParameterDistribution in _libBornAgainBase:
_libBornAgainBase.ParameterDistribution_swigregister(ParameterDistribution)
class R3(object):
    r""" Three-dimensional vector class, templated on base type. Base type T can be int, double, or complex<double>. The resulting classes shall be abbreviated I3, R3, C3."""

    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"""
        *Overload 1:*
        Constructs a vector from cartesian components.

        |

        *Overload 2:*
        Constructs the null vector.
        """
        _libBornAgainBase.R3_swiginit(self, _libBornAgainBase.new_R3(*args))

    def x(self):
        r""" Returns x-component in cartesian coordinate system."""
        return _libBornAgainBase.R3_x(self)

    def y(self):
        r""" Returns y-component in cartesian coordinate system."""
        return _libBornAgainBase.R3_y(self)

    def z(self):
        r""" Returns z-component in cartesian coordinate system."""
        return _libBornAgainBase.R3_z(self)

    def setX(self, a):
        r""" Sets x-component in cartesian coordinate system."""
        return _libBornAgainBase.R3_setX(self, a)

    def setY(self, a):
        r""" Sets y-component in cartesian coordinate system."""
        return _libBornAgainBase.R3_setY(self, a)

    def setZ(self, a):
        r""" Sets z-component in cartesian coordinate system."""
        return _libBornAgainBase.R3_setZ(self, a)

    def __iadd__(self, v):
        r""" Adds other vector to this, and returns result."""
        return _libBornAgainBase.R3___iadd__(self, v)

    def __isub__(self, v):
        r""" Subtracts other vector from this, and returns result."""
        return _libBornAgainBase.R3___isub__(self, v)

    def conj(self):
        r""" Returns complex conjugate vector"""
        return _libBornAgainBase.R3_conj(self)

    def mag2(self):
        r""" Returns magnitude squared of the vector."""
        return _libBornAgainBase.R3_mag2(self)

    def analytic_square(self):
        r""" Returns bilinear square q·q = qx² + qy² + qz² (no conjugation). This is the analytic continuation of |q|² for complex wavevectors. For form and structure factors, use this instead of mag2(). See Wuttke, J. Appl. Cryst. (2026), eq. (8)."""
        return _libBornAgainBase.R3_analytic_square(self)

    def mag(self):
        r""" Returns magnitude of the vector."""
        return _libBornAgainBase.R3_mag(self)

    def magxy2(self):
        r""" Returns squared distance from z axis."""
        return _libBornAgainBase.R3_magxy2(self)

    def analytic_square_xy(self):
        r""" Returns bilinear square of in-plane component: qx² + qy² (no conjugation). This is the analytic continuation for cylindrically symmetric form factors. See Wuttke, J. Appl. Cryst. (2026), eq. (13)."""
        return _libBornAgainBase.R3_analytic_square_xy(self)

    def magxy(self):
        r""" Returns distance from z axis."""
        return _libBornAgainBase.R3_magxy(self)

    def unit_or_throw(self):
        r""" Returns unit vector in direction of this. Throws if length is zero."""
        return _libBornAgainBase.R3_unit_or_throw(self)

    def unit_or_null(self):
        r""" Returns unit vector in direction of this. Returns null vector if length is zero."""
        return _libBornAgainBase.R3_unit_or_null(self)

    def complex(self):
        r""" Returns this, trivially converted to complex type."""
        return _libBornAgainBase.R3_complex(self)

    def real(self):
        r""" Returns real parts."""
        return _libBornAgainBase.R3_real(self)

    def __eq__(self, other):
        r"""__eq__(R3 self, R3 other) -> bool"""
        return _libBornAgainBase.R3___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(R3 self, R3 other) -> bool"""
        return _libBornAgainBase.R3___ne__(self, other)

    def rotatedY(self, a):
        r""" Returns result of rotation around y-axis."""
        return _libBornAgainBase.R3_rotatedY(self, a)

    def rotatedZ(self, a):
        r""" Returns result of rotation around z-axis."""
        return _libBornAgainBase.R3_rotatedZ(self, a)

    def __add__(self, rhs):
        r"""__add__(R3 self, R3 rhs) -> R3"""
        return _libBornAgainBase.R3___add__(self, rhs)

    def __mul__(self, c):
        r"""__mul__(R3 self, double c) -> R3"""
        return _libBornAgainBase.R3___mul__(self, c)

    def __rmul__(self, c):
        r"""__rmul__(R3 self, double c) -> R3"""
        return _libBornAgainBase.R3___rmul__(self, c)

    def __neg__(self):
        r"""__neg__(R3 self) -> R3"""
        return _libBornAgainBase.R3___neg__(self)
    __swig_destroy__ = _libBornAgainBase.delete_R3

# Register R3 in _libBornAgainBase:
_libBornAgainBase.R3_swigregister(R3)
class C3(object):
    r""" Three-dimensional vector class, templated on base type. Base type T can be int, double, or complex<double>. The resulting classes shall be abbreviated I3, R3, C3."""

    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"""
        *Overload 1:*
        Constructs a vector from cartesian components.

        |

        *Overload 2:*
        Constructs the null vector.
        """
        _libBornAgainBase.C3_swiginit(self, _libBornAgainBase.new_C3(*args))

    def x(self):
        r""" Returns x-component in cartesian coordinate system."""
        return _libBornAgainBase.C3_x(self)

    def y(self):
        r""" Returns y-component in cartesian coordinate system."""
        return _libBornAgainBase.C3_y(self)

    def z(self):
        r""" Returns z-component in cartesian coordinate system."""
        return _libBornAgainBase.C3_z(self)

    def setX(self, a):
        r""" Sets x-component in cartesian coordinate system."""
        return _libBornAgainBase.C3_setX(self, a)

    def setY(self, a):
        r""" Sets y-component in cartesian coordinate system."""
        return _libBornAgainBase.C3_setY(self, a)

    def setZ(self, a):
        r""" Sets z-component in cartesian coordinate system."""
        return _libBornAgainBase.C3_setZ(self, a)

    def __iadd__(self, v):
        r""" Adds other vector to this, and returns result."""
        return _libBornAgainBase.C3___iadd__(self, v)

    def __isub__(self, v):
        r""" Subtracts other vector from this, and returns result."""
        return _libBornAgainBase.C3___isub__(self, v)

    def conj(self):
        r""" Returns complex conjugate vector"""
        return _libBornAgainBase.C3_conj(self)

    def mag2(self):
        r""" Returns magnitude squared of the vector."""
        return _libBornAgainBase.C3_mag2(self)

    def analytic_square(self):
        r""" Returns bilinear square q·q = qx² + qy² + qz² (no conjugation). This is the analytic continuation of |q|² for complex wavevectors. For form and structure factors, use this instead of mag2(). See Wuttke, J. Appl. Cryst. (2026), eq. (8)."""
        return _libBornAgainBase.C3_analytic_square(self)

    def mag(self):
        r""" Returns magnitude of the vector."""
        return _libBornAgainBase.C3_mag(self)

    def magxy2(self):
        r""" Returns squared distance from z axis."""
        return _libBornAgainBase.C3_magxy2(self)

    def analytic_square_xy(self):
        r""" Returns bilinear square of in-plane component: qx² + qy² (no conjugation). This is the analytic continuation for cylindrically symmetric form factors. See Wuttke, J. Appl. Cryst. (2026), eq. (13)."""
        return _libBornAgainBase.C3_analytic_square_xy(self)

    def magxy(self):
        r""" Returns distance from z axis."""
        return _libBornAgainBase.C3_magxy(self)

    def unit_or_throw(self):
        r""" Returns unit vector in direction of this. Throws if length is zero."""
        return _libBornAgainBase.C3_unit_or_throw(self)

    def unit_or_null(self):
        r""" Returns unit vector in direction of this. Returns null vector if length is zero."""
        return _libBornAgainBase.C3_unit_or_null(self)

    def complex(self):
        r""" Returns this, trivially converted to complex type."""
        return _libBornAgainBase.C3_complex(self)

    def real(self):
        r""" Returns real parts."""
        return _libBornAgainBase.C3_real(self)

    def __eq__(self, other):
        r"""__eq__(C3 self, C3 other) -> bool"""
        return _libBornAgainBase.C3___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(C3 self, C3 other) -> bool"""
        return _libBornAgainBase.C3___ne__(self, other)

    def rotatedY(self, a):
        r""" Returns result of rotation around y-axis."""
        return _libBornAgainBase.C3_rotatedY(self, a)

    def rotatedZ(self, a):
        r""" Returns result of rotation around z-axis."""
        return _libBornAgainBase.C3_rotatedZ(self, a)
    __swig_destroy__ = _libBornAgainBase.delete_C3

# Register C3 in _libBornAgainBase:
_libBornAgainBase.C3_swigregister(C3)
class vector_R3(object):
    r"""Proxy of C++ std::vector< R3 > 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, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainBase.vector_R3___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_R3 self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, vector_R3 v)
        __setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * 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)

