libBornAgainBase.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

import _libBornAgainBase

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


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


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


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


import weakref

class SwigPyIterator(object):
    r"""Proxy of C++ swig::SwigPyIterator class."""

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

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

    def value(self):
        r"""value(SwigPyIterator self) -> PyObject *"""
        return _libBornAgainBase.SwigPyIterator_value(self)

    def incr(self, n=1):
        r"""incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _libBornAgainBase.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        r"""decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _libBornAgainBase.SwigPyIterator_decr(self, n)

    def distance(self, x):
        r"""distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _libBornAgainBase.SwigPyIterator_distance(self, x)

    def equal(self, x):
        r"""equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _libBornAgainBase.SwigPyIterator_equal(self, x)

    def copy(self):
        r"""copy(SwigPyIterator self) -> SwigPyIterator"""
        return _libBornAgainBase.SwigPyIterator_copy(self)

    def next(self):
        r"""next(SwigPyIterator self) -> PyObject *"""
        return _libBornAgainBase.SwigPyIterator_next(self)

    def __next__(self):
        r"""__next__(SwigPyIterator self) -> PyObject *"""
        return _libBornAgainBase.SwigPyIterator___next__(self)

    def previous(self):
        r"""previous(SwigPyIterator self) -> PyObject *"""
        return _libBornAgainBase.SwigPyIterator_previous(self)

    def advance(self, n):
        r"""advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _libBornAgainBase.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        r"""__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _libBornAgainBase.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        r"""__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _libBornAgainBase.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        r"""__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _libBornAgainBase.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        r"""__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _libBornAgainBase.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        r"""__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _libBornAgainBase.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        r"""
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _libBornAgainBase.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

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

SHARED_PTR_DISOWN = _libBornAgainBase.SHARED_PTR_DISOWN

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

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

    def iterator(self):
        r"""iterator(vdouble1d_t self) -> SwigPyIterator"""
        return _libBornAgainBase.vdouble1d_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vdouble1d_t self) -> bool"""
        return _libBornAgainBase.vdouble1d_t___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vdouble1d_t self) -> bool"""
        return _libBornAgainBase.vdouble1d_t___bool__(self)

    def __len__(self):
        r"""__len__(vdouble1d_t self) -> std::vector< double >::size_type"""
        return _libBornAgainBase.vdouble1d_t___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> vdouble1d_t"""
        return _libBornAgainBase.vdouble1d_t___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
        __setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, vdouble1d_t v)
        """
        return _libBornAgainBase.vdouble1d_t___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _libBornAgainBase.vdouble1d_t___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vdouble1d_t self, std::vector< double >::difference_type i)
        __delitem__(vdouble1d_t self, PySliceObject * slice)
        """
        return _libBornAgainBase.vdouble1d_t___delitem__(self, *args)

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

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

    def pop(self):
        r"""pop(vdouble1d_t self) -> std::vector< double >::value_type"""
        return _libBornAgainBase.vdouble1d_t_pop(self)

    def append(self, x):
        r"""append(vdouble1d_t self, std::vector< double >::value_type const & x)"""
        return _libBornAgainBase.vdouble1d_t_append(self, x)

    def empty(self):
        r"""empty(vdouble1d_t self) -> bool"""
        return _libBornAgainBase.vdouble1d_t_empty(self)

    def size(self):
        r"""size(vdouble1d_t self) -> std::vector< double >::size_type"""
        return _libBornAgainBase.vdouble1d_t_size(self)

    def swap(self, v):
        r"""swap(vdouble1d_t self, vdouble1d_t v)"""
        return _libBornAgainBase.vdouble1d_t_swap(self, v)

    def begin(self):
        r"""begin(vdouble1d_t self) -> std::vector< double >::iterator"""
        return _libBornAgainBase.vdouble1d_t_begin(self)

    def end(self):
        r"""end(vdouble1d_t self) -> std::vector< double >::iterator"""
        return _libBornAgainBase.vdouble1d_t_end(self)

    def rbegin(self):
        r"""rbegin(vdouble1d_t self) -> std::vector< double >::reverse_iterator"""
        return _libBornAgainBase.vdouble1d_t_rbegin(self)

    def rend(self):
        r"""rend(vdouble1d_t self) -> std::vector< double >::reverse_iterator"""
        return _libBornAgainBase.vdouble1d_t_rend(self)

    def clear(self):
        r"""clear(vdouble1d_t self)"""
        return _libBornAgainBase.vdouble1d_t_clear(self)

    def get_allocator(self):
        r"""get_allocator(vdouble1d_t self) -> std::vector< double >::allocator_type"""
        return _libBornAgainBase.vdouble1d_t_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vdouble1d_t self)"""
        return _libBornAgainBase.vdouble1d_t_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vdouble1d_t self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
        erase(vdouble1d_t self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
        """
        return _libBornAgainBase.vdouble1d_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vdouble1d_t self) -> vdouble1d_t
        __init__(vdouble1d_t self, vdouble1d_t other) -> vdouble1d_t
        __init__(vdouble1d_t self, std::vector< double >::size_type size) -> vdouble1d_t
        __init__(vdouble1d_t self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> vdouble1d_t
        """
        _libBornAgainBase.vdouble1d_t_swiginit(self, _libBornAgainBase.new_vdouble1d_t(*args))

    def push_back(self, x):
        r"""push_back(vdouble1d_t self, std::vector< double >::value_type const & x)"""
        return _libBornAgainBase.vdouble1d_t_push_back(self, x)

    def front(self):
        r"""front(vdouble1d_t self) -> std::vector< double >::value_type const &"""
        return _libBornAgainBase.vdouble1d_t_front(self)

    def back(self):
        r"""back(vdouble1d_t self) -> std::vector< double >::value_type const &"""
        return _libBornAgainBase.vdouble1d_t_back(self)

    def assign(self, n, x):
        r"""assign(vdouble1d_t self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _libBornAgainBase.vdouble1d_t_assign(self, n, x)

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

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

    def reserve(self, n):
        r"""reserve(vdouble1d_t self, std::vector< double >::size_type n)"""
        return _libBornAgainBase.vdouble1d_t_reserve(self, n)

    def capacity(self):
        r"""capacity(vdouble1d_t self) -> std::vector< double >::size_type"""
        return _libBornAgainBase.vdouble1d_t_capacity(self)
    __swig_destroy__ = _libBornAgainBase.delete_vdouble1d_t

# Register vdouble1d_t in _libBornAgainBase:
_libBornAgainBase.vdouble1d_t_swigregister(vdouble1d_t)

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

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

    def iterator(self):
        r"""iterator(vdouble2d_t self) -> SwigPyIterator"""
        return _libBornAgainBase.vdouble2d_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vdouble2d_t self) -> bool"""
        return _libBornAgainBase.vdouble2d_t___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vdouble2d_t self) -> bool"""
        return _libBornAgainBase.vdouble2d_t___bool__(self)

    def __len__(self):
        r"""__len__(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"""
        return _libBornAgainBase.vdouble2d_t___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j) -> vdouble2d_t"""
        return _libBornAgainBase.vdouble2d_t___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)
        __setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, vdouble2d_t v)
        """
        return _libBornAgainBase.vdouble2d_t___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"""
        return _libBornAgainBase.vdouble2d_t___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)
        __delitem__(vdouble2d_t self, PySliceObject * slice)
        """
        return _libBornAgainBase.vdouble2d_t___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t
        __getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t
        """
        return _libBornAgainBase.vdouble2d_t___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)
        __setitem__(vdouble2d_t self, PySliceObject * slice)
        __setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)
        """
        return _libBornAgainBase.vdouble2d_t___setitem__(self, *args)

    def pop(self):
        r"""pop(vdouble2d_t self) -> vdouble1d_t"""
        return _libBornAgainBase.vdouble2d_t_pop(self)

    def append(self, x):
        r"""append(vdouble2d_t self, vdouble1d_t x)"""
        return _libBornAgainBase.vdouble2d_t_append(self, x)

    def empty(self):
        r"""empty(vdouble2d_t self) -> bool"""
        return _libBornAgainBase.vdouble2d_t_empty(self)

    def size(self):
        r"""size(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"""
        return _libBornAgainBase.vdouble2d_t_size(self)

    def swap(self, v):
        r"""swap(vdouble2d_t self, vdouble2d_t v)"""
        return _libBornAgainBase.vdouble2d_t_swap(self, v)

    def begin(self):
        r"""begin(vdouble2d_t self) -> std::vector< std::vector< double > >::iterator"""
        return _libBornAgainBase.vdouble2d_t_begin(self)

    def end(self):
        r"""end(vdouble2d_t self) -> std::vector< std::vector< double > >::iterator"""
        return _libBornAgainBase.vdouble2d_t_end(self)

    def rbegin(self):
        r"""rbegin(vdouble2d_t self) -> std::vector< std::vector< double > >::reverse_iterator"""
        return _libBornAgainBase.vdouble2d_t_rbegin(self)

    def rend(self):
        r"""rend(vdouble2d_t self) -> std::vector< std::vector< double > >::reverse_iterator"""
        return _libBornAgainBase.vdouble2d_t_rend(self)

    def clear(self):
        r"""clear(vdouble2d_t self)"""
        return _libBornAgainBase.vdouble2d_t_clear(self)

    def get_allocator(self):
        r"""get_allocator(vdouble2d_t self) -> std::vector< std::vector< double > >::allocator_type"""
        return _libBornAgainBase.vdouble2d_t_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vdouble2d_t self)"""
        return _libBornAgainBase.vdouble2d_t_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vdouble2d_t self, std::vector< std::vector< double > >::iterator pos) -> std::vector< std::vector< double > >::iterator
        erase(vdouble2d_t self, std::vector< std::vector< double > >::iterator first, std::vector< std::vector< double > >::iterator last) -> std::vector< std::vector< double > >::iterator
        """
        return _libBornAgainBase.vdouble2d_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vdouble2d_t self) -> vdouble2d_t
        __init__(vdouble2d_t self, vdouble2d_t other) -> vdouble2d_t
        __init__(vdouble2d_t self, std::vector< std::vector< double > >::size_type size) -> vdouble2d_t
        __init__(vdouble2d_t self, std::vector< std::vector< double > >::size_type size, vdouble1d_t value) -> vdouble2d_t
        """
        _libBornAgainBase.vdouble2d_t_swiginit(self, _libBornAgainBase.new_vdouble2d_t(*args))

    def push_back(self, x):
        r"""push_back(vdouble2d_t self, vdouble1d_t x)"""
        return _libBornAgainBase.vdouble2d_t_push_back(self, x)

    def front(self):
        r"""front(vdouble2d_t self) -> vdouble1d_t"""
        return _libBornAgainBase.vdouble2d_t_front(self)

    def back(self):
        r"""back(vdouble2d_t self) -> vdouble1d_t"""
        return _libBornAgainBase.vdouble2d_t_back(self)

    def assign(self, n, x):
        r"""assign(vdouble2d_t self, std::vector< std::vector< double > >::size_type n, vdouble1d_t x)"""
        return _libBornAgainBase.vdouble2d_t_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vdouble2d_t self, std::vector< std::vector< double > >::size_type new_size)
        resize(vdouble2d_t self, std::vector< std::vector< double > >::size_type new_size, vdouble1d_t x)
        """
        return _libBornAgainBase.vdouble2d_t_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vdouble2d_t self, std::vector< std::vector< double > >::iterator pos, vdouble1d_t x) -> std::vector< std::vector< double > >::iterator
        insert(vdouble2d_t self, std::vector< std::vector< double > >::iterator pos, std::vector< std::vector< double > >::size_type n, vdouble1d_t x)
        """
        return _libBornAgainBase.vdouble2d_t_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vdouble2d_t self, std::vector< std::vector< double > >::size_type n)"""
        return _libBornAgainBase.vdouble2d_t_reserve(self, n)

    def capacity(self):
        r"""capacity(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"""
        return _libBornAgainBase.vdouble2d_t_capacity(self)
    __swig_destroy__ = _libBornAgainBase.delete_vdouble2d_t

# Register vdouble2d_t in _libBornAgainBase:
_libBornAgainBase.vdouble2d_t_swigregister(vdouble2d_t)

class ICloneable(object):
    r"""


    Interface for polymorphic classes that should not be copied, except by explicit cloning.

    Child classes of  ICloneable must provide clone().

    C++ includes: ICloneable.h

    """

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

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

    def clone(self):
        r"""
        clone(ICloneable self) -> ICloneable
        virtual ICloneable* ICloneable::clone() const =0

        """
        return _libBornAgainBase.ICloneable_clone(self)

    def transferToCPP(self):
        r"""
        transferToCPP(ICloneable self)
        virtual void ICloneable::transferToCPP()

        Used for Python overriding of clone (see swig/tweaks.py) 

        """
        return self.__disown__()

# Register ICloneable in _libBornAgainBase:
_libBornAgainBase.ICloneable_swigregister(ICloneable)


def mul_I(z):
    r"""
    mul_I(complex_t z) -> complex_t
    complex_t mul_I(complex_t z)

    Returns product I*z, where I is the imaginary unit. 

    """
    return _libBornAgainBase.mul_I(z)

def exp_I(z):
    r"""
    exp_I(complex_t z) -> complex_t
    complex_t exp_I(complex_t z)

    Returns exp(I*z), where I is the imaginary unit. 

    """
    return _libBornAgainBase.exp_I(z)

def rad2deg(angle):
    r"""
    rad2deg(double angle) -> double
    double Units::rad2deg(double angle)

    """
    return _libBornAgainBase.rad2deg(angle)

def deg2rad(angle):
    r"""
    deg2rad(double angle) -> double
    double Units::deg2rad(double angle)

    """
    return _libBornAgainBase.deg2rad(angle)

def StandardNormal(x):
    r"""
    StandardNormal(double x) -> double
    double MathFunctions::StandardNormal(double x)

    """
    return _libBornAgainBase.StandardNormal(x)

def Gaussian(x, average, std_dev):
    r"""
    Gaussian(double x, double average, double std_dev) -> double
    double MathFunctions::Gaussian(double x, double average, double std_dev)

    """
    return _libBornAgainBase.Gaussian(x, average, std_dev)

def IntegratedGaussian(x, average, std_dev):
    r"""
    IntegratedGaussian(double x, double average, double std_dev) -> double
    double MathFunctions::IntegratedGaussian(double x, double average, double std_dev)

    """
    return _libBornAgainBase.IntegratedGaussian(x, average, std_dev)

def cot(x):
    r"""
    cot(double x) -> double
    double MathFunctions::cot(double x)

    cotangent function:  $cot(x)\\equiv1/tan(x)$

    """
    return _libBornAgainBase.cot(x)

def Si(x):
    r"""
    Si(double x) -> double
    double MathFunctions::Si(double x)

    Sine integral function:  $Si(x)\\equiv\\int_0^x du \\sin(u)/u$. 

    """
    return _libBornAgainBase.Si(x)

def sinc(*args):
    r"""
    sinc(double x) -> double
    sinc(complex_t const z) -> complex_t
    complex_t MathFunctions::sinc(const complex_t z)

    Complex sinc function:  $sinc(x)\\equiv\\sin(x)/x$. 

    """
    return _libBornAgainBase.sinc(*args)

def tanhc(z):
    r"""
    tanhc(complex_t const z) -> complex_t
    complex_t MathFunctions::tanhc(const complex_t z)

    Complex tanhc function:  $tanhc(x)\\equiv\\tanh(x)/x$. 

    """
    return _libBornAgainBase.tanhc(z)

def Laue(x, N):
    r"""
    Laue(double const x, size_t N) -> double
    double MathFunctions::Laue(const double x, size_t N)

    Real Laue function:  $Laue(x,N)\\equiv\\sin(Nx)/sin(x)$. 

    """
    return _libBornAgainBase.Laue(x, N)

def erf(arg):
    r"""
    erf(double arg) -> double
    double MathFunctions::erf(double arg)

    Error function of real-valued argument. 

    """
    return _libBornAgainBase.erf(arg)

def Bessel_I0(x):
    r"""
    Bessel_I0(double x) -> double
    double MathFunctions::Bessel_I0(double x)

    Modified Bessel function of the first kind and order 0. 

    """
    return _libBornAgainBase.Bessel_I0(x)

def Bessel_J0(*args):
    r"""
    Bessel_J0(double x) -> double
    Bessel_J0(complex_t const z) -> complex_t
    complex_t MathFunctions::Bessel_J0(const complex_t z)

    Complex Bessel function of the first kind and order 0. 

    """
    return _libBornAgainBase.Bessel_J0(*args)

def Bessel_J1(*args):
    r"""
    Bessel_J1(double x) -> double
    Bessel_J1(complex_t const z) -> complex_t
    complex_t MathFunctions::Bessel_J1(const complex_t z)

    Complex Bessel function of the first kind and order 1. 

    """
    return _libBornAgainBase.Bessel_J1(*args)

def Bessel_J1c(*args):
    r"""
    Bessel_J1c(double x) -> double
    Bessel_J1c(complex_t const z) -> complex_t
    complex_t MathFunctions::Bessel_J1c(const complex_t z)

    Complex Bessel function Bessel_J1(x)/x. 

    """
    return _libBornAgainBase.Bessel_J1c(*args)
FORWARD_FFT = _libBornAgainBase.FORWARD_FFT

BACKWARD_FFT = _libBornAgainBase.BACKWARD_FFT


def FastFourierTransform(*args):
    r"""
    FastFourierTransform(std::vector< complex_t,std::allocator< complex_t > > const & data, MathFunctions::EFFTDirection tcase) -> std::vector< complex_t,std::allocator< complex_t > >
    FastFourierTransform(vdouble1d_t data, MathFunctions::EFFTDirection tcase) -> std::vector< complex_t,std::allocator< complex_t > >
    std::vector< complex_t > MathFunctions::FastFourierTransform(const std::vector< double > &data, EFFTDirection tcase)

    simple (and unoptimized) wrapper function for the discrete fast Fourier transformation library (fftw3); transforms real to complex 

    """
    return _libBornAgainBase.FastFourierTransform(*args)

def ConvolveFFT(signal, resfunc):
    r"""
    ConvolveFFT(vdouble1d_t signal, vdouble1d_t resfunc) -> std::vector< complex_t,std::allocator< complex_t > >
    std::vector< complex_t > MathFunctions::ConvolveFFT(const std::vector< double > &signal, const std::vector< double > &resfunc)

    convolution of two real vectors of equal size 

    """
    return _libBornAgainBase.ConvolveFFT(signal, resfunc)

def GenerateUniformRandom():
    r"""
    GenerateUniformRandom() -> double
    double MathFunctions::GenerateUniformRandom()

    """
    return _libBornAgainBase.GenerateUniformRandom()

def GenerateStandardNormalRandom():
    r"""
    GenerateStandardNormalRandom() -> double
    double MathFunctions::GenerateStandardNormalRandom()

    """
    return _libBornAgainBase.GenerateStandardNormalRandom()

def GenerateNormalRandom(average, std_dev):
    r"""
    GenerateNormalRandom(double average, double std_dev) -> double
    double MathFunctions::GenerateNormalRandom(double average, double std_dev)

    """
    return _libBornAgainBase.GenerateNormalRandom(average, std_dev)

def GeneratePoissonRandom(average):
    r"""
    GeneratePoissonRandom(double average) -> double
    double MathFunctions::GeneratePoissonRandom(double average)

    """
    return _libBornAgainBase.GeneratePoissonRandom(average)
class ThreadInfo(object):
    r"""


    Information to run simulation with dedicated number of threads.

    C++ includes: ThreadInfo.h

    """

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

    def __init__(self):
        r"""
        __init__(ThreadInfo self) -> ThreadInfo
        ThreadInfo::ThreadInfo()

        """
        _libBornAgainBase.ThreadInfo_swiginit(self, _libBornAgainBase.new_ThreadInfo())
    n_threads = property(_libBornAgainBase.ThreadInfo_n_threads_get, _libBornAgainBase.ThreadInfo_n_threads_set, doc=r"""n_threads : unsigned int""")
    n_batches = property(_libBornAgainBase.ThreadInfo_n_batches_get, _libBornAgainBase.ThreadInfo_n_batches_set, doc=r"""n_batches : unsigned int""")
    current_batch = property(_libBornAgainBase.ThreadInfo_current_batch_get, _libBornAgainBase.ThreadInfo_current_batch_set, doc=r"""current_batch : unsigned int""")
    __swig_destroy__ = _libBornAgainBase.delete_ThreadInfo

# Register ThreadInfo in _libBornAgainBase:
_libBornAgainBase.ThreadInfo_swigregister(ThreadInfo)
cvar = _libBornAgainBase.cvar
I = cvar.I
nanometer = cvar.nanometer
angstrom = cvar.angstrom
micrometer = cvar.micrometer
millimeter = cvar.millimeter
meter = cvar.meter
nm = cvar.nm
nm2 = cvar.nm2
barn = cvar.barn
radian = cvar.radian
milliradian = cvar.milliradian
degree = cvar.degree
steradian = cvar.steradian
rad = cvar.rad
mrad = cvar.mrad
sr = cvar.sr
deg = cvar.deg
tesla = cvar.tesla
gauss = cvar.gauss


def vecOfLambdaAlphaPhi(_lambda, _alpha, _phi):
    r"""
    vecOfLambdaAlphaPhi(double _lambda, double _alpha, double _phi) -> kvector_t
    BasicVector3D<double> vecOfLambdaAlphaPhi(double _lambda, double _alpha, double _phi)

    Creates a vector<double> as a wavevector with given wavelength and angles. Specifically needed for grazing-incidence scattering. 

    """
    return _libBornAgainBase.vecOfLambdaAlphaPhi(_lambda, _alpha, _phi)
class Bin1D(object):
    r"""Proxy of C++ Bin1D class."""

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

    def __init__(self, *args):
        r"""
        __init__(Bin1D self) -> Bin1D
        __init__(Bin1D self, double lower, double upper) -> Bin1D
        Bin1D::Bin1D(double lower, double upper)

        """
        _libBornAgainBase.Bin1D_swiginit(self, _libBornAgainBase.new_Bin1D(*args))
    m_lower = property(_libBornAgainBase.Bin1D_m_lower_get, _libBornAgainBase.Bin1D_m_lower_set, doc=r"""m_lower : double""")
    m_upper = property(_libBornAgainBase.Bin1D_m_upper_get, _libBornAgainBase.Bin1D_m_upper_set, doc=r"""m_upper : double""")

    def getMidPoint(self):
        r"""
        getMidPoint(Bin1D self) -> double
        double Bin1D::getMidPoint() const

        """
        return _libBornAgainBase.Bin1D_getMidPoint(self)

    def getBinSize(self):
        r"""
        getBinSize(Bin1D self) -> double
        double Bin1D::getBinSize() const

        """
        return _libBornAgainBase.Bin1D_getBinSize(self)
    __swig_destroy__ = _libBornAgainBase.delete_Bin1D

# Register Bin1D in _libBornAgainBase:
_libBornAgainBase.Bin1D_swigregister(Bin1D)


def BinContains(bin, value):
    r"""
    BinContains(Bin1D bin, double value) -> bool
    bool BinContains(const Bin1D &bin, double value)

    Checks if value is contained in bin: value in [m_lower, m_upper) 

    """
    return _libBornAgainBase.BinContains(bin, value)
class Bin1DKVector(object):
    r"""


    An one-dimensional range of kvector_t's.

    C++ includes: Bin.h

    """

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

    def __init__(self, *args):
        r"""
        __init__(Bin1DKVector self) -> Bin1DKVector
        __init__(Bin1DKVector self, kvector_t lower, kvector_t upper) -> Bin1DKVector
        __init__(Bin1DKVector self, double wavelength, Bin1D alpha_bin, Bin1D phi_bin) -> Bin1DKVector
        Bin1DKVector::Bin1DKVector(double wavelength, const Bin1D &alpha_bin, const Bin1D &phi_bin)

        creation on  Bin1DKVector from alpha and phi bins 

        """
        _libBornAgainBase.Bin1DKVector_swiginit(self, _libBornAgainBase.new_Bin1DKVector(*args))

    def getMidPoint(self):
        r"""
        getMidPoint(Bin1DKVector self) -> kvector_t
        kvector_t Bin1DKVector::getMidPoint() const

        """
        return _libBornAgainBase.Bin1DKVector_getMidPoint(self)

    def getDelta(self):
        r"""
        getDelta(Bin1DKVector self) -> kvector_t
        kvector_t Bin1DKVector::getDelta() const

        """
        return _libBornAgainBase.Bin1DKVector_getDelta(self)
    m_q_lower = property(_libBornAgainBase.Bin1DKVector_m_q_lower_get, _libBornAgainBase.Bin1DKVector_m_q_lower_set, doc=r"""m_q_lower : kvector_t""")
    m_q_upper = property(_libBornAgainBase.Bin1DKVector_m_q_upper_get, _libBornAgainBase.Bin1DKVector_m_q_upper_set, doc=r"""m_q_upper : kvector_t""")
    __swig_destroy__ = _libBornAgainBase.delete_Bin1DKVector

# Register Bin1DKVector in _libBornAgainBase:
_libBornAgainBase.Bin1DKVector_swigregister(Bin1DKVector)

class Bin1DCVector(object):
    r"""


    An one-dimensional range of cvector_t's.

    C++ includes: Bin.h

    """

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

    def __init__(self, *args):
        r"""
        __init__(Bin1DCVector self) -> Bin1DCVector
        __init__(Bin1DCVector self, cvector_t lower, cvector_t upper) -> Bin1DCVector
        __init__(Bin1DCVector self, double wavelength, Bin1D alpha_bin, Bin1D phi_bin) -> Bin1DCVector
        Bin1DCVector::Bin1DCVector(double wavelength, const Bin1D &alpha_bin, const Bin1D &phi_bin)

        creation on  Bin1DCVector from alpha and phi bins 

        """
        _libBornAgainBase.Bin1DCVector_swiginit(self, _libBornAgainBase.new_Bin1DCVector(*args))

    def getMidPoint(self):
        r"""
        getMidPoint(Bin1DCVector self) -> cvector_t
        cvector_t Bin1DCVector::getMidPoint() const

        """
        return _libBornAgainBase.Bin1DCVector_getMidPoint(self)

    def getDelta(self):
        r"""
        getDelta(Bin1DCVector self) -> cvector_t
        cvector_t Bin1DCVector::getDelta() const

        """
        return _libBornAgainBase.Bin1DCVector_getDelta(self)
    m_q_lower = property(_libBornAgainBase.Bin1DCVector_m_q_lower_get, _libBornAgainBase.Bin1DCVector_m_q_lower_set, doc=r"""m_q_lower : cvector_t""")
    m_q_upper = property(_libBornAgainBase.Bin1DCVector_m_q_upper_get, _libBornAgainBase.Bin1DCVector_m_q_upper_set, doc=r"""m_q_upper : cvector_t""")
    __swig_destroy__ = _libBornAgainBase.delete_Bin1DCVector

# Register Bin1DCVector in _libBornAgainBase:
_libBornAgainBase.Bin1DCVector_swigregister(Bin1DCVector)

class IAxis(object):
    r"""


    Interface for one-dimensional axes.

    C++ includes: IAxis.h

    """

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

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

    def clone(self):
        r"""
        clone(IAxis self) -> IAxis
        virtual IAxis* IAxis::clone() const =0

        clone function 

        """
        return _libBornAgainBase.IAxis_clone(self)
    __swig_destroy__ = _libBornAgainBase.delete_IAxis

    def size(self):
        r"""
        size(IAxis self) -> size_t
        virtual size_t IAxis::size() const =0

        retrieve the number of bins 

        """
        return _libBornAgainBase.IAxis_size(self)

    def getName(self):
        r"""
        getName(IAxis self) -> std::string
        std::string IAxis::getName() const

        retrieve the label of the axis 

        """
        return _libBornAgainBase.IAxis_getName(self)

    def setName(self, name):
        r"""
        setName(IAxis self, std::string name)
        void IAxis::setName(std::string name)

        Sets the axis label. 

        """
        return _libBornAgainBase.IAxis_setName(self, name)

    def getBin(self, index):
        r"""
        getBin(IAxis self, size_t index) -> Bin1D
        virtual Bin1D IAxis::getBin(size_t index) const =0