libBornAgainBase.py

        """
        return _libBornAgainBase.R3_project(self, v)
    __swig_destroy__ = _libBornAgainBase.delete_R3

# Register R3 in _libBornAgainBase:
_libBornAgainBase.R3_swigregister(R3)

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

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

    def iterator(self):
        r"""iterator(vector_R3 self) -> SwigPyIterator"""
        return _libBornAgainBase.vector_R3_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_R3 self) -> bool"""
        return _libBornAgainBase.vector_R3___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_R3 self) -> bool"""
        return _libBornAgainBase.vector_R3___bool__(self)

    def __len__(self):
        r"""__len__(vector_R3 self) -> std::vector< BasicVector3D< double > >::size_type"""
        return _libBornAgainBase.vector_R3___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vector_R3 self, std::vector< BasicVector3D< double > >::difference_type i, std::vector< BasicVector3D< 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< BasicVector3D< double > >::difference_type i, std::vector< BasicVector3D< double > >::difference_type j)
        __setslice__(vector_R3 self, std::vector< BasicVector3D< double > >::difference_type i, std::vector< BasicVector3D< 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< BasicVector3D< double > >::difference_type i, std::vector< BasicVector3D< double > >::difference_type j)"""
        return _libBornAgainBase.vector_R3___delslice__(self, i, j)

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

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_R3 self, PySliceObject * slice) -> vector_R3
        __getitem__(vector_R3 self, std::vector< BasicVector3D< double > >::difference_type i) -> R3
        """
        return _libBornAgainBase.vector_R3___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_R3 self, PySliceObject * slice, vector_R3 v)
        __setitem__(vector_R3 self, PySliceObject * slice)
        __setitem__(vector_R3 self, std::vector< BasicVector3D< 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< BasicVector3D< 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< BasicVector3D< double > >::iterator"""
        return _libBornAgainBase.vector_R3_begin(self)

    def end(self):
        r"""end(vector_R3 self) -> std::vector< BasicVector3D< double > >::iterator"""
        return _libBornAgainBase.vector_R3_end(self)

    def rbegin(self):
        r"""rbegin(vector_R3 self) -> std::vector< BasicVector3D< double > >::reverse_iterator"""
        return _libBornAgainBase.vector_R3_rbegin(self)

    def rend(self):
        r"""rend(vector_R3 self) -> std::vector< BasicVector3D< 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< BasicVector3D< 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< BasicVector3D< double > >::iterator pos) -> std::vector< BasicVector3D< double > >::iterator
        erase(vector_R3 self, std::vector< BasicVector3D< double > >::iterator first, std::vector< BasicVector3D< double > >::iterator last) -> std::vector< BasicVector3D< 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< BasicVector3D< double > >::size_type size) -> vector_R3
        __init__(vector_R3 self, std::vector< BasicVector3D< 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< BasicVector3D< 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< BasicVector3D< double > >::size_type new_size)
        resize(vector_R3 self, std::vector< BasicVector3D< 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< BasicVector3D< double > >::iterator pos, R3 x) -> std::vector< BasicVector3D< double > >::iterator
        insert(vector_R3 self, std::vector< BasicVector3D< double > >::iterator pos, std::vector< BasicVector3D< double > >::size_type n, R3 x)
        """
        return _libBornAgainBase.vector_R3_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vector_R3 self, std::vector< BasicVector3D< double > >::size_type n)"""
        return _libBornAgainBase.vector_R3_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_R3 self) -> std::vector< BasicVector3D< double > >::size_type"""
        return _libBornAgainBase.vector_R3_capacity(self)
    __swig_destroy__ = _libBornAgainBase.delete_vector_R3

# Register vector_R3 in _libBornAgainBase:
_libBornAgainBase.vector_R3_swigregister(vector_R3)

class C3(object):
    r"""


    Three-dimensional vector template, for use with integer, double, or complex components.

    C++ includes: BasicVector3D.h

    """

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

    def __init__(self, *args):
        r"""
        __init__(C3 self) -> C3
        __init__(C3 self, std::complex< double > const x, std::complex< double > const y, std::complex< double > const z) -> C3
        BasicVector3D< T >::BasicVector3D(const T x, const T y, const T z)

        Constructs a vector from cartesian components. 

        """
        _libBornAgainBase.C3_swiginit(self, _libBornAgainBase.new_C3(*args))

    def x(self):
        r"""
        x(C3 self) -> std::complex< double >
        T BasicVector3D< T >::x() const

        Returns x-component in cartesian coordinate system. 

        """
        return _libBornAgainBase.C3_x(self)

    def y(self):
        r"""
        y(C3 self) -> std::complex< double >
        T BasicVector3D< T >::y() const

        Returns y-component in cartesian coordinate system. 

        """
        return _libBornAgainBase.C3_y(self)

    def z(self):
        r"""
        z(C3 self) -> std::complex< double >
        T BasicVector3D< T >::z() const

        Returns z-component in cartesian coordinate system. 

        """
        return _libBornAgainBase.C3_z(self)

    def setX(self, a):
        r"""
        setX(C3 self, std::complex< double > const & a)
        void BasicVector3D< T >::setX(const T &a)

        Sets x-component in cartesian coordinate system. 

        """
        return _libBornAgainBase.C3_setX(self, a)

    def setY(self, a):
        r"""
        setY(C3 self, std::complex< double > const & a)
        void BasicVector3D< T >::setY(const T &a)

        Sets y-component in cartesian coordinate system. 

        """
        return _libBornAgainBase.C3_setY(self, a)

    def setZ(self, a):
        r"""
        setZ(C3 self, std::complex< double > const & a)
        void BasicVector3D< T >::setZ(const T &a)

        Sets z-component in cartesian coordinate system. 

        """
        return _libBornAgainBase.C3_setZ(self, a)

    def __iadd__(self, v):
        r"""__iadd__(C3 self, C3 v) -> C3"""
        return _libBornAgainBase.C3___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(C3 self, C3 v) -> C3"""
        return _libBornAgainBase.C3___isub__(self, v)

    def conj(self):
        r"""
        conj(C3 self) -> C3
        BasicVector3D<T> BasicVector3D< T >::conj() const

        Returns complex conjugate vector. 

        """
        return _libBornAgainBase.C3_conj(self)

    def mag2(self):
        r"""
        mag2(C3 self) -> double
        double BasicVector3D< T >::mag2() const

        Returns magnitude squared of the vector. 

        """
        return _libBornAgainBase.C3_mag2(self)

    def mag(self):
        r"""
        mag(C3 self) -> double
        double BasicVector3D< T >::mag() const

        Returns magnitude of the vector. 

        """
        return _libBornAgainBase.C3_mag(self)

    def magxy2(self):
        r"""
        magxy2(C3 self) -> double
        double BasicVector3D< T >::magxy2() const

        Returns squared distance from z axis. 

        """
        return _libBornAgainBase.C3_magxy2(self)

    def magxy(self):
        r"""
        magxy(C3 self) -> double
        double BasicVector3D< T >::magxy() const

        Returns distance from z axis. 

        """
        return _libBornAgainBase.C3_magxy(self)

    def unit(self):
        r"""
        unit(C3 self) -> C3
        BasicVector3D<T> BasicVector3D< T >::unit() const

        Returns unit vector in direction of this. Throws for null vector. 

        """
        return _libBornAgainBase.C3_unit(self)

    def real(self):
        r"""
        real(C3 self) -> R3
        BasicVector3D<double> BasicVector3D< T >::real() const

        Returns real parts. 

        """
        return _libBornAgainBase.C3_real(self)

    def project(self, v):
        r"""
        project(C3 self, C3 v) -> C3
        BasicVector3D<T> BasicVector3D< T >::project(const BasicVector3D< T > &v) const

        Returns projection of this onto other vector: (this*v)*v/|v|^2. 

        """
        return _libBornAgainBase.C3_project(self, v)
    __swig_destroy__ = _libBornAgainBase.delete_C3

# Register C3 in _libBornAgainBase:
_libBornAgainBase.C3_swigregister(C3)

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

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

    def iterator(self):
        r"""iterator(vector_C3 self) -> SwigPyIterator"""
        return _libBornAgainBase.vector_C3_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_C3 self) -> bool"""
        return _libBornAgainBase.vector_C3___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_C3 self) -> bool"""
        return _libBornAgainBase.vector_C3___bool__(self)

    def __len__(self):
        r"""__len__(vector_C3 self) -> std::vector< BasicVector3D< std::complex< double > > >::size_type"""
        return _libBornAgainBase.vector_C3___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i, std::vector< BasicVector3D< std::complex< double > > >::difference_type j) -> vector_C3"""
        return _libBornAgainBase.vector_C3___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i, std::vector< BasicVector3D< std::complex< double > > >::difference_type j)
        __setslice__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i, std::vector< BasicVector3D< std::complex< double > > >::difference_type j, vector_C3 v)
        """
        return _libBornAgainBase.vector_C3___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i, std::vector< BasicVector3D< std::complex< double > > >::difference_type j)"""
        return _libBornAgainBase.vector_C3___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i)
        __delitem__(vector_C3 self, PySliceObject * slice)
        """
        return _libBornAgainBase.vector_C3___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_C3 self, PySliceObject * slice) -> vector_C3
        __getitem__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i) -> C3
        """
        return _libBornAgainBase.vector_C3___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_C3 self, PySliceObject * slice, vector_C3 v)
        __setitem__(vector_C3 self, PySliceObject * slice)
        __setitem__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i, C3 x)
        """
        return _libBornAgainBase.vector_C3___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_C3 self) -> C3"""
        return _libBornAgainBase.vector_C3_pop(self)

    def append(self, x):
        r"""append(vector_C3 self, C3 x)"""
        return _libBornAgainBase.vector_C3_append(self, x)

    def empty(self):
        r"""empty(vector_C3 self) -> bool"""
        return _libBornAgainBase.vector_C3_empty(self)

    def size(self):
        r"""size(vector_C3 self) -> std::vector< BasicVector3D< std::complex< double > > >::size_type"""
        return _libBornAgainBase.vector_C3_size(self)

    def swap(self, v):
        r"""swap(vector_C3 self, vector_C3 v)"""
        return _libBornAgainBase.vector_C3_swap(self, v)

    def begin(self):
        r"""begin(vector_C3 self) -> std::vector< BasicVector3D< std::complex< double > > >::iterator"""
        return _libBornAgainBase.vector_C3_begin(self)

    def end(self):
        r"""end(vector_C3 self) -> std::vector< BasicVector3D< std::complex< double > > >::iterator"""
        return _libBornAgainBase.vector_C3_end(self)

    def rbegin(self):
        r"""rbegin(vector_C3 self) -> std::vector< BasicVector3D< std::complex< double > > >::reverse_iterator"""
        return _libBornAgainBase.vector_C3_rbegin(self)

    def rend(self):
        r"""rend(vector_C3 self) -> std::vector< BasicVector3D< std::complex< double > > >::reverse_iterator"""
        return _libBornAgainBase.vector_C3_rend(self)

    def clear(self):
        r"""clear(vector_C3 self)"""
        return _libBornAgainBase.vector_C3_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_C3 self) -> std::vector< BasicVector3D< std::complex< double > > >::allocator_type"""
        return _libBornAgainBase.vector_C3_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_C3 self)"""
        return _libBornAgainBase.vector_C3_pop_back(self)

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

    def __init__(self, *args):
        r"""
        __init__(vector_C3 self) -> vector_C3
        __init__(vector_C3 self, vector_C3 other) -> vector_C3
        __init__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::size_type size) -> vector_C3
        __init__(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::size_type size, C3 value) -> vector_C3
        """
        _libBornAgainBase.vector_C3_swiginit(self, _libBornAgainBase.new_vector_C3(*args))

    def push_back(self, x):
        r"""push_back(vector_C3 self, C3 x)"""
        return _libBornAgainBase.vector_C3_push_back(self, x)

    def front(self):
        r"""front(vector_C3 self) -> C3"""
        return _libBornAgainBase.vector_C3_front(self)

    def back(self):
        r"""back(vector_C3 self) -> C3"""
        return _libBornAgainBase.vector_C3_back(self)

    def assign(self, n, x):
        r"""assign(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::size_type n, C3 x)"""
        return _libBornAgainBase.vector_C3_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::size_type new_size)
        resize(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::size_type new_size, C3 x)
        """
        return _libBornAgainBase.vector_C3_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::iterator pos, C3 x) -> std::vector< BasicVector3D< std::complex< double > > >::iterator
        insert(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::iterator pos, std::vector< BasicVector3D< std::complex< double > > >::size_type n, C3 x)
        """
        return _libBornAgainBase.vector_C3_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vector_C3 self, std::vector< BasicVector3D< std::complex< double > > >::size_type n)"""
        return _libBornAgainBase.vector_C3_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_C3 self) -> std::vector< BasicVector3D< std::complex< double > > >::size_type"""
        return _libBornAgainBase.vector_C3_capacity(self)
    __swig_destroy__ = _libBornAgainBase.delete_vector_C3

# Register vector_C3 in _libBornAgainBase:
_libBornAgainBase.vector_C3_swigregister(vector_C3)