From 4074f93aa4b3aed1da6f452d2b08e0ab714ed1b0 Mon Sep 17 00:00:00 2001
From: "Joachim Wuttke (h)" <j.wuttke@fz-juelich.de>
Date: Thu, 25 Nov 2021 19:36:01 +0100
Subject: [PATCH] BasicVector3D now inheriting from std::array
---
Base/Vector/BasicVector3D.h | 65 +-
Wrap/Swig/commons.i | 4 +
auto/Wrap/libBornAgainBase.py | 228 +-
auto/Wrap/libBornAgainBase_wrap.cpp | 3410 ++++++++++++++++++---
auto/Wrap/libBornAgainCore.py | 232 +-
auto/Wrap/libBornAgainCore_wrap.cpp | 3596 ++++++++++++++++++----
auto/Wrap/libBornAgainDevice.py | 232 +-
auto/Wrap/libBornAgainDevice_wrap.cpp | 3598 +++++++++++++++++++----
auto/Wrap/libBornAgainFit.py | 224 ++
auto/Wrap/libBornAgainFit_wrap.cpp | 3400 ++++++++++++++++++---
auto/Wrap/libBornAgainParam.py | 224 ++
auto/Wrap/libBornAgainParam_wrap.cpp | 3580 ++++++++++++++++++----
auto/Wrap/libBornAgainResample.py | 232 +-
auto/Wrap/libBornAgainResample_wrap.cpp | 3412 ++++++++++++++++++---
auto/Wrap/libBornAgainSample.py | 232 +-
auto/Wrap/libBornAgainSample_wrap.cpp | 3596 ++++++++++++++++++----
16 files changed, 22933 insertions(+), 3332 deletions(-)
diff --git a/Base/Vector/BasicVector3D.h b/Base/Vector/BasicVector3D.h
index 624f5c27ad8..20ac8d00e7c 100644
--- a/Base/Vector/BasicVector3D.h
+++ b/Base/Vector/BasicVector3D.h
@@ -20,12 +20,13 @@
#define BORNAGAIN_BASE_VECTOR_BASICVECTOR3D_H
#include "Base/Types/Complex.h"
+#include <array>
//! Three-dimensional vector template, for use with integer, double, or complex components.
-template <class T> class BasicVector3D {
+template <class T> class BasicVector3D : public std::array<T,3> {
private:
- T v_[3];
+ using super = std::array<T,3>;
public:
// -------------------------------------------------------------------------
@@ -33,34 +34,28 @@ public:
// -------------------------------------------------------------------------
//! Constructs the null vector.
- BasicVector3D() : v_{0., 0., 0.} {}
+ BasicVector3D() : super{0., 0., 0.} {}
//! Constructs a vector from cartesian components.
- BasicVector3D(const T x, const T y, const T z) : v_{x,y,z} {}
+ BasicVector3D(const T x, const T y, const T z) : super{x,y,z} {}
// -------------------------------------------------------------------------
// Component access
// -------------------------------------------------------------------------
- //! Returns component for given index.
- inline T operator[](int i) const { return v_[i]; }
-
- //! Returns component reference for given index.
- inline T& operator[](int i) { return v_[i]; }
-
//! Returns x-component in cartesian coordinate system.
- inline T x() const { return v_[0]; }
+ inline T x() const { return (*this)[0]; }
//! Returns y-component in cartesian coordinate system.
- inline T y() const { return v_[1]; }
+ inline T y() const { return (*this)[1]; }
//! Returns z-component in cartesian coordinate system.
- inline T z() const { return v_[2]; }
+ inline T z() const { return (*this)[2]; }
//! Sets x-component in cartesian coordinate system.
- void setX(const T& a) { v_[0] = a; }
+ void setX(const T& a) { (*this)[0] = a; }
//! Sets y-component in cartesian coordinate system.
- void setY(const T& a) { v_[1] = a; }
+ void setY(const T& a) { (*this)[1] = a; }
//! Sets z-component in cartesian coordinate system.
- void setZ(const T& a) { v_[2] = a; }
+ void setZ(const T& a) { (*this)[2] = a; }
// -------------------------------------------------------------------------
// In-place operations
@@ -69,18 +64,18 @@ public:
//! Adds other vector to this, and returns result.
BasicVector3D<T>& operator+=(const BasicVector3D<T>& v)
{
- v_[0] += v.v_[0];
- v_[1] += v.v_[1];
- v_[2] += v.v_[2];
+ (*this)[0] += v[0];
+ (*this)[1] += v[1];
+ (*this)[2] += v[2];
return *this;
}
//! Subtracts other vector from this, and returns result.
BasicVector3D<T>& operator-=(const BasicVector3D<T>& v)
{
- v_[0] -= v.v_[0];
- v_[1] -= v.v_[1];
- v_[2] -= v.v_[2];
+ (*this)[0] -= v[0];
+ (*this)[1] -= v[1];
+ (*this)[2] -= v[2];
return *this;
}
@@ -88,9 +83,9 @@ public:
#ifndef SWIG
template <class U> auto operator*=(U a)
{
- v_[0] *= a;
- v_[1] *= a;
- v_[2] *= a;
+ (*this)[0] *= a;
+ (*this)[1] *= a;
+ (*this)[2] *= a;
return *this;
}
#endif // USER_API
@@ -99,9 +94,9 @@ public:
#ifndef SWIG
template <class U> auto operator/=(U a)
{
- v_[0] /= a;
- v_[1] /= a;
- v_[2] /= a;
+ (*this)[0] /= a;
+ (*this)[1] /= a;
+ (*this)[2] /= a;
return *this;
}
#endif // USER_API
@@ -265,20 +260,6 @@ template <class T, class U> inline BasicVector3D<T> operator/(const BasicVector3
return BasicVector3D<T>(v.x() / a, v.y() / a, v.z() / a);
}
-//! Comparison of two vectors for equality.
-//! @relates BasicVector3D
-template <class T> inline bool operator==(const BasicVector3D<T>& a, const BasicVector3D<T>& b)
-{
- return (a.x() == b.x() && a.y() == b.y() && a.z() == b.z());
-}
-
-//! Comparison of two vectors for inequality.
-//! @relates BasicVector3D
-template <class T> inline bool operator!=(const BasicVector3D<T>& a, const BasicVector3D<T>& b)
-{
- return (a.x() != b.x() || a.y() != b.y() || a.z() != b.z());
-}
-
// =============================================================================
// ?? for API generation ??
// =============================================================================
diff --git a/Wrap/Swig/commons.i b/Wrap/Swig/commons.i
index a9a170d2d41..7fe75c63f84 100644
--- a/Wrap/Swig/commons.i
+++ b/Wrap/Swig/commons.i
@@ -3,6 +3,7 @@
%include "stdint.i"
%include "std_complex.i"
%include "std_string.i"
+%include "std_array.i"
%include "std_vector.i"
%include "std_map.i"
%include "std_shared_ptr.i"
@@ -29,6 +30,9 @@
#define BORNAGAIN_PYTHON
#endif
+%template(arrayR3_t) std::array<double,3>;
+%template(arrayC3_t) std::array<std::complex<double>,3>;
+
%template(vdouble1d_t) std::vector<double>;
%template(vdouble2d_t) std::vector<std::vector<double>>;
%template(vector_integer_t) std::vector<int>;
diff --git a/auto/Wrap/libBornAgainBase.py b/auto/Wrap/libBornAgainBase.py
index 388f461fc74..dc209c142f3 100644
--- a/auto/Wrap/libBornAgainBase.py
+++ b/auto/Wrap/libBornAgainBase.py
@@ -157,6 +157,230 @@ def deprecated(message):
return deprecated_func
return deprecated_decorator
+class arrayR3_t(object):
+ r"""Proxy of C++ std::array< double,3 > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(arrayR3_t self) -> SwigPyIterator"""
+ return _libBornAgainBase.arrayR3_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(arrayR3_t self) -> bool"""
+ return _libBornAgainBase.arrayR3_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(arrayR3_t self) -> bool"""
+ return _libBornAgainBase.arrayR3_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(arrayR3_t self) -> std::array< double,3 >::size_type"""
+ return _libBornAgainBase.arrayR3_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j) -> arrayR3_t"""
+ return _libBornAgainBase.arrayR3_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)
+ __setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j, arrayR3_t v)
+ """
+ return _libBornAgainBase.arrayR3_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)"""
+ return _libBornAgainBase.arrayR3_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(arrayR3_t self, std::array< double,3 >::difference_type i)
+ __delitem__(arrayR3_t self, PySliceObject * slice)
+ """
+ return _libBornAgainBase.arrayR3_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(arrayR3_t self, PySliceObject * slice) -> arrayR3_t
+ __getitem__(arrayR3_t self, std::array< double,3 >::difference_type i) -> std::array< double,3 >::value_type const &
+ """
+ return _libBornAgainBase.arrayR3_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(arrayR3_t self, PySliceObject * slice, arrayR3_t v)
+ __setitem__(arrayR3_t self, PySliceObject * slice)
+ __setitem__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::value_type const & x)
+ """
+ return _libBornAgainBase.arrayR3_t___setitem__(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(arrayR3_t self) -> arrayR3_t
+ __init__(arrayR3_t self, arrayR3_t other) -> arrayR3_t
+ """
+ _libBornAgainBase.arrayR3_t_swiginit(self, _libBornAgainBase.new_arrayR3_t(*args))
+
+ def empty(self):
+ r"""empty(arrayR3_t self) -> bool"""
+ return _libBornAgainBase.arrayR3_t_empty(self)
+
+ def size(self):
+ r"""size(arrayR3_t self) -> std::array< double,3 >::size_type"""
+ return _libBornAgainBase.arrayR3_t_size(self)
+
+ def swap(self, v):
+ r"""swap(arrayR3_t self, arrayR3_t v)"""
+ return _libBornAgainBase.arrayR3_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(arrayR3_t self) -> std::array< double,3 >::iterator"""
+ return _libBornAgainBase.arrayR3_t_begin(self)
+
+ def end(self):
+ r"""end(arrayR3_t self) -> std::array< double,3 >::iterator"""
+ return _libBornAgainBase.arrayR3_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"""
+ return _libBornAgainBase.arrayR3_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"""
+ return _libBornAgainBase.arrayR3_t_rend(self)
+
+ def front(self):
+ r"""front(arrayR3_t self) -> std::array< double,3 >::value_type const &"""
+ return _libBornAgainBase.arrayR3_t_front(self)
+
+ def back(self):
+ r"""back(arrayR3_t self) -> std::array< double,3 >::value_type const &"""
+ return _libBornAgainBase.arrayR3_t_back(self)
+
+ def fill(self, u):
+ r"""fill(arrayR3_t self, std::array< double,3 >::value_type const & u)"""
+ return _libBornAgainBase.arrayR3_t_fill(self, u)
+ __swig_destroy__ = _libBornAgainBase.delete_arrayR3_t
+
+# Register arrayR3_t in _libBornAgainBase:
+_libBornAgainBase.arrayR3_t_swigregister(arrayR3_t)
+
+class arrayC3_t(object):
+ r"""Proxy of C++ std::array< std::complex< double >,3 > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(arrayC3_t self) -> SwigPyIterator"""
+ return _libBornAgainBase.arrayC3_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(arrayC3_t self) -> bool"""
+ return _libBornAgainBase.arrayC3_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(arrayC3_t self) -> bool"""
+ return _libBornAgainBase.arrayC3_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"""
+ return _libBornAgainBase.arrayC3_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j) -> arrayC3_t"""
+ return _libBornAgainBase.arrayC3_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)
+ __setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j, arrayC3_t v)
+ """
+ return _libBornAgainBase.arrayC3_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)"""
+ return _libBornAgainBase.arrayC3_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i)
+ __delitem__(arrayC3_t self, PySliceObject * slice)
+ """
+ return _libBornAgainBase.arrayC3_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(arrayC3_t self, PySliceObject * slice) -> arrayC3_t
+ __getitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i) -> std::array< std::complex< double >,3 >::value_type const &
+ """
+ return _libBornAgainBase.arrayC3_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(arrayC3_t self, PySliceObject * slice, arrayC3_t v)
+ __setitem__(arrayC3_t self, PySliceObject * slice)
+ __setitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::value_type const & x)
+ """
+ return _libBornAgainBase.arrayC3_t___setitem__(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(arrayC3_t self) -> arrayC3_t
+ __init__(arrayC3_t self, arrayC3_t other) -> arrayC3_t
+ """
+ _libBornAgainBase.arrayC3_t_swiginit(self, _libBornAgainBase.new_arrayC3_t(*args))
+
+ def empty(self):
+ r"""empty(arrayC3_t self) -> bool"""
+ return _libBornAgainBase.arrayC3_t_empty(self)
+
+ def size(self):
+ r"""size(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"""
+ return _libBornAgainBase.arrayC3_t_size(self)
+
+ def swap(self, v):
+ r"""swap(arrayC3_t self, arrayC3_t v)"""
+ return _libBornAgainBase.arrayC3_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"""
+ return _libBornAgainBase.arrayC3_t_begin(self)
+
+ def end(self):
+ r"""end(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"""
+ return _libBornAgainBase.arrayC3_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"""
+ return _libBornAgainBase.arrayC3_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"""
+ return _libBornAgainBase.arrayC3_t_rend(self)
+
+ def front(self):
+ r"""front(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"""
+ return _libBornAgainBase.arrayC3_t_front(self)
+
+ def back(self):
+ r"""back(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"""
+ return _libBornAgainBase.arrayC3_t_back(self)
+
+ def fill(self, u):
+ r"""fill(arrayC3_t self, std::array< std::complex< double >,3 >::value_type const & u)"""
+ return _libBornAgainBase.arrayC3_t_fill(self, u)
+ __swig_destroy__ = _libBornAgainBase.delete_arrayC3_t
+
+# Register arrayC3_t in _libBornAgainBase:
+_libBornAgainBase.arrayC3_t_swigregister(arrayC3_t)
+
class vdouble1d_t(object):
r"""Proxy of C++ std::vector< double > class."""
@@ -2770,7 +2994,7 @@ class FixedBinAxis(IAxis):
# Register FixedBinAxis in _libBornAgainBase:
_libBornAgainBase.FixedBinAxis_swigregister(FixedBinAxis)
-class R3(object):
+class R3(arrayR3_t):
r"""
@@ -3173,7 +3397,7 @@ class vector_R3(object):
# Register vector_R3 in _libBornAgainBase:
_libBornAgainBase.vector_R3_swigregister(vector_R3)
-class C3(object):
+class C3(arrayC3_t):
r"""
diff --git a/auto/Wrap/libBornAgainBase_wrap.cpp b/auto/Wrap/libBornAgainBase_wrap.cpp
index d35bc2f601b..69eec727bb7 100644
--- a/auto/Wrap/libBornAgainBase_wrap.cpp
+++ b/auto/Wrap/libBornAgainBase_wrap.cpp
@@ -3137,30 +3137,32 @@ namespace Swig {
#define SWIGTYPE_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t swig_types[37]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t swig_types[38]
#define SWIGTYPE_p_std__allocatorT_unsigned_long_t swig_types[39]
-#define SWIGTYPE_p_std__complexT_double_t swig_types[40]
-#define SWIGTYPE_p_std__invalid_argument swig_types[41]
-#define SWIGTYPE_p_std__lessT_std__string_t swig_types[42]
-#define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[43]
-#define SWIGTYPE_p_std__ostream swig_types[44]
-#define SWIGTYPE_p_std__pairT_double_double_t swig_types[45]
-#define SWIGTYPE_p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t swig_types[46]
-#define SWIGTYPE_p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t swig_types[47]
-#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[48]
-#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[49]
-#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[50]
-#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[51]
-#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[52]
-#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[53]
-#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[54]
-#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[55]
-#define SWIGTYPE_p_swig__SwigPyIterator swig_types[56]
-#define SWIGTYPE_p_unsigned_char swig_types[57]
-#define SWIGTYPE_p_unsigned_int swig_types[58]
-#define SWIGTYPE_p_unsigned_long_long swig_types[59]
-#define SWIGTYPE_p_unsigned_short swig_types[60]
-#define SWIGTYPE_p_value_type swig_types[61]
-static swig_type_info *swig_types[63];
-static swig_module_info swig_module = {swig_types, 62, 0, 0, 0, 0};
+#define SWIGTYPE_p_std__arrayT_double_3_t swig_types[40]
+#define SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t swig_types[41]
+#define SWIGTYPE_p_std__complexT_double_t swig_types[42]
+#define SWIGTYPE_p_std__invalid_argument swig_types[43]
+#define SWIGTYPE_p_std__lessT_std__string_t swig_types[44]
+#define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[45]
+#define SWIGTYPE_p_std__ostream swig_types[46]
+#define SWIGTYPE_p_std__pairT_double_double_t swig_types[47]
+#define SWIGTYPE_p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t swig_types[48]
+#define SWIGTYPE_p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t swig_types[49]
+#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[50]
+#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[51]
+#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[52]
+#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[53]
+#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[54]
+#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[55]
+#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[56]
+#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[57]
+#define SWIGTYPE_p_swig__SwigPyIterator swig_types[58]
+#define SWIGTYPE_p_unsigned_char swig_types[59]
+#define SWIGTYPE_p_unsigned_int swig_types[60]
+#define SWIGTYPE_p_unsigned_long_long swig_types[61]
+#define SWIGTYPE_p_unsigned_short swig_types[62]
+#define SWIGTYPE_p_value_type swig_types[63]
+static swig_type_info *swig_types[65];
+static swig_module_info swig_module = {swig_types, 64, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
@@ -4995,48 +4997,104 @@ namespace swig {
namespace swig {
- template <class T>
- struct traits_reserve<std::vector<T> > {
- static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
- seq.reserve(n);
+ template <class T, size_t N>
+ struct traits_asptr<std::array<T, N> > {
+ static int asptr(PyObject *obj, std::array<T, N> **vec) {
+ return traits_asptr_stdseq<std::array<T, N> >::asptr(obj, vec);
}
};
- template <class T>
- struct traits_asptr<std::vector<T> > {
- static int asptr(PyObject *obj, std::vector<T> **vec) {
- return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+ template <class T, size_t N>
+ struct traits_from<std::array<T, N> > {
+ static PyObject *from(const std::array<T, N>& vec) {
+ return traits_from_stdseq<std::array<T, N> >::from(vec);
}
};
-
- template <class T>
- struct traits_from<std::vector<T> > {
- static PyObject *from(const std::vector<T>& vec) {
- return traits_from_stdseq<std::vector<T> >::from(vec);
+
+ template <class SwigPySeq, class T, size_t N>
+ inline void
+ assign(const SwigPySeq& swigpyseq, std::array<T, N>* seq) {
+ if (swigpyseq.size() < seq->size())
+ throw std::invalid_argument("std::array cannot be expanded in size");
+ else if (swigpyseq.size() > seq->size())
+ throw std::invalid_argument("std::array cannot be reduced in size");
+ std::copy(swigpyseq.begin(), swigpyseq.end(), seq->begin());
+ }
+
+ template <class T, size_t N>
+ inline void
+ erase(std::array<T, N>* SWIGUNUSEDPARM(seq), const typename std::array<T, N>::iterator& SWIGUNUSEDPARM(position)) {
+ throw std::invalid_argument("std::array object does not support item deletion");
+ }
+
+ // Only limited slicing is supported as std::array is fixed in size
+ template <class T, size_t N, class Difference>
+ inline std::array<T, N>*
+ getslice(const std::array<T, N>* self, Difference i, Difference j, Py_ssize_t step) {
+ typedef std::array<T, N> Sequence;
+ typename Sequence::size_type size = self->size();
+ Difference ii = 0;
+ Difference jj = 0;
+ swig::slice_adjust(i, j, step, size, ii, jj);
+
+ if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
+ Sequence *sequence = new Sequence();
+ std::copy(self->begin(), self->end(), sequence->begin());
+ return sequence;
+ } else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
+ Sequence *sequence = new Sequence();
+ std::copy(self->rbegin(), self->rend(), sequence->begin());
+ return sequence;
+ } else {
+ throw std::invalid_argument("std::array object only supports getting a slice that is the size of the array");
}
- };
+ }
+
+ template <class T, size_t N, class Difference, class InputSeq>
+ inline void
+ setslice(std::array<T, N>* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
+ typedef std::array<T, N> Sequence;
+ typename Sequence::size_type size = self->size();
+ Difference ii = 0;
+ Difference jj = 0;
+ swig::slice_adjust(i, j, step, size, ii, jj, true);
+
+ if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
+ std::copy(is.begin(), is.end(), self->begin());
+ } else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
+ std::copy(is.rbegin(), is.rend(), self->begin());
+ } else {
+ throw std::invalid_argument("std::array object only supports setting a slice that is the size of the array");
+ }
+ }
+
+ template <class T, size_t N, class Difference>
+ inline void
+ delslice(std::array<T, N>* SWIGUNUSEDPARM(self), Difference SWIGUNUSEDPARM(i), Difference SWIGUNUSEDPARM(j), Py_ssize_t SWIGUNUSEDPARM(step)) {
+ throw std::invalid_argument("std::array object does not support item deletion");
+ }
}
namespace swig {
- template <> struct traits<std::vector< double, std::allocator< double > > > {
+ template <> struct traits<std::array< double, 3 > > {
typedef pointer_category category;
static const char* type_name() {
- return "std::vector<" "double" "," "std::allocator< double >" " >";
+ return "std::array<" "double" "," "3" " >";
}
};
}
-SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_array_Sl_double_Sc_3_Sg__iterator(std::array< double,3 > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
+SWIGINTERN bool std_array_Sl_double_Sc_3_Sg____nonzero__(std::array< double,3 > const *self){
return !(self->empty());
}
-SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
+SWIGINTERN bool std_array_Sl_double_Sc_3_Sg____bool__(std::array< double,3 > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
+SWIGINTERN std::array< double,3 >::size_type std_array_Sl_double_Sc_3_Sg____len__(std::array< double,3 > const *self){
return self->size();
}
@@ -5073,66 +5131,66 @@ SWIG_From_size_t (size_t value)
#endif
}
-SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+SWIGINTERN std::array< double,3 > *std_array_Sl_double_Sc_3_Sg____getslice__(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
return swig::getslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
- swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setslice____SWIG_0(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
+ swig::setslice(self, i, j, 1, std::array< double,3 >());
}
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setslice____SWIG_1(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j,std::array< double,3 > const &v){
swig::setslice(self, i, j, 1, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delslice__(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
swig::delslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delitem____SWIG_0(std::array< double,3 > *self,std::array< double,3 >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN std::array< double,3 > *std_array_Sl_double_Sc_3_Sg____getitem____SWIG_0(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_0(std::array< double,3 > *self,PySliceObject *slice,std::array< double,3 > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_1(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delitem____SWIG_1(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
+SWIGINTERN std::array< double,3 >::value_type const &std_array_Sl_double_Sc_3_Sg____getitem____SWIG_1(std::array< double,3 > const *self,std::array< double,3 >::difference_type i){
return *(swig::cgetpos(self, i));
}
@@ -5170,227 +5228,476 @@ namespace swig {
};
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_2(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
-SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
- if (self->size() == 0)
- throw std::out_of_range("pop from empty container");
- std::vector< double,std::allocator< double > >::value_type x = self->back();
- self->pop_back();
- return x;
+
+SWIGINTERN int
+SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
+{
+ if (PyComplex_Check(o)) {
+ if (val) *val = std::complex<double>(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
+ return SWIG_OK;
+ } else {
+ double d;
+ int res = SWIG_AddCast(SWIG_AsVal_double (o, &d));
+ if (SWIG_IsOK(res)) {
+ if (val) *val = std::complex<double>(d, 0.0);
+ return res;
}
-SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
- self->push_back(x);
+ }
+ return SWIG_TypeError;
+}
+
+
+SWIGINTERNINLINE PyObject*
+SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/local/share/swig/4.0.2/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+
+const std::complex<double>&
+
+
+
+/*@SWIG@*/ c)
+{
+ return PyComplex_FromDoubles(std::real(c), std::imag(c));
+}
+
+
+namespace swig {
+ template <> struct traits< std::complex<double> > {
+ typedef value_category category;
+ static const char* type_name() { return"std::complex<double>"; }
+ };
+ template <> struct traits_asval< std::complex<double> > {
+ typedef std::complex<double> value_type;
+ static int asval(PyObject *obj, value_type *val) {
+ return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
}
-SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos){ return self->erase(pos); }
-SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_1(std::vector< double > *self,std::vector< double >::iterator first,std::vector< double >::iterator last){ return self->erase(first, last); }
-SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::value_type const &x){ return self->insert(pos, x); }
-SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }
+ };
+ template <> struct traits_from< std::complex<double> > {
+ typedef std::complex<double> value_type;
+ static PyObject *from(const value_type& val) {
+ return SWIG_From_std_complex_Sl_double_Sg_ (val);
+ }
+ };
+}
+
namespace swig {
- template <> struct traits<std::vector< std::vector< double,std::allocator< double > >, std::allocator< std::vector< double,std::allocator< double > > > > > {
+ template <> struct traits<std::array< std::complex< double >, 3 > > {
typedef pointer_category category;
static const char* type_name() {
- return "std::vector<" "std::vector< double,std::allocator< double > >" "," "std::allocator< std::vector< double,std::allocator< double > > >" " >";
+ return "std::array<" "std::complex< double >" "," "3" " >";
}
};
}
-SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_vector_Sl_double_Sg__Sg__iterator(std::vector< std::vector< double > > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg__iterator(std::array< std::complex< double >,3 > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____nonzero__(std::vector< std::vector< double > > const *self){
+SWIGINTERN bool std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____nonzero__(std::array< std::complex< double >,3 > const *self){
return !(self->empty());
}
-SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____bool__(std::vector< std::vector< double > > const *self){
+SWIGINTERN bool std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____bool__(std::array< std::complex< double >,3 > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector< std::vector< double > >::size_type std_vector_Sl_std_vector_Sl_double_Sg__Sg____len__(std::vector< std::vector< double > > const *self){
+SWIGINTERN std::array< std::complex< double >,3 >::size_type std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____len__(std::array< std::complex< double >,3 > const *self){
return self->size();
}
-SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
+SWIGINTERN std::array< std::complex< double >,3 > *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getslice__(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
return swig::getslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
- swig::setslice(self, i, j, 1, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >());
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_0(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
+ swig::setslice(self, i, j, 1, std::array< std::complex< double >,3 >());
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_1(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j,std::array< std::complex< double >,3 > const &v){
swig::setslice(self, i, j, 1, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delslice__(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
swig::delslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_0(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN std::array< std::complex< double >,3 > *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_0(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_0(std::array< std::complex< double >,3 > *self,PySliceObject *slice,std::array< std::complex< double >,3 > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_1(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_1(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN std::vector< std::vector< double > >::value_type const &std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_1(std::vector< std::vector< double > > const *self,std::vector< std::vector< double > >::difference_type i){
+SWIGINTERN std::array< std::complex< double >,3 >::value_type const &std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_1(std::array< std::complex< double >,3 > const *self,std::array< std::complex< double >,3 >::difference_type i){
return *(swig::cgetpos(self, i));
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_2(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::value_type const &x){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_2(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
-SWIGINTERN std::vector< std::vector< double > >::value_type std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(std::vector< std::vector< double > > *self){
- if (self->size() == 0)
- throw std::out_of_range("pop from empty container");
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type x = self->back();
- self->pop_back();
- return x;
- }
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__append(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::value_type const &x){
- self->push_back(x);
- }
-SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos){ return self->erase(pos); }
-SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator first,std::vector< std::vector< double > >::iterator last){ return self->erase(first, last); }
-SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos,std::vector< std::vector< double > >::value_type const &x){ return self->insert(pos, x); }
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos,std::vector< std::vector< double > >::size_type n,std::vector< std::vector< double > >::value_type const &x){ self->insert(pos, n, x); }
-
-SWIGINTERN int
-SWIG_AsVal_int (PyObject * obj, int *val)
-{
- long v;
- int res = SWIG_AsVal_long (obj, &v);
- if (SWIG_IsOK(res)) {
- if ((v < INT_MIN || v > INT_MAX)) {
- return SWIG_OverflowError;
- } else {
- if (val) *val = static_cast< int >(v);
- }
- }
- return res;
-}
+ namespace swig {
+ template <class T>
+ struct traits_reserve<std::vector<T> > {
+ static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
+ seq.reserve(n);
+ }
+ };
-namespace swig {
- template <> struct traits< int > {
- typedef value_category category;
- static const char* type_name() { return"int"; }
- };
- template <> struct traits_asval< int > {
- typedef int value_type;
- static int asval(PyObject *obj, value_type *val) {
- return SWIG_AsVal_int (obj, val);
- }
- };
- template <> struct traits_from< int > {
- typedef int value_type;
- static PyObject *from(const value_type& val) {
- return SWIG_From_int (val);
- }
- };
-}
+ template <class T>
+ struct traits_asptr<std::vector<T> > {
+ static int asptr(PyObject *obj, std::vector<T> **vec) {
+ return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+ }
+ };
+
+ template <class T>
+ struct traits_from<std::vector<T> > {
+ static PyObject *from(const std::vector<T>& vec) {
+ return traits_from_stdseq<std::vector<T> >::from(vec);
+ }
+ };
+ }
namespace swig {
- template <> struct traits<std::vector< int, std::allocator< int > > > {
+ template <> struct traits<std::vector< double, std::allocator< double > > > {
typedef pointer_category category;
static const char* type_name() {
- return "std::vector<" "int" "," "std::allocator< int >" " >";
+ return "std::vector<" "double" "," "std::allocator< double >" " >";
}
};
}
-SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
+SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
return !(self->empty());
}
-SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
+SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
+SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
return self->size();
}
-SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
return swig::getslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
- swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >());
+SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+ swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
}
-SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
swig::setslice(self, i, j, 1, v);
}
-SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
+SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
swig::delslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< int,std::allocator< int > >::difference_type id = i;
- std::vector< int,std::allocator< int > >::difference_type jd = j;
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< int,std::allocator< int > >::difference_type id = i;
- std::vector< int,std::allocator< int > >::difference_type jd = j;
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< int,std::allocator< int > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
+ return *(swig::cgetpos(self, i));
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
+ *(swig::getpos(self,i)) = x;
+ }
+SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
+ if (self->size() == 0)
+ throw std::out_of_range("pop from empty container");
+ std::vector< double,std::allocator< double > >::value_type x = self->back();
+ self->pop_back();
+ return x;
+ }
+SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
+ self->push_back(x);
+ }
+SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos){ return self->erase(pos); }
+SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_1(std::vector< double > *self,std::vector< double >::iterator first,std::vector< double >::iterator last){ return self->erase(first, last); }
+SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::value_type const &x){ return self->insert(pos, x); }
+SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }
+
+ namespace swig {
+ template <> struct traits<std::vector< std::vector< double,std::allocator< double > >, std::allocator< std::vector< double,std::allocator< double > > > > > {
+ typedef pointer_category category;
+ static const char* type_name() {
+ return "std::vector<" "std::vector< double,std::allocator< double > >" "," "std::allocator< std::vector< double,std::allocator< double > > >" " >";
+ }
+ };
+ }
+
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_vector_Sl_double_Sg__Sg__iterator(std::vector< std::vector< double > > *self,PyObject **PYTHON_SELF){
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+ }
+SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____nonzero__(std::vector< std::vector< double > > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____bool__(std::vector< std::vector< double > > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN std::vector< std::vector< double > >::size_type std_vector_Sl_std_vector_Sl_double_Sg__Sg____len__(std::vector< std::vector< double > > const *self){
+ return self->size();
+ }
+SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
+ return swig::getslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
+ swig::setslice(self, i, j, 1, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >());
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+ swig::setslice(self, i, j, 1, v);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
+ swig::delslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
+ swig::erase(self, swig::getpos(self, i));
+ }
+SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ return swig::getslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ swig::setslice(self, id, jd, step, v);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN std::vector< std::vector< double > >::value_type const &std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_1(std::vector< std::vector< double > > const *self,std::vector< std::vector< double > >::difference_type i){
+ return *(swig::cgetpos(self, i));
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_2(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::value_type const &x){
+ *(swig::getpos(self,i)) = x;
+ }
+SWIGINTERN std::vector< std::vector< double > >::value_type std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(std::vector< std::vector< double > > *self){
+ if (self->size() == 0)
+ throw std::out_of_range("pop from empty container");
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type x = self->back();
+ self->pop_back();
+ return x;
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__append(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::value_type const &x){
+ self->push_back(x);
+ }
+SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos){ return self->erase(pos); }
+SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator first,std::vector< std::vector< double > >::iterator last){ return self->erase(first, last); }
+SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos,std::vector< std::vector< double > >::value_type const &x){ return self->insert(pos, x); }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos,std::vector< std::vector< double > >::size_type n,std::vector< std::vector< double > >::value_type const &x){ self->insert(pos, n, x); }
+
+SWIGINTERN int
+SWIG_AsVal_int (PyObject * obj, int *val)
+{
+ long v;
+ int res = SWIG_AsVal_long (obj, &v);
+ if (SWIG_IsOK(res)) {
+ if ((v < INT_MIN || v > INT_MAX)) {
+ return SWIG_OverflowError;
+ } else {
+ if (val) *val = static_cast< int >(v);
+ }
+ }
+ return res;
+}
+
+
+namespace swig {
+ template <> struct traits< int > {
+ typedef value_category category;
+ static const char* type_name() { return"int"; }
+ };
+ template <> struct traits_asval< int > {
+ typedef int value_type;
+ static int asval(PyObject *obj, value_type *val) {
+ return SWIG_AsVal_int (obj, val);
+ }
+ };
+ template <> struct traits_from< int > {
+ typedef int value_type;
+ static PyObject *from(const value_type& val) {
+ return SWIG_From_int (val);
+ }
+ };
+}
+
+
+ namespace swig {
+ template <> struct traits<std::vector< int, std::allocator< int > > > {
+ typedef pointer_category category;
+ static const char* type_name() {
+ return "std::vector<" "int" "," "std::allocator< int >" " >";
+ }
+ };
+ }
+
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+ }
+SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
+ return self->size();
+ }
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
+ return swig::getslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
+ swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >());
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
+ swig::setslice(self, i, j, 1, v);
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
+ swig::delslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
+ swig::erase(self, swig::getpos(self, i));
+ }
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< int,std::allocator< int > >::difference_type id = i;
+ std::vector< int,std::allocator< int > >::difference_type jd = j;
+ return swig::getslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< int,std::allocator< int > >::difference_type id = i;
+ std::vector< int,std::allocator< int > >::difference_type jd = j;
+ swig::setslice(self, id, jd, step, v);
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
@@ -5648,57 +5955,6 @@ SWIGINTERN std::vector< unsigned long >::iterator std_vector_Sl_unsigned_SS_long
SWIGINTERN std::vector< unsigned long >::iterator std_vector_Sl_unsigned_SS_long_Sg__insert__SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::iterator pos,std::vector< unsigned long >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg__insert__SWIG_1(std::vector< unsigned long > *self,std::vector< unsigned long >::iterator pos,std::vector< unsigned long >::size_type n,std::vector< unsigned long >::value_type const &x){ self->insert(pos, n, x); }
-SWIGINTERN int
-SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
-{
- if (PyComplex_Check(o)) {
- if (val) *val = std::complex<double>(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
- return SWIG_OK;
- } else {
- double d;
- int res = SWIG_AddCast(SWIG_AsVal_double (o, &d));
- if (SWIG_IsOK(res)) {
- if (val) *val = std::complex<double>(d, 0.0);
- return res;
- }
- }
- return SWIG_TypeError;
-}
-
-
-SWIGINTERNINLINE PyObject*
-SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/local/share/swig/4.0.2/typemaps/swigmacros.swg,104,%ifcplusplus@*/
-
-const std::complex<double>&
-
-
-
-/*@SWIG@*/ c)
-{
- return PyComplex_FromDoubles(std::real(c), std::imag(c));
-}
-
-
-namespace swig {
- template <> struct traits< std::complex<double> > {
- typedef value_category category;
- static const char* type_name() { return"std::complex<double>"; }
- };
- template <> struct traits_asval< std::complex<double> > {
- typedef std::complex<double> value_type;
- static int asval(PyObject *obj, value_type *val) {
- return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
- }
- };
- template <> struct traits_from< std::complex<double> > {
- typedef std::complex<double> value_type;
- static PyObject *from(const value_type& val) {
- return SWIG_From_std_complex_Sl_double_Sg_ (val);
- }
- };
-}
-
-
namespace swig {
template <> struct traits<std::vector< std::complex< double >, std::allocator< std::complex< double > > > > {
typedef pointer_category category;
@@ -7449,280 +7705,2510 @@ fail:
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ bool result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ ptrdiff_t result;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PyObject **arg2 = (PyObject **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ arg2 = &swig_obj[0];
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_iterator" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (swig::SwigPyIterator *)std_array_Sl_double_Sc_3_Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___nonzero__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)std_array_Sl_double_Sc_3_Sg____nonzero__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___bool__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)std_array_Sl_double_Sc_3_Sg____bool__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___len__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = std_array_Sl_double_Sc_3_Sg____len__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ std::array< double,3 > *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t___getslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___getslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___getslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ result = (std::array< double,3 > *)std_array_Sl_double_Sc_3_Sg____getslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_double_Sc_3_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ std::array< double,3 > *arg4 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ int res4 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res4 = swig::asptr(swig_obj[3], &ptr);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "arrayR3_t___setslice__" "', argument " "4"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t___setslice__" "', argument " "4"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg4 = ptr;
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::array< double,3 > const &)*arg4);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[5] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___setslice__", 0, 4, argv))) SWIG_fail;
+ --argc;
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setslice____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[3], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayR3_t___setslice____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___setslice__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__setslice__(std::array< double,3 >::difference_type,std::array< double,3 >::difference_type)\n"
+ " std::array< double,3 >::__setslice__(std::array< double,3 >::difference_type,std::array< double,3 >::difference_type,std::array< double,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t___delslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___delslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___delslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_double_Sc_3_Sg____delslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___delitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ try {
+ std_array_Sl_double_Sc_3_Sg____delitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ result = (std::array< double,3 > *)std_array_Sl_double_Sc_3_Sg____getitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::array< double,3 > *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res3 = swig::asptr(swig_obj[2], &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg3 = ptr;
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_0(arg1,arg2,(std::array< double,3 > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____delitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___delitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___delitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___delitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__delitem__(std::array< double,3 >::difference_type)\n"
+ " std::array< double,3 >::__delitem__(PySliceObject *)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getitem__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___getitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ try {
+ result = (std::array< double,3 >::value_type *) &std_array_Sl_double_Sc_3_Sg____getitem____SWIG_1((std::array< double,3 > const *)arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___getitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___getitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___getitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__getitem__(PySliceObject *)\n"
+ " std::array< double,3 >::__getitem__(std::array< double,3 >::difference_type) const\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::value_type *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< double,3 >::value_type temp3 ;
+ double val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 >::value_type""'");
+ }
+ temp3 = static_cast< std::array< double,3 >::value_type >(val3);
+ arg3 = &temp3;
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_2(arg1,arg2,(double const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[4] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___setitem__", 0, 3, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_2(self, argc, argv);
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___setitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__setitem__(PySliceObject *,std::array< double,3 > const &)\n"
+ " std::array< double,3 >::__setitem__(PySliceObject *)\n"
+ " std::array< double,3 >::__setitem__(std::array< double,3 >::difference_type,std::array< double,3 >::value_type const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
+ result = (std::array< double,3 > *)new std::array< double,3 >();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_NEW | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = 0 ;
+ int res1 = SWIG_OLDOBJ ;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res1 = swig::asptr(swig_obj[0], &ptr);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg1 = ptr;
+ }
+ result = (std::array< double,3 > *)new std::array< double,3 >((std::array< double,3 > const &)*arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_NEW | 0 );
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[2] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "new_arrayR3_t", 0, 1, argv))) SWIG_fail;
+ --argc;
+ if (argc == 0) {
+ return _wrap_new_arrayR3_t__SWIG_0(self, argc, argv);
+ }
+ if (argc == 1) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_arrayR3_t__SWIG_1(self, argc, argv);
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_arrayR3_t'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::array()\n"
+ " std::array< double,3 >::array(std::array< double,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_empty" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)((std::array< double,3 > const *)arg1)->empty();
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_size" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = ((std::array< double,3 > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 > *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t_swap", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_swap" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__arrayT_double_3_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "arrayR3_t_swap" "', argument " "2"" of type '" "std::array< double,3 > &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t_swap" "', argument " "2"" of type '" "std::array< double,3 > &""'");
+ }
+ arg2 = reinterpret_cast< std::array< double,3 > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_begin" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_end" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::reverse_iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_rbegin" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::reverse_iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_rend" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_front" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (std::array< double,3 >::value_type *) &((std::array< double,3 > const *)arg1)->front();
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_back" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (std::array< double,3 >::value_type *) &((std::array< double,3 > const *)arg1)->back();
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::value_type *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< double,3 >::value_type temp2 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t_fill", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_fill" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t_fill" "', argument " "2"" of type '" "std::array< double,3 >::value_type""'");
+ }
+ temp2 = static_cast< std::array< double,3 >::value_type >(val2);
+ arg2 = &temp2;
+ (arg1)->fill((std::array< double,3 >::value_type const &)*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_arrayR3_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ delete arg1;
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *arrayR3_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__arrayT_double_3_t, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *arrayR3_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PyObject **arg2 = (PyObject **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ arg2 = &swig_obj[0];
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_iterator" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (swig::SwigPyIterator *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___nonzero__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____nonzero__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___bool__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____bool__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___len__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____len__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t___getslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___getslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___getslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ result = (std::array< std::complex< double >,3 > *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ std::array< std::complex< double >,3 > *arg4 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ int res4 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res4 = swig::asptr(swig_obj[3], &ptr);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "arrayC3_t___setslice__" "', argument " "4"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t___setslice__" "', argument " "4"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg4 = ptr;
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::array< std::complex< double >,3 > const &)*arg4);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[5] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___setslice__", 0, 4, argv))) SWIG_fail;
+ --argc;
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setslice____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[3], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayC3_t___setslice____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___setslice__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__setslice__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::difference_type)\n"
+ " std::array< std::complex< double >,3 >::__setslice__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t___delslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___delslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___delslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___delitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ result = (std::array< std::complex< double >,3 > *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::array< std::complex< double >,3 > *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res3 = swig::asptr(swig_obj[2], &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg3 = ptr;
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_0(arg1,arg2,(std::array< std::complex< double >,3 > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___delitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___delitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___delitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__delitem__(std::array< std::complex< double >,3 >::difference_type)\n"
+ " std::array< std::complex< double >,3 >::__delitem__(PySliceObject *)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___getitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ try {
+ result = (std::array< std::complex< double >,3 >::value_type *) &std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_1((std::array< std::complex< double >,3 > const *)arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___getitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___getitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___getitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__getitem__(PySliceObject *)\n"
+ " std::array< std::complex< double >,3 >::__getitem__(std::array< std::complex< double >,3 >::difference_type) const\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::value_type *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< std::complex< double >,3 >::value_type temp3 ;
+ std::complex< double > val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_std_complex_Sl_double_Sg_(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::value_type""'");
+ }
+ temp3 = static_cast< std::array< std::complex< double >,3 >::value_type >(val3);
+ arg3 = &temp3;
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_2(arg1,arg2,(std::complex< double > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[4] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___setitem__", 0, 3, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_2(self, argc, argv);
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___setitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__setitem__(PySliceObject *,std::array< std::complex< double >,3 > const &)\n"
+ " std::array< std::complex< double >,3 >::__setitem__(PySliceObject *)\n"
+ " std::array< std::complex< double >,3 >::__setitem__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::value_type const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayC3_t__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
+ result = (std::array< std::complex< double >,3 > *)new std::array< std::complex< double >,3 >();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_NEW | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayC3_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = 0 ;
+ int res1 = SWIG_OLDOBJ ;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res1 = swig::asptr(swig_obj[0], &ptr);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg1 = ptr;
+ }
+ result = (std::array< std::complex< double >,3 > *)new std::array< std::complex< double >,3 >((std::array< std::complex< double >,3 > const &)*arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_NEW | 0 );
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayC3_t(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[2] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "new_arrayC3_t", 0, 1, argv))) SWIG_fail;
+ --argc;
+ if (argc == 0) {
+ return _wrap_new_arrayC3_t__SWIG_0(self, argc, argv);
+ }
+ if (argc == 1) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_arrayC3_t__SWIG_1(self, argc, argv);
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_arrayC3_t'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::array()\n"
+ " std::array< std::complex< double >,3 >::array(std::array< std::complex< double >,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_empty" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)((std::array< std::complex< double >,3 > const *)arg1)->empty();
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_size" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = ((std::array< std::complex< double >,3 > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 > *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t_swap", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_swap" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "arrayC3_t_swap" "', argument " "2"" of type '" "std::array< std::complex< double >,3 > &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t_swap" "', argument " "2"" of type '" "std::array< std::complex< double >,3 > &""'");
+ }
+ arg2 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_begin" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- bool result;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_end" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_bool(static_cast< bool >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::reverse_iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_rbegin" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::reverse_iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_rend" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_front" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (std::array< std::complex< double >,3 >::value_type *) &((std::array< std::complex< double >,3 > const *)arg1)->front();
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_back" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (std::array< std::complex< double >,3 >::value_type *) &((std::array< std::complex< double >,3 > const *)arg1)->back();
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- ptrdiff_t result;
+ std::array< std::complex< double >,3 >::value_type temp2 ;
+ std::complex< double > val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t_fill", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_fill" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t_fill" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::value_type""'");
+ }
+ temp2 = static_cast< std::array< std::complex< double >,3 >::value_type >(val2);
+ arg2 = &temp2;
+ (arg1)->fill((std::array< std::complex< double >,3 >::value_type const &)*arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
- Py_ssize_t argc;
- PyObject *argv[3] = {
- 0
- };
+SWIGINTERN PyObject *_wrap_delete_arrayC3_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
- if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
- --argc;
- if (argc == 2) {
- int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
- }
- }
- }
- if (argc == 2) {
- int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- {
- int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
- _v = SWIG_CheckState(res);
- }
- if (_v) {
- return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
- }
- }
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
-
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ delete arg1;
+ resultobj = SWIG_Py_Void();
+ return resultobj;
fail:
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *arrayC3_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
+SWIGINTERN PyObject *arrayC3_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
SWIGINTERN PyObject *_wrap_vdouble1d_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
@@ -32727,6 +35213,86 @@ static PyMethodDef SwigMethods[] = {
"SwigPyIterator___sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t\n"
""},
{ "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
+ { "arrayR3_t_iterator", _wrap_arrayR3_t_iterator, METH_O, "arrayR3_t_iterator(arrayR3_t self) -> SwigPyIterator"},
+ { "arrayR3_t___nonzero__", _wrap_arrayR3_t___nonzero__, METH_O, "arrayR3_t___nonzero__(arrayR3_t self) -> bool"},
+ { "arrayR3_t___bool__", _wrap_arrayR3_t___bool__, METH_O, "arrayR3_t___bool__(arrayR3_t self) -> bool"},
+ { "arrayR3_t___len__", _wrap_arrayR3_t___len__, METH_O, "arrayR3_t___len__(arrayR3_t self) -> std::array< double,3 >::size_type"},
+ { "arrayR3_t___getslice__", _wrap_arrayR3_t___getslice__, METH_VARARGS, "arrayR3_t___getslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j) -> arrayR3_t"},
+ { "arrayR3_t___setslice__", _wrap_arrayR3_t___setslice__, METH_VARARGS, "\n"
+ "arrayR3_t___setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)\n"
+ "arrayR3_t___setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j, arrayR3_t v)\n"
+ ""},
+ { "arrayR3_t___delslice__", _wrap_arrayR3_t___delslice__, METH_VARARGS, "arrayR3_t___delslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)"},
+ { "arrayR3_t___delitem__", _wrap_arrayR3_t___delitem__, METH_VARARGS, "\n"
+ "arrayR3_t___delitem__(arrayR3_t self, std::array< double,3 >::difference_type i)\n"
+ "arrayR3_t___delitem__(arrayR3_t self, PySliceObject * slice)\n"
+ ""},
+ { "arrayR3_t___getitem__", _wrap_arrayR3_t___getitem__, METH_VARARGS, "\n"
+ "arrayR3_t___getitem__(arrayR3_t self, PySliceObject * slice) -> arrayR3_t\n"
+ "arrayR3_t___getitem__(arrayR3_t self, std::array< double,3 >::difference_type i) -> std::array< double,3 >::value_type const &\n"
+ ""},
+ { "arrayR3_t___setitem__", _wrap_arrayR3_t___setitem__, METH_VARARGS, "\n"
+ "arrayR3_t___setitem__(arrayR3_t self, PySliceObject * slice, arrayR3_t v)\n"
+ "arrayR3_t___setitem__(arrayR3_t self, PySliceObject * slice)\n"
+ "arrayR3_t___setitem__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::value_type const & x)\n"
+ ""},
+ { "new_arrayR3_t", _wrap_new_arrayR3_t, METH_VARARGS, "\n"
+ "arrayR3_t()\n"
+ "new_arrayR3_t(arrayR3_t other) -> arrayR3_t\n"
+ ""},
+ { "arrayR3_t_empty", _wrap_arrayR3_t_empty, METH_O, "arrayR3_t_empty(arrayR3_t self) -> bool"},
+ { "arrayR3_t_size", _wrap_arrayR3_t_size, METH_O, "arrayR3_t_size(arrayR3_t self) -> std::array< double,3 >::size_type"},
+ { "arrayR3_t_swap", _wrap_arrayR3_t_swap, METH_VARARGS, "arrayR3_t_swap(arrayR3_t self, arrayR3_t v)"},
+ { "arrayR3_t_begin", _wrap_arrayR3_t_begin, METH_O, "arrayR3_t_begin(arrayR3_t self) -> std::array< double,3 >::iterator"},
+ { "arrayR3_t_end", _wrap_arrayR3_t_end, METH_O, "arrayR3_t_end(arrayR3_t self) -> std::array< double,3 >::iterator"},
+ { "arrayR3_t_rbegin", _wrap_arrayR3_t_rbegin, METH_O, "arrayR3_t_rbegin(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"},
+ { "arrayR3_t_rend", _wrap_arrayR3_t_rend, METH_O, "arrayR3_t_rend(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"},
+ { "arrayR3_t_front", _wrap_arrayR3_t_front, METH_O, "arrayR3_t_front(arrayR3_t self) -> std::array< double,3 >::value_type const &"},
+ { "arrayR3_t_back", _wrap_arrayR3_t_back, METH_O, "arrayR3_t_back(arrayR3_t self) -> std::array< double,3 >::value_type const &"},
+ { "arrayR3_t_fill", _wrap_arrayR3_t_fill, METH_VARARGS, "arrayR3_t_fill(arrayR3_t self, std::array< double,3 >::value_type const & u)"},
+ { "delete_arrayR3_t", _wrap_delete_arrayR3_t, METH_O, "delete_arrayR3_t(arrayR3_t self)"},
+ { "arrayR3_t_swigregister", arrayR3_t_swigregister, METH_O, NULL},
+ { "arrayR3_t_swiginit", arrayR3_t_swiginit, METH_VARARGS, NULL},
+ { "arrayC3_t_iterator", _wrap_arrayC3_t_iterator, METH_O, "arrayC3_t_iterator(arrayC3_t self) -> SwigPyIterator"},
+ { "arrayC3_t___nonzero__", _wrap_arrayC3_t___nonzero__, METH_O, "arrayC3_t___nonzero__(arrayC3_t self) -> bool"},
+ { "arrayC3_t___bool__", _wrap_arrayC3_t___bool__, METH_O, "arrayC3_t___bool__(arrayC3_t self) -> bool"},
+ { "arrayC3_t___len__", _wrap_arrayC3_t___len__, METH_O, "arrayC3_t___len__(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"},
+ { "arrayC3_t___getslice__", _wrap_arrayC3_t___getslice__, METH_VARARGS, "arrayC3_t___getslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j) -> arrayC3_t"},
+ { "arrayC3_t___setslice__", _wrap_arrayC3_t___setslice__, METH_VARARGS, "\n"
+ "arrayC3_t___setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)\n"
+ "arrayC3_t___setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j, arrayC3_t v)\n"
+ ""},
+ { "arrayC3_t___delslice__", _wrap_arrayC3_t___delslice__, METH_VARARGS, "arrayC3_t___delslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)"},
+ { "arrayC3_t___delitem__", _wrap_arrayC3_t___delitem__, METH_VARARGS, "\n"
+ "arrayC3_t___delitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i)\n"
+ "arrayC3_t___delitem__(arrayC3_t self, PySliceObject * slice)\n"
+ ""},
+ { "arrayC3_t___getitem__", _wrap_arrayC3_t___getitem__, METH_VARARGS, "\n"
+ "arrayC3_t___getitem__(arrayC3_t self, PySliceObject * slice) -> arrayC3_t\n"
+ "arrayC3_t___getitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i) -> std::array< std::complex< double >,3 >::value_type const &\n"
+ ""},
+ { "arrayC3_t___setitem__", _wrap_arrayC3_t___setitem__, METH_VARARGS, "\n"
+ "arrayC3_t___setitem__(arrayC3_t self, PySliceObject * slice, arrayC3_t v)\n"
+ "arrayC3_t___setitem__(arrayC3_t self, PySliceObject * slice)\n"
+ "arrayC3_t___setitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::value_type const & x)\n"
+ ""},
+ { "new_arrayC3_t", _wrap_new_arrayC3_t, METH_VARARGS, "\n"
+ "arrayC3_t()\n"
+ "new_arrayC3_t(arrayC3_t other) -> arrayC3_t\n"
+ ""},
+ { "arrayC3_t_empty", _wrap_arrayC3_t_empty, METH_O, "arrayC3_t_empty(arrayC3_t self) -> bool"},
+ { "arrayC3_t_size", _wrap_arrayC3_t_size, METH_O, "arrayC3_t_size(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"},
+ { "arrayC3_t_swap", _wrap_arrayC3_t_swap, METH_VARARGS, "arrayC3_t_swap(arrayC3_t self, arrayC3_t v)"},
+ { "arrayC3_t_begin", _wrap_arrayC3_t_begin, METH_O, "arrayC3_t_begin(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"},
+ { "arrayC3_t_end", _wrap_arrayC3_t_end, METH_O, "arrayC3_t_end(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"},
+ { "arrayC3_t_rbegin", _wrap_arrayC3_t_rbegin, METH_O, "arrayC3_t_rbegin(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"},
+ { "arrayC3_t_rend", _wrap_arrayC3_t_rend, METH_O, "arrayC3_t_rend(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"},
+ { "arrayC3_t_front", _wrap_arrayC3_t_front, METH_O, "arrayC3_t_front(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"},
+ { "arrayC3_t_back", _wrap_arrayC3_t_back, METH_O, "arrayC3_t_back(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"},
+ { "arrayC3_t_fill", _wrap_arrayC3_t_fill, METH_VARARGS, "arrayC3_t_fill(arrayC3_t self, std::array< std::complex< double >,3 >::value_type const & u)"},
+ { "delete_arrayC3_t", _wrap_delete_arrayC3_t, METH_O, "delete_arrayC3_t(arrayC3_t self)"},
+ { "arrayC3_t_swigregister", arrayC3_t_swigregister, METH_O, NULL},
+ { "arrayC3_t_swiginit", arrayC3_t_swiginit, METH_VARARGS, NULL},
{ "vdouble1d_t_iterator", _wrap_vdouble1d_t_iterator, METH_O, "vdouble1d_t_iterator(vdouble1d_t self) -> SwigPyIterator"},
{ "vdouble1d_t___nonzero__", _wrap_vdouble1d_t___nonzero__, METH_O, "vdouble1d_t___nonzero__(vdouble1d_t self) -> bool"},
{ "vdouble1d_t___bool__", _wrap_vdouble1d_t___bool__, METH_O, "vdouble1d_t___bool__(vdouble1d_t self) -> bool"},
@@ -34345,6 +36911,12 @@ static void *_p_CustomBinAxisTo_p_IAxis(void *x, int *SWIGUNUSEDPARM(newmemory))
static void *_p_FixedBinAxisTo_p_IAxis(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((IAxis *) ((FixedBinAxis *) x));
}
+static void *_p_BasicVector3DT_std__complexT_double_t_tTo_p_std__arrayT_std__complexT_double_t_3_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((std::array< std::complex< double >,3 > *) ((BasicVector3D< std::complex< double > > *) x));
+}
+static void *_p_BasicVector3DT_double_tTo_p_std__arrayT_double_3_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((std::array< double,3 > *) ((BasicVector3D< double > *) x));
+}
static swig_type_info _swigt__p_BasicVector3DT_double_t = {"_p_BasicVector3DT_double_t", "std::vector< BasicVector3D< double > >::value_type *|R3 *|BasicVector3D< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BasicVector3DT_int_t = {"_p_BasicVector3DT_int_t", "I3 *|BasicVector3D< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BasicVector3DT_std__complexT_double_t_t = {"_p_BasicVector3DT_std__complexT_double_t_t", "BasicVector3D< std::complex< double > > *|std::vector< BasicVector3D< std::complex< double > > >::value_type *|C3 *|BasicVector3D< complex_t > *", 0, 0, (void*)0, 0};
@@ -34385,6 +36957,8 @@ static swig_type_info _swigt__p_std__allocatorT_std__string_t = {"_p_std__alloca
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t = {"_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t", "std::vector< std::vector< double > >::allocator_type *|std::allocator< std::vector< double,std::allocator< double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t = {"_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t", "std::vector< std::vector< int > >::allocator_type *|std::allocator< std::vector< int,std::allocator< int > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_unsigned_long_t = {"_p_std__allocatorT_unsigned_long_t", "std::vector< unsigned long >::allocator_type *|std::allocator< unsigned long > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__arrayT_double_3_t = {"_p_std__arrayT_double_3_t", "std::array< double,3 > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__arrayT_std__complexT_double_t_3_t = {"_p_std__arrayT_std__complexT_double_t_3_t", "std::array< std::complex< double >,3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__complexT_double_t = {"_p_std__complexT_double_t", "complex_t *|std::complex< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__lessT_std__string_t = {"_p_std__lessT_std__string_t", "std::less< std::string > *", 0, 0, (void*)0, 0};
@@ -34449,6 +37023,8 @@ static swig_type_info *swig_type_initial[] = {
&_swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t,
&_swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t,
&_swigt__p_std__allocatorT_unsigned_long_t,
+ &_swigt__p_std__arrayT_double_3_t,
+ &_swigt__p_std__arrayT_std__complexT_double_t_3_t,
&_swigt__p_std__complexT_double_t,
&_swigt__p_std__invalid_argument,
&_swigt__p_std__lessT_std__string_t,
@@ -34513,6 +37089,8 @@ static swig_cast_info _swigc__p_std__allocatorT_std__string_t[] = { {&_swigt__p
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t[] = { {&_swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t[] = { {&_swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_unsigned_long_t[] = { {&_swigt__p_std__allocatorT_unsigned_long_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__arrayT_double_3_t[] = { {&_swigt__p_BasicVector3DT_double_t, _p_BasicVector3DT_double_tTo_p_std__arrayT_double_3_t, 0, 0}, {&_swigt__p_std__arrayT_double_3_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__arrayT_std__complexT_double_t_3_t[] = { {&_swigt__p_std__arrayT_std__complexT_double_t_3_t, 0, 0, 0}, {&_swigt__p_BasicVector3DT_std__complexT_double_t_t, _p_BasicVector3DT_std__complexT_double_t_tTo_p_std__arrayT_std__complexT_double_t_3_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__complexT_double_t[] = { {&_swigt__p_std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__lessT_std__string_t[] = { {&_swigt__p_std__lessT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -34577,6 +37155,8 @@ static swig_cast_info *swig_cast_initial[] = {
_swigc__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t,
_swigc__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t,
_swigc__p_std__allocatorT_unsigned_long_t,
+ _swigc__p_std__arrayT_double_3_t,
+ _swigc__p_std__arrayT_std__complexT_double_t_3_t,
_swigc__p_std__complexT_double_t,
_swigc__p_std__invalid_argument,
_swigc__p_std__lessT_std__string_t,
diff --git a/auto/Wrap/libBornAgainCore.py b/auto/Wrap/libBornAgainCore.py
index d56b3d214b7..7247cc93534 100644
--- a/auto/Wrap/libBornAgainCore.py
+++ b/auto/Wrap/libBornAgainCore.py
@@ -157,6 +157,230 @@ def deprecated(message):
return deprecated_func
return deprecated_decorator
+class arrayR3_t(object):
+ r"""Proxy of C++ std::array< double,3 > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(arrayR3_t self) -> SwigPyIterator"""
+ return _libBornAgainCore.arrayR3_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(arrayR3_t self) -> bool"""
+ return _libBornAgainCore.arrayR3_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(arrayR3_t self) -> bool"""
+ return _libBornAgainCore.arrayR3_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(arrayR3_t self) -> std::array< double,3 >::size_type"""
+ return _libBornAgainCore.arrayR3_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j) -> arrayR3_t"""
+ return _libBornAgainCore.arrayR3_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)
+ __setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j, arrayR3_t v)
+ """
+ return _libBornAgainCore.arrayR3_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)"""
+ return _libBornAgainCore.arrayR3_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(arrayR3_t self, std::array< double,3 >::difference_type i)
+ __delitem__(arrayR3_t self, PySliceObject * slice)
+ """
+ return _libBornAgainCore.arrayR3_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(arrayR3_t self, PySliceObject * slice) -> arrayR3_t
+ __getitem__(arrayR3_t self, std::array< double,3 >::difference_type i) -> std::array< double,3 >::value_type const &
+ """
+ return _libBornAgainCore.arrayR3_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(arrayR3_t self, PySliceObject * slice, arrayR3_t v)
+ __setitem__(arrayR3_t self, PySliceObject * slice)
+ __setitem__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::value_type const & x)
+ """
+ return _libBornAgainCore.arrayR3_t___setitem__(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(arrayR3_t self) -> arrayR3_t
+ __init__(arrayR3_t self, arrayR3_t other) -> arrayR3_t
+ """
+ _libBornAgainCore.arrayR3_t_swiginit(self, _libBornAgainCore.new_arrayR3_t(*args))
+
+ def empty(self):
+ r"""empty(arrayR3_t self) -> bool"""
+ return _libBornAgainCore.arrayR3_t_empty(self)
+
+ def size(self):
+ r"""size(arrayR3_t self) -> std::array< double,3 >::size_type"""
+ return _libBornAgainCore.arrayR3_t_size(self)
+
+ def swap(self, v):
+ r"""swap(arrayR3_t self, arrayR3_t v)"""
+ return _libBornAgainCore.arrayR3_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(arrayR3_t self) -> std::array< double,3 >::iterator"""
+ return _libBornAgainCore.arrayR3_t_begin(self)
+
+ def end(self):
+ r"""end(arrayR3_t self) -> std::array< double,3 >::iterator"""
+ return _libBornAgainCore.arrayR3_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"""
+ return _libBornAgainCore.arrayR3_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"""
+ return _libBornAgainCore.arrayR3_t_rend(self)
+
+ def front(self):
+ r"""front(arrayR3_t self) -> std::array< double,3 >::value_type const &"""
+ return _libBornAgainCore.arrayR3_t_front(self)
+
+ def back(self):
+ r"""back(arrayR3_t self) -> std::array< double,3 >::value_type const &"""
+ return _libBornAgainCore.arrayR3_t_back(self)
+
+ def fill(self, u):
+ r"""fill(arrayR3_t self, std::array< double,3 >::value_type const & u)"""
+ return _libBornAgainCore.arrayR3_t_fill(self, u)
+ __swig_destroy__ = _libBornAgainCore.delete_arrayR3_t
+
+# Register arrayR3_t in _libBornAgainCore:
+_libBornAgainCore.arrayR3_t_swigregister(arrayR3_t)
+
+class arrayC3_t(object):
+ r"""Proxy of C++ std::array< std::complex< double >,3 > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(arrayC3_t self) -> SwigPyIterator"""
+ return _libBornAgainCore.arrayC3_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(arrayC3_t self) -> bool"""
+ return _libBornAgainCore.arrayC3_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(arrayC3_t self) -> bool"""
+ return _libBornAgainCore.arrayC3_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"""
+ return _libBornAgainCore.arrayC3_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j) -> arrayC3_t"""
+ return _libBornAgainCore.arrayC3_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)
+ __setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j, arrayC3_t v)
+ """
+ return _libBornAgainCore.arrayC3_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)"""
+ return _libBornAgainCore.arrayC3_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i)
+ __delitem__(arrayC3_t self, PySliceObject * slice)
+ """
+ return _libBornAgainCore.arrayC3_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(arrayC3_t self, PySliceObject * slice) -> arrayC3_t
+ __getitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i) -> std::array< std::complex< double >,3 >::value_type const &
+ """
+ return _libBornAgainCore.arrayC3_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(arrayC3_t self, PySliceObject * slice, arrayC3_t v)
+ __setitem__(arrayC3_t self, PySliceObject * slice)
+ __setitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::value_type const & x)
+ """
+ return _libBornAgainCore.arrayC3_t___setitem__(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(arrayC3_t self) -> arrayC3_t
+ __init__(arrayC3_t self, arrayC3_t other) -> arrayC3_t
+ """
+ _libBornAgainCore.arrayC3_t_swiginit(self, _libBornAgainCore.new_arrayC3_t(*args))
+
+ def empty(self):
+ r"""empty(arrayC3_t self) -> bool"""
+ return _libBornAgainCore.arrayC3_t_empty(self)
+
+ def size(self):
+ r"""size(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"""
+ return _libBornAgainCore.arrayC3_t_size(self)
+
+ def swap(self, v):
+ r"""swap(arrayC3_t self, arrayC3_t v)"""
+ return _libBornAgainCore.arrayC3_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"""
+ return _libBornAgainCore.arrayC3_t_begin(self)
+
+ def end(self):
+ r"""end(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"""
+ return _libBornAgainCore.arrayC3_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"""
+ return _libBornAgainCore.arrayC3_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"""
+ return _libBornAgainCore.arrayC3_t_rend(self)
+
+ def front(self):
+ r"""front(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"""
+ return _libBornAgainCore.arrayC3_t_front(self)
+
+ def back(self):
+ r"""back(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"""
+ return _libBornAgainCore.arrayC3_t_back(self)
+
+ def fill(self, u):
+ r"""fill(arrayC3_t self, std::array< std::complex< double >,3 >::value_type const & u)"""
+ return _libBornAgainCore.arrayC3_t_fill(self, u)
+ __swig_destroy__ = _libBornAgainCore.delete_arrayC3_t
+
+# Register arrayC3_t in _libBornAgainCore:
+_libBornAgainCore.arrayC3_t_swigregister(arrayC3_t)
+
class vdouble1d_t(object):
r"""Proxy of C++ std::vector< double > class."""
@@ -1680,7 +1904,7 @@ _libBornAgainCore.vector_pvacuum_double_t_swigregister(vector_pvacuum_double_t)
import libBornAgainFit
import libBornAgainBase
-class R3(object):
+class R3(arrayR3_t):
r"""Proxy of C++ BasicVector3D< double > class."""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
@@ -1689,7 +1913,7 @@ class R3(object):
def __init__(self, *args):
r"""
__init__(R3 self) -> R3
- __init__(R3 self, double const x1, double const y1, double const z1) -> R3
+ __init__(R3 self, double const x, double const y, double const z) -> R3
"""
_libBornAgainCore.R3_swiginit(self, _libBornAgainCore.new_R3(*args))
@@ -1968,7 +2192,7 @@ class vector_R3(object):
# Register vector_R3 in _libBornAgainCore:
_libBornAgainCore.vector_R3_swigregister(vector_R3)
-class C3(object):
+class C3(arrayC3_t):
r"""Proxy of C++ BasicVector3D< std::complex< double > > class."""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
@@ -1977,7 +2201,7 @@ class C3(object):
def __init__(self, *args):
r"""
__init__(C3 self) -> C3
- __init__(C3 self, std::complex< double > const x1, std::complex< double > const y1, std::complex< double > const z1) -> C3
+ __init__(C3 self, std::complex< double > const x, std::complex< double > const y, std::complex< double > const z) -> C3
"""
_libBornAgainCore.C3_swiginit(self, _libBornAgainCore.new_C3(*args))
diff --git a/auto/Wrap/libBornAgainCore_wrap.cpp b/auto/Wrap/libBornAgainCore_wrap.cpp
index 3a35188a62e..bb86e86ccbf 100644
--- a/auto/Wrap/libBornAgainCore_wrap.cpp
+++ b/auto/Wrap/libBornAgainCore_wrap.cpp
@@ -3175,34 +3175,36 @@ namespace Swig {
#define SWIGTYPE_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t swig_types[75]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t swig_types[76]
#define SWIGTYPE_p_std__allocatorT_unsigned_long_t swig_types[77]
-#define SWIGTYPE_p_std__complexT_double_t swig_types[78]
-#define SWIGTYPE_p_std__functionT_bool_fsize_tF_t swig_types[79]
-#define SWIGTYPE_p_std__invalid_argument swig_types[80]
-#define SWIGTYPE_p_std__lessT_std__string_t swig_types[81]
-#define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[82]
-#define SWIGTYPE_p_std__pairT_double_double_t swig_types[83]
-#define SWIGTYPE_p_std__vectorT_AxisInfo_std__allocatorT_AxisInfo_t_t swig_types[84]
-#define SWIGTYPE_p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t swig_types[85]
-#define SWIGTYPE_p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t swig_types[86]
-#define SWIGTYPE_p_std__vectorT_INode_const_p_std__allocatorT_INode_const_p_t_t swig_types[87]
-#define SWIGTYPE_p_std__vectorT_INode_p_std__allocatorT_INode_p_t_t swig_types[88]
-#define SWIGTYPE_p_std__vectorT_ParameterDistribution_std__allocatorT_ParameterDistribution_t_t swig_types[89]
-#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[90]
-#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[91]
-#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[92]
-#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[93]
-#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[94]
-#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[95]
-#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[96]
-#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[97]
-#define SWIGTYPE_p_swig__SwigPyIterator swig_types[98]
-#define SWIGTYPE_p_unsigned_char swig_types[99]
-#define SWIGTYPE_p_unsigned_int swig_types[100]
-#define SWIGTYPE_p_unsigned_long_long swig_types[101]
-#define SWIGTYPE_p_unsigned_short swig_types[102]
-#define SWIGTYPE_p_value_type swig_types[103]
-static swig_type_info *swig_types[105];
-static swig_module_info swig_module = {swig_types, 104, 0, 0, 0, 0};
+#define SWIGTYPE_p_std__arrayT_double_3_t swig_types[78]
+#define SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t swig_types[79]
+#define SWIGTYPE_p_std__complexT_double_t swig_types[80]
+#define SWIGTYPE_p_std__functionT_bool_fsize_tF_t swig_types[81]
+#define SWIGTYPE_p_std__invalid_argument swig_types[82]
+#define SWIGTYPE_p_std__lessT_std__string_t swig_types[83]
+#define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[84]
+#define SWIGTYPE_p_std__pairT_double_double_t swig_types[85]
+#define SWIGTYPE_p_std__vectorT_AxisInfo_std__allocatorT_AxisInfo_t_t swig_types[86]
+#define SWIGTYPE_p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t swig_types[87]
+#define SWIGTYPE_p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t swig_types[88]
+#define SWIGTYPE_p_std__vectorT_INode_const_p_std__allocatorT_INode_const_p_t_t swig_types[89]
+#define SWIGTYPE_p_std__vectorT_INode_p_std__allocatorT_INode_p_t_t swig_types[90]
+#define SWIGTYPE_p_std__vectorT_ParameterDistribution_std__allocatorT_ParameterDistribution_t_t swig_types[91]
+#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[92]
+#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[93]
+#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[94]
+#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[95]
+#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[96]
+#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[97]
+#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[98]
+#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[99]
+#define SWIGTYPE_p_swig__SwigPyIterator swig_types[100]
+#define SWIGTYPE_p_unsigned_char swig_types[101]
+#define SWIGTYPE_p_unsigned_int swig_types[102]
+#define SWIGTYPE_p_unsigned_long_long swig_types[103]
+#define SWIGTYPE_p_unsigned_short swig_types[104]
+#define SWIGTYPE_p_value_type swig_types[105]
+static swig_type_info *swig_types[107];
+static swig_module_info swig_module = {swig_types, 106, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
@@ -5037,48 +5039,104 @@ namespace swig {
namespace swig {
- template <class T>
- struct traits_reserve<std::vector<T> > {
- static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
- seq.reserve(n);
+ template <class T, size_t N>
+ struct traits_asptr<std::array<T, N> > {
+ static int asptr(PyObject *obj, std::array<T, N> **vec) {
+ return traits_asptr_stdseq<std::array<T, N> >::asptr(obj, vec);
}
};
- template <class T>
- struct traits_asptr<std::vector<T> > {
- static int asptr(PyObject *obj, std::vector<T> **vec) {
- return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+ template <class T, size_t N>
+ struct traits_from<std::array<T, N> > {
+ static PyObject *from(const std::array<T, N>& vec) {
+ return traits_from_stdseq<std::array<T, N> >::from(vec);
}
};
-
- template <class T>
- struct traits_from<std::vector<T> > {
- static PyObject *from(const std::vector<T>& vec) {
- return traits_from_stdseq<std::vector<T> >::from(vec);
+
+ template <class SwigPySeq, class T, size_t N>
+ inline void
+ assign(const SwigPySeq& swigpyseq, std::array<T, N>* seq) {
+ if (swigpyseq.size() < seq->size())
+ throw std::invalid_argument("std::array cannot be expanded in size");
+ else if (swigpyseq.size() > seq->size())
+ throw std::invalid_argument("std::array cannot be reduced in size");
+ std::copy(swigpyseq.begin(), swigpyseq.end(), seq->begin());
+ }
+
+ template <class T, size_t N>
+ inline void
+ erase(std::array<T, N>* SWIGUNUSEDPARM(seq), const typename std::array<T, N>::iterator& SWIGUNUSEDPARM(position)) {
+ throw std::invalid_argument("std::array object does not support item deletion");
+ }
+
+ // Only limited slicing is supported as std::array is fixed in size
+ template <class T, size_t N, class Difference>
+ inline std::array<T, N>*
+ getslice(const std::array<T, N>* self, Difference i, Difference j, Py_ssize_t step) {
+ typedef std::array<T, N> Sequence;
+ typename Sequence::size_type size = self->size();
+ Difference ii = 0;
+ Difference jj = 0;
+ swig::slice_adjust(i, j, step, size, ii, jj);
+
+ if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
+ Sequence *sequence = new Sequence();
+ std::copy(self->begin(), self->end(), sequence->begin());
+ return sequence;
+ } else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
+ Sequence *sequence = new Sequence();
+ std::copy(self->rbegin(), self->rend(), sequence->begin());
+ return sequence;
+ } else {
+ throw std::invalid_argument("std::array object only supports getting a slice that is the size of the array");
}
- };
+ }
+
+ template <class T, size_t N, class Difference, class InputSeq>
+ inline void
+ setslice(std::array<T, N>* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
+ typedef std::array<T, N> Sequence;
+ typename Sequence::size_type size = self->size();
+ Difference ii = 0;
+ Difference jj = 0;
+ swig::slice_adjust(i, j, step, size, ii, jj, true);
+
+ if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
+ std::copy(is.begin(), is.end(), self->begin());
+ } else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
+ std::copy(is.rbegin(), is.rend(), self->begin());
+ } else {
+ throw std::invalid_argument("std::array object only supports setting a slice that is the size of the array");
+ }
+ }
+
+ template <class T, size_t N, class Difference>
+ inline void
+ delslice(std::array<T, N>* SWIGUNUSEDPARM(self), Difference SWIGUNUSEDPARM(i), Difference SWIGUNUSEDPARM(j), Py_ssize_t SWIGUNUSEDPARM(step)) {
+ throw std::invalid_argument("std::array object does not support item deletion");
+ }
}
namespace swig {
- template <> struct traits<std::vector< double, std::allocator< double > > > {
+ template <> struct traits<std::array< double, 3 > > {
typedef pointer_category category;
static const char* type_name() {
- return "std::vector<" "double" "," "std::allocator< double >" " >";
+ return "std::array<" "double" "," "3" " >";
}
};
}
-SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_array_Sl_double_Sc_3_Sg__iterator(std::array< double,3 > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
+SWIGINTERN bool std_array_Sl_double_Sc_3_Sg____nonzero__(std::array< double,3 > const *self){
return !(self->empty());
}
-SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
+SWIGINTERN bool std_array_Sl_double_Sc_3_Sg____bool__(std::array< double,3 > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
+SWIGINTERN std::array< double,3 >::size_type std_array_Sl_double_Sc_3_Sg____len__(std::array< double,3 > const *self){
return self->size();
}
@@ -5115,66 +5173,66 @@ SWIG_From_size_t (size_t value)
#endif
}
-SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+SWIGINTERN std::array< double,3 > *std_array_Sl_double_Sc_3_Sg____getslice__(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
return swig::getslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
- swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setslice____SWIG_0(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
+ swig::setslice(self, i, j, 1, std::array< double,3 >());
}
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setslice____SWIG_1(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j,std::array< double,3 > const &v){
swig::setslice(self, i, j, 1, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delslice__(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
swig::delslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delitem____SWIG_0(std::array< double,3 > *self,std::array< double,3 >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN std::array< double,3 > *std_array_Sl_double_Sc_3_Sg____getitem____SWIG_0(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_0(std::array< double,3 > *self,PySliceObject *slice,std::array< double,3 > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_1(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delitem____SWIG_1(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
+SWIGINTERN std::array< double,3 >::value_type const &std_array_Sl_double_Sc_3_Sg____getitem____SWIG_1(std::array< double,3 > const *self,std::array< double,3 >::difference_type i){
return *(swig::cgetpos(self, i));
}
@@ -5212,6 +5270,255 @@ namespace swig {
};
}
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_2(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::value_type const &x){
+ *(swig::getpos(self,i)) = x;
+ }
+
+SWIGINTERN int
+SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
+{
+ if (PyComplex_Check(o)) {
+ if (val) *val = std::complex<double>(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
+ return SWIG_OK;
+ } else {
+ double d;
+ int res = SWIG_AddCast(SWIG_AsVal_double (o, &d));
+ if (SWIG_IsOK(res)) {
+ if (val) *val = std::complex<double>(d, 0.0);
+ return res;
+ }
+ }
+ return SWIG_TypeError;
+}
+
+
+SWIGINTERNINLINE PyObject*
+SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/local/share/swig/4.0.2/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+
+const std::complex<double>&
+
+
+
+/*@SWIG@*/ c)
+{
+ return PyComplex_FromDoubles(std::real(c), std::imag(c));
+}
+
+
+namespace swig {
+ template <> struct traits< std::complex<double> > {
+ typedef value_category category;
+ static const char* type_name() { return"std::complex<double>"; }
+ };
+ template <> struct traits_asval< std::complex<double> > {
+ typedef std::complex<double> value_type;
+ static int asval(PyObject *obj, value_type *val) {
+ return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
+ }
+ };
+ template <> struct traits_from< std::complex<double> > {
+ typedef std::complex<double> value_type;
+ static PyObject *from(const value_type& val) {
+ return SWIG_From_std_complex_Sl_double_Sg_ (val);
+ }
+ };
+}
+
+
+ namespace swig {
+ template <> struct traits<std::array< std::complex< double >, 3 > > {
+ typedef pointer_category category;
+ static const char* type_name() {
+ return "std::array<" "std::complex< double >" "," "3" " >";
+ }
+ };
+ }
+
+SWIGINTERN swig::SwigPyIterator *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg__iterator(std::array< std::complex< double >,3 > *self,PyObject **PYTHON_SELF){
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+ }
+SWIGINTERN bool std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____nonzero__(std::array< std::complex< double >,3 > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____bool__(std::array< std::complex< double >,3 > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN std::array< std::complex< double >,3 >::size_type std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____len__(std::array< std::complex< double >,3 > const *self){
+ return self->size();
+ }
+SWIGINTERN std::array< std::complex< double >,3 > *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getslice__(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
+ return swig::getslice(self, i, j, 1);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_0(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
+ swig::setslice(self, i, j, 1, std::array< std::complex< double >,3 >());
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_1(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j,std::array< std::complex< double >,3 > const &v){
+ swig::setslice(self, i, j, 1, v);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delslice__(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
+ swig::delslice(self, i, j, 1);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_0(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i){
+ swig::erase(self, swig::getpos(self, i));
+ }
+SWIGINTERN std::array< std::complex< double >,3 > *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_0(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
+ return swig::getslice(self, id, jd, step);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_0(std::array< std::complex< double >,3 > *self,PySliceObject *slice,std::array< std::complex< double >,3 > const &v){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
+ swig::setslice(self, id, jd, step, v);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_1(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_1(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN std::array< std::complex< double >,3 >::value_type const &std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_1(std::array< std::complex< double >,3 > const *self,std::array< std::complex< double >,3 >::difference_type i){
+ return *(swig::cgetpos(self, i));
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_2(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::value_type const &x){
+ *(swig::getpos(self,i)) = x;
+ }
+
+ namespace swig {
+ template <class T>
+ struct traits_reserve<std::vector<T> > {
+ static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
+ seq.reserve(n);
+ }
+ };
+
+ template <class T>
+ struct traits_asptr<std::vector<T> > {
+ static int asptr(PyObject *obj, std::vector<T> **vec) {
+ return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+ }
+ };
+
+ template <class T>
+ struct traits_from<std::vector<T> > {
+ static PyObject *from(const std::vector<T>& vec) {
+ return traits_from_stdseq<std::vector<T> >::from(vec);
+ }
+ };
+ }
+
+
+ namespace swig {
+ template <> struct traits<std::vector< double, std::allocator< double > > > {
+ typedef pointer_category category;
+ static const char* type_name() {
+ return "std::vector<" "double" "," "std::allocator< double >" " >";
+ }
+ };
+ }
+
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+ }
+SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
+ return self->size();
+ }
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+ return swig::getslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+ swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
+ swig::setslice(self, i, j, 1, v);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+ swig::delslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
+ swig::erase(self, swig::getpos(self, i));
+ }
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ return swig::getslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::setslice(self, id, jd, step, v);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
+ return *(swig::cgetpos(self, i));
+ }
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
@@ -5690,57 +5997,6 @@ SWIGINTERN std::vector< unsigned long >::iterator std_vector_Sl_unsigned_SS_long
SWIGINTERN std::vector< unsigned long >::iterator std_vector_Sl_unsigned_SS_long_Sg__insert__SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::iterator pos,std::vector< unsigned long >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg__insert__SWIG_1(std::vector< unsigned long > *self,std::vector< unsigned long >::iterator pos,std::vector< unsigned long >::size_type n,std::vector< unsigned long >::value_type const &x){ self->insert(pos, n, x); }
-SWIGINTERN int
-SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
-{
- if (PyComplex_Check(o)) {
- if (val) *val = std::complex<double>(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
- return SWIG_OK;
- } else {
- double d;
- int res = SWIG_AddCast(SWIG_AsVal_double (o, &d));
- if (SWIG_IsOK(res)) {
- if (val) *val = std::complex<double>(d, 0.0);
- return res;
- }
- }
- return SWIG_TypeError;
-}
-
-
-SWIGINTERNINLINE PyObject*
-SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/local/share/swig/4.0.2/typemaps/swigmacros.swg,104,%ifcplusplus@*/
-
-const std::complex<double>&
-
-
-
-/*@SWIG@*/ c)
-{
- return PyComplex_FromDoubles(std::real(c), std::imag(c));
-}
-
-
-namespace swig {
- template <> struct traits< std::complex<double> > {
- typedef value_category category;
- static const char* type_name() { return"std::complex<double>"; }
- };
- template <> struct traits_asval< std::complex<double> > {
- typedef std::complex<double> value_type;
- static int asval(PyObject *obj, value_type *val) {
- return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
- }
- };
- template <> struct traits_from< std::complex<double> > {
- typedef std::complex<double> value_type;
- static PyObject *from(const value_type& val) {
- return SWIG_From_std_complex_Sl_double_Sg_ (val);
- }
- };
-}
-
-
namespace swig {
template <> struct traits<std::vector< std::complex< double >, std::allocator< std::complex< double > > > > {
typedef pointer_category category;
@@ -7692,592 +7948,2822 @@ SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(
SWIG_fail;
}
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_decr", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 1) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv);
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_size_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " swig::SwigPyIterator::decr(size_t)\n"
+ " swig::SwigPyIterator::decr()\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ ptrdiff_t result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ try {
+ result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
+ } catch(std::invalid_argument &_e) {
+ SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
+ }
+ resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ bool result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ try {
+ result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
+ } catch(std::invalid_argument &_e) {
+ SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
+ }
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ PyObject *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ try {
+ result = (PyObject *)(arg1)->next();
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = result;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ PyObject *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ try {
+ result = (PyObject *)(arg1)->__next__();
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = result;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ PyObject *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ try {
+ result = (PyObject *)(arg1)->previous();
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = result;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ bool result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ bool result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ ptrdiff_t result;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PyObject **arg2 = (PyObject **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ arg2 = &swig_obj[0];
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_iterator" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (swig::SwigPyIterator *)std_array_Sl_double_Sc_3_Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___nonzero__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)std_array_Sl_double_Sc_3_Sg____nonzero__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___bool__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)std_array_Sl_double_Sc_3_Sg____bool__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___len__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = std_array_Sl_double_Sc_3_Sg____len__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ std::array< double,3 > *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t___getslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___getslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___getslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ result = (std::array< double,3 > *)std_array_Sl_double_Sc_3_Sg____getslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_double_Sc_3_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ std::array< double,3 > *arg4 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ int res4 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res4 = swig::asptr(swig_obj[3], &ptr);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "arrayR3_t___setslice__" "', argument " "4"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t___setslice__" "', argument " "4"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg4 = ptr;
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::array< double,3 > const &)*arg4);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[5] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___setslice__", 0, 4, argv))) SWIG_fail;
+ --argc;
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setslice____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[3], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayR3_t___setslice____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___setslice__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__setslice__(std::array< double,3 >::difference_type,std::array< double,3 >::difference_type)\n"
+ " std::array< double,3 >::__setslice__(std::array< double,3 >::difference_type,std::array< double,3 >::difference_type,std::array< double,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t___delslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___delslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___delslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_double_Sc_3_Sg____delslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___delitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ try {
+ std_array_Sl_double_Sc_3_Sg____delitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ result = (std::array< double,3 > *)std_array_Sl_double_Sc_3_Sg____getitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::array< double,3 > *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res3 = swig::asptr(swig_obj[2], &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg3 = ptr;
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_0(arg1,arg2,(std::array< double,3 > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____delitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___delitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___delitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___delitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__delitem__(std::array< double,3 >::difference_type)\n"
+ " std::array< double,3 >::__delitem__(PySliceObject *)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getitem__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___getitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ try {
+ result = (std::array< double,3 >::value_type *) &std_array_Sl_double_Sc_3_Sg____getitem____SWIG_1((std::array< double,3 > const *)arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___getitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___getitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___getitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__getitem__(PySliceObject *)\n"
+ " std::array< double,3 >::__getitem__(std::array< double,3 >::difference_type) const\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::value_type *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< double,3 >::value_type temp3 ;
+ double val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 >::value_type""'");
+ }
+ temp3 = static_cast< std::array< double,3 >::value_type >(val3);
+ arg3 = &temp3;
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_2(arg1,arg2,(double const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[4] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___setitem__", 0, 3, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_2(self, argc, argv);
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___setitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__setitem__(PySliceObject *,std::array< double,3 > const &)\n"
+ " std::array< double,3 >::__setitem__(PySliceObject *)\n"
+ " std::array< double,3 >::__setitem__(std::array< double,3 >::difference_type,std::array< double,3 >::value_type const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
+ result = (std::array< double,3 > *)new std::array< double,3 >();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_NEW | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = 0 ;
+ int res1 = SWIG_OLDOBJ ;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res1 = swig::asptr(swig_obj[0], &ptr);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg1 = ptr;
+ }
+ result = (std::array< double,3 > *)new std::array< double,3 >((std::array< double,3 > const &)*arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_NEW | 0 );
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[2] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "new_arrayR3_t", 0, 1, argv))) SWIG_fail;
+ --argc;
+ if (argc == 0) {
+ return _wrap_new_arrayR3_t__SWIG_0(self, argc, argv);
+ }
+ if (argc == 1) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_arrayR3_t__SWIG_1(self, argc, argv);
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_arrayR3_t'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::array()\n"
+ " std::array< double,3 >::array(std::array< double,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_empty" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)((std::array< double,3 > const *)arg1)->empty();
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_size" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = ((std::array< double,3 > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 > *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t_swap", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_swap" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__arrayT_double_3_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "arrayR3_t_swap" "', argument " "2"" of type '" "std::array< double,3 > &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t_swap" "', argument " "2"" of type '" "std::array< double,3 > &""'");
+ }
+ arg2 = reinterpret_cast< std::array< double,3 > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_begin" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_end" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::reverse_iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_rbegin" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::reverse_iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_rend" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_front" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (std::array< double,3 >::value_type *) &((std::array< double,3 > const *)arg1)->front();
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_back" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (std::array< double,3 >::value_type *) &((std::array< double,3 > const *)arg1)->back();
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::value_type *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< double,3 >::value_type temp2 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t_fill", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_fill" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t_fill" "', argument " "2"" of type '" "std::array< double,3 >::value_type""'");
+ }
+ temp2 = static_cast< std::array< double,3 >::value_type >(val2);
+ arg2 = &temp2;
+ (arg1)->fill((std::array< double,3 >::value_type const &)*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_arrayR3_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ delete arg1;
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *arrayR3_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__arrayT_double_3_t, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *arrayR3_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PyObject **arg2 = (PyObject **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ arg2 = &swig_obj[0];
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_iterator" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (swig::SwigPyIterator *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___nonzero__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____nonzero__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___bool__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____bool__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___len__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____len__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t___getslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___getslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___getslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ result = (std::array< std::complex< double >,3 > *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ std::array< std::complex< double >,3 > *arg4 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ int res4 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res4 = swig::asptr(swig_obj[3], &ptr);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "arrayC3_t___setslice__" "', argument " "4"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t___setslice__" "', argument " "4"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg4 = ptr;
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::array< std::complex< double >,3 > const &)*arg4);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[5] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___setslice__", 0, 4, argv))) SWIG_fail;
+ --argc;
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setslice____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[3], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayC3_t___setslice____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___setslice__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__setslice__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::difference_type)\n"
+ " std::array< std::complex< double >,3 >::__setslice__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t___delslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___delslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___delslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___delitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ result = (std::array< std::complex< double >,3 > *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::array< std::complex< double >,3 > *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res3 = swig::asptr(swig_obj[2], &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg3 = ptr;
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_0(arg1,arg2,(std::array< std::complex< double >,3 > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___delitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___delitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___delitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__delitem__(std::array< std::complex< double >,3 >::difference_type)\n"
+ " std::array< std::complex< double >,3 >::__delitem__(PySliceObject *)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___getitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ try {
+ result = (std::array< std::complex< double >,3 >::value_type *) &std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_1((std::array< std::complex< double >,3 > const *)arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___getitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___getitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___getitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__getitem__(PySliceObject *)\n"
+ " std::array< std::complex< double >,3 >::__getitem__(std::array< std::complex< double >,3 >::difference_type) const\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::value_type *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< std::complex< double >,3 >::value_type temp3 ;
+ std::complex< double > val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_std_complex_Sl_double_Sg_(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::value_type""'");
+ }
+ temp3 = static_cast< std::array< std::complex< double >,3 >::value_type >(val3);
+ arg3 = &temp3;
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_2(arg1,arg2,(std::complex< double > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
- PyObject *argv[3] = {
+ PyObject *argv[4] = {
0
};
- if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_decr", 0, 2, argv))) SWIG_fail;
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___setitem__", 0, 3, argv))) SWIG_fail;
--argc;
- if (argc == 1) {
+ if (argc == 2) {
int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- return _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv);
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_1(self, argc, argv);
+ }
}
}
- if (argc == 2) {
+ if (argc == 3) {
int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
- int res = SWIG_AsVal_size_t(argv[1], NULL);
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
- return _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv);
+ {
+ int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_2(self, argc, argv);
+ }
}
}
}
fail:
- SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " swig::SwigPyIterator::decr(size_t)\n"
- " swig::SwigPyIterator::decr()\n");
+ " std::array< std::complex< double >,3 >::__setitem__(PySliceObject *,std::array< std::complex< double >,3 > const &)\n"
+ " std::array< std::complex< double >,3 >::__setitem__(PySliceObject *)\n"
+ " std::array< std::complex< double >,3 >::__setitem__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::value_type const &)\n");
return 0;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_arrayC3_t__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- ptrdiff_t result;
+ std::array< std::complex< double >,3 > *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- try {
- result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
- } catch(std::invalid_argument &_e) {
- SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
- }
- resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
+ result = (std::array< std::complex< double >,3 > *)new std::array< std::complex< double >,3 >();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_arrayC3_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- bool result;
+ std::array< std::complex< double >,3 > *arg1 = 0 ;
+ int res1 = SWIG_OLDOBJ ;
+ std::array< std::complex< double >,3 > *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- try {
- result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
- } catch(std::invalid_argument &_e) {
- SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
+ if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res1 = swig::asptr(swig_obj[0], &ptr);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg1 = ptr;
}
- resultobj = SWIG_From_bool(static_cast< bool >(result));
+ result = (std::array< std::complex< double >,3 > *)new std::array< std::complex< double >,3 >((std::array< std::complex< double >,3 > const &)*arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_NEW | 0 );
+ if (SWIG_IsNewObj(res1)) delete arg1;
return resultobj;
fail:
+ if (SWIG_IsNewObj(res1)) delete arg1;
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject *swig_obj[1] ;
- swig::SwigPyIterator *result = 0 ;
+SWIGINTERN PyObject *_wrap_new_arrayC3_t(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[2] = {
+ 0
+ };
- if (!args) SWIG_fail;
- swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ if (!(argc = SWIG_Python_UnpackTuple(args, "new_arrayC3_t", 0, 1, argv))) SWIG_fail;
+ --argc;
+ if (argc == 0) {
+ return _wrap_new_arrayC3_t__SWIG_0(self, argc, argv);
}
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
- return resultobj;
+ if (argc == 1) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_arrayC3_t__SWIG_1(self, argc, argv);
+ }
+ }
+
fail:
- return NULL;
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_arrayC3_t'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::array()\n"
+ " std::array< std::complex< double >,3 >::array(std::array< std::complex< double >,3 > const &)\n");
+ return 0;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
- PyObject *result = 0 ;
+ bool result;
if (!args) SWIG_fail;
swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- try {
- result = (PyObject *)(arg1)->next();
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_empty" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = result;
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)((std::array< std::complex< double >,3 > const *)arg1)->empty();
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
- PyObject *result = 0 ;
+ std::array< std::complex< double >,3 >::size_type result;
if (!args) SWIG_fail;
swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- try {
- result = (PyObject *)(arg1)->__next__();
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_size" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = result;
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = ((std::array< std::complex< double >,3 > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- PyObject *swig_obj[1] ;
- PyObject *result = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!args) SWIG_fail;
- swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t_swap", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_swap" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- try {
- result = (PyObject *)(arg1)->previous();
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "arrayC3_t_swap" "', argument " "2"" of type '" "std::array< std::complex< double >,3 > &""'");
}
- resultobj = result;
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t_swap" "', argument " "2"" of type '" "std::array< std::complex< double >,3 > &""'");
+ }
+ arg2 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_begin" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- bool result;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_end" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_bool(static_cast< bool >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- bool result;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::reverse_iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_rbegin" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_bool(static_cast< bool >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::reverse_iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_rend" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
- }
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_front" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (std::array< std::complex< double >,3 >::value_type *) &((std::array< std::complex< double >,3 > const *)arg1)->front();
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_back" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (std::array< std::complex< double >,3 >::value_type *) &((std::array< std::complex< double >,3 > const *)arg1)->back();
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
+ std::array< std::complex< double >,3 >::value_type temp2 ;
+ std::complex< double > val2 ;
int ecode2 = 0 ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[2] ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t_fill", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_fill" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t_fill" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::value_type""'");
}
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
- }
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ temp2 = static_cast< std::array< std::complex< double >,3 >::value_type >(val2);
+ arg2 = &temp2;
+ (arg1)->fill((std::array< std::complex< double >,3 >::value_type const &)*arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_delete_arrayC3_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- ptrdiff_t result;
+ PyObject *swig_obj[1] ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ delete arg1;
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
-}
-
-
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
- Py_ssize_t argc;
- PyObject *argv[3] = {
- 0
- };
-
- if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
- --argc;
- if (argc == 2) {
- int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
- }
- }
- }
- if (argc == 2) {
- int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- {
- int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
- _v = SWIG_CheckState(res);
- }
- if (_v) {
- return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
- }
- }
- }
-
-fail:
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *arrayC3_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
+SWIGINTERN PyObject *arrayC3_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
SWIGINTERN PyObject *_wrap_vdouble1d_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
@@ -43275,6 +45761,86 @@ static PyMethodDef SwigMethods[] = {
"SwigPyIterator___sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t\n"
""},
{ "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
+ { "arrayR3_t_iterator", _wrap_arrayR3_t_iterator, METH_O, "arrayR3_t_iterator(arrayR3_t self) -> SwigPyIterator"},
+ { "arrayR3_t___nonzero__", _wrap_arrayR3_t___nonzero__, METH_O, "arrayR3_t___nonzero__(arrayR3_t self) -> bool"},
+ { "arrayR3_t___bool__", _wrap_arrayR3_t___bool__, METH_O, "arrayR3_t___bool__(arrayR3_t self) -> bool"},
+ { "arrayR3_t___len__", _wrap_arrayR3_t___len__, METH_O, "arrayR3_t___len__(arrayR3_t self) -> std::array< double,3 >::size_type"},
+ { "arrayR3_t___getslice__", _wrap_arrayR3_t___getslice__, METH_VARARGS, "arrayR3_t___getslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j) -> arrayR3_t"},
+ { "arrayR3_t___setslice__", _wrap_arrayR3_t___setslice__, METH_VARARGS, "\n"
+ "arrayR3_t___setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)\n"
+ "arrayR3_t___setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j, arrayR3_t v)\n"
+ ""},
+ { "arrayR3_t___delslice__", _wrap_arrayR3_t___delslice__, METH_VARARGS, "arrayR3_t___delslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)"},
+ { "arrayR3_t___delitem__", _wrap_arrayR3_t___delitem__, METH_VARARGS, "\n"
+ "arrayR3_t___delitem__(arrayR3_t self, std::array< double,3 >::difference_type i)\n"
+ "arrayR3_t___delitem__(arrayR3_t self, PySliceObject * slice)\n"
+ ""},
+ { "arrayR3_t___getitem__", _wrap_arrayR3_t___getitem__, METH_VARARGS, "\n"
+ "arrayR3_t___getitem__(arrayR3_t self, PySliceObject * slice) -> arrayR3_t\n"
+ "arrayR3_t___getitem__(arrayR3_t self, std::array< double,3 >::difference_type i) -> std::array< double,3 >::value_type const &\n"
+ ""},
+ { "arrayR3_t___setitem__", _wrap_arrayR3_t___setitem__, METH_VARARGS, "\n"
+ "arrayR3_t___setitem__(arrayR3_t self, PySliceObject * slice, arrayR3_t v)\n"
+ "arrayR3_t___setitem__(arrayR3_t self, PySliceObject * slice)\n"
+ "arrayR3_t___setitem__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::value_type const & x)\n"
+ ""},
+ { "new_arrayR3_t", _wrap_new_arrayR3_t, METH_VARARGS, "\n"
+ "arrayR3_t()\n"
+ "new_arrayR3_t(arrayR3_t other) -> arrayR3_t\n"
+ ""},
+ { "arrayR3_t_empty", _wrap_arrayR3_t_empty, METH_O, "arrayR3_t_empty(arrayR3_t self) -> bool"},
+ { "arrayR3_t_size", _wrap_arrayR3_t_size, METH_O, "arrayR3_t_size(arrayR3_t self) -> std::array< double,3 >::size_type"},
+ { "arrayR3_t_swap", _wrap_arrayR3_t_swap, METH_VARARGS, "arrayR3_t_swap(arrayR3_t self, arrayR3_t v)"},
+ { "arrayR3_t_begin", _wrap_arrayR3_t_begin, METH_O, "arrayR3_t_begin(arrayR3_t self) -> std::array< double,3 >::iterator"},
+ { "arrayR3_t_end", _wrap_arrayR3_t_end, METH_O, "arrayR3_t_end(arrayR3_t self) -> std::array< double,3 >::iterator"},
+ { "arrayR3_t_rbegin", _wrap_arrayR3_t_rbegin, METH_O, "arrayR3_t_rbegin(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"},
+ { "arrayR3_t_rend", _wrap_arrayR3_t_rend, METH_O, "arrayR3_t_rend(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"},
+ { "arrayR3_t_front", _wrap_arrayR3_t_front, METH_O, "arrayR3_t_front(arrayR3_t self) -> std::array< double,3 >::value_type const &"},
+ { "arrayR3_t_back", _wrap_arrayR3_t_back, METH_O, "arrayR3_t_back(arrayR3_t self) -> std::array< double,3 >::value_type const &"},
+ { "arrayR3_t_fill", _wrap_arrayR3_t_fill, METH_VARARGS, "arrayR3_t_fill(arrayR3_t self, std::array< double,3 >::value_type const & u)"},
+ { "delete_arrayR3_t", _wrap_delete_arrayR3_t, METH_O, "delete_arrayR3_t(arrayR3_t self)"},
+ { "arrayR3_t_swigregister", arrayR3_t_swigregister, METH_O, NULL},
+ { "arrayR3_t_swiginit", arrayR3_t_swiginit, METH_VARARGS, NULL},
+ { "arrayC3_t_iterator", _wrap_arrayC3_t_iterator, METH_O, "arrayC3_t_iterator(arrayC3_t self) -> SwigPyIterator"},
+ { "arrayC3_t___nonzero__", _wrap_arrayC3_t___nonzero__, METH_O, "arrayC3_t___nonzero__(arrayC3_t self) -> bool"},
+ { "arrayC3_t___bool__", _wrap_arrayC3_t___bool__, METH_O, "arrayC3_t___bool__(arrayC3_t self) -> bool"},
+ { "arrayC3_t___len__", _wrap_arrayC3_t___len__, METH_O, "arrayC3_t___len__(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"},
+ { "arrayC3_t___getslice__", _wrap_arrayC3_t___getslice__, METH_VARARGS, "arrayC3_t___getslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j) -> arrayC3_t"},
+ { "arrayC3_t___setslice__", _wrap_arrayC3_t___setslice__, METH_VARARGS, "\n"
+ "arrayC3_t___setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)\n"
+ "arrayC3_t___setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j, arrayC3_t v)\n"
+ ""},
+ { "arrayC3_t___delslice__", _wrap_arrayC3_t___delslice__, METH_VARARGS, "arrayC3_t___delslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)"},
+ { "arrayC3_t___delitem__", _wrap_arrayC3_t___delitem__, METH_VARARGS, "\n"
+ "arrayC3_t___delitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i)\n"
+ "arrayC3_t___delitem__(arrayC3_t self, PySliceObject * slice)\n"
+ ""},
+ { "arrayC3_t___getitem__", _wrap_arrayC3_t___getitem__, METH_VARARGS, "\n"
+ "arrayC3_t___getitem__(arrayC3_t self, PySliceObject * slice) -> arrayC3_t\n"
+ "arrayC3_t___getitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i) -> std::array< std::complex< double >,3 >::value_type const &\n"
+ ""},
+ { "arrayC3_t___setitem__", _wrap_arrayC3_t___setitem__, METH_VARARGS, "\n"
+ "arrayC3_t___setitem__(arrayC3_t self, PySliceObject * slice, arrayC3_t v)\n"
+ "arrayC3_t___setitem__(arrayC3_t self, PySliceObject * slice)\n"
+ "arrayC3_t___setitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::value_type const & x)\n"
+ ""},
+ { "new_arrayC3_t", _wrap_new_arrayC3_t, METH_VARARGS, "\n"
+ "arrayC3_t()\n"
+ "new_arrayC3_t(arrayC3_t other) -> arrayC3_t\n"
+ ""},
+ { "arrayC3_t_empty", _wrap_arrayC3_t_empty, METH_O, "arrayC3_t_empty(arrayC3_t self) -> bool"},
+ { "arrayC3_t_size", _wrap_arrayC3_t_size, METH_O, "arrayC3_t_size(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"},
+ { "arrayC3_t_swap", _wrap_arrayC3_t_swap, METH_VARARGS, "arrayC3_t_swap(arrayC3_t self, arrayC3_t v)"},
+ { "arrayC3_t_begin", _wrap_arrayC3_t_begin, METH_O, "arrayC3_t_begin(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"},
+ { "arrayC3_t_end", _wrap_arrayC3_t_end, METH_O, "arrayC3_t_end(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"},
+ { "arrayC3_t_rbegin", _wrap_arrayC3_t_rbegin, METH_O, "arrayC3_t_rbegin(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"},
+ { "arrayC3_t_rend", _wrap_arrayC3_t_rend, METH_O, "arrayC3_t_rend(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"},
+ { "arrayC3_t_front", _wrap_arrayC3_t_front, METH_O, "arrayC3_t_front(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"},
+ { "arrayC3_t_back", _wrap_arrayC3_t_back, METH_O, "arrayC3_t_back(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"},
+ { "arrayC3_t_fill", _wrap_arrayC3_t_fill, METH_VARARGS, "arrayC3_t_fill(arrayC3_t self, std::array< std::complex< double >,3 >::value_type const & u)"},
+ { "delete_arrayC3_t", _wrap_delete_arrayC3_t, METH_O, "delete_arrayC3_t(arrayC3_t self)"},
+ { "arrayC3_t_swigregister", arrayC3_t_swigregister, METH_O, NULL},
+ { "arrayC3_t_swiginit", arrayC3_t_swiginit, METH_VARARGS, NULL},
{ "vdouble1d_t_iterator", _wrap_vdouble1d_t_iterator, METH_O, "vdouble1d_t_iterator(vdouble1d_t self) -> SwigPyIterator"},
{ "vdouble1d_t___nonzero__", _wrap_vdouble1d_t___nonzero__, METH_O, "vdouble1d_t___nonzero__(vdouble1d_t self) -> bool"},
{ "vdouble1d_t___bool__", _wrap_vdouble1d_t___bool__, METH_O, "vdouble1d_t___bool__(vdouble1d_t self) -> bool"},
@@ -43829,7 +46395,7 @@ static PyMethodDef SwigMethods[] = {
{ "vector_pvacuum_double_t_swiginit", vector_pvacuum_double_t_swiginit, METH_VARARGS, NULL},
{ "new_R3", _wrap_new_R3, METH_VARARGS, "\n"
"R3()\n"
- "new_R3(double const x1, double const y1, double const z1) -> R3\n"
+ "new_R3(double const x, double const y, double const z) -> R3\n"
""},
{ "R3_x", _wrap_R3_x, METH_O, "R3_x(R3 self) -> double"},
{ "R3_y", _wrap_R3_y, METH_O, "R3_y(R3 self) -> double"},
@@ -43924,7 +46490,7 @@ static PyMethodDef SwigMethods[] = {
{ "vector_R3_swiginit", vector_R3_swiginit, METH_VARARGS, NULL},
{ "new_C3", _wrap_new_C3, METH_VARARGS, "\n"
"C3()\n"
- "new_C3(std::complex< double > const x1, std::complex< double > const y1, std::complex< double > const z1) -> C3\n"
+ "new_C3(std::complex< double > const x, std::complex< double > const y, std::complex< double > const z) -> C3\n"
""},
{ "C3_x", _wrap_C3_x, METH_O, "C3_x(C3 self) -> std::complex< double >"},
{ "C3_y", _wrap_C3_y, METH_O, "C3_y(C3 self) -> std::complex< double >"},
@@ -45361,6 +47927,12 @@ static void *_p_ISampleNodeTo_p_INode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
static void *_p_IBornFFTo_p_INode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((INode *) (ISampleNode *)(IFormFactor *) ((IBornFF *) x));
}
+static void *_p_BasicVector3DT_std__complexT_double_t_tTo_p_std__arrayT_std__complexT_double_t_3_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((std::array< std::complex< double >,3 > *) ((BasicVector3D< std::complex< double > > *) x));
+}
+static void *_p_BasicVector3DT_double_tTo_p_std__arrayT_double_3_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((std::array< double,3 > *) ((BasicVector3D< double > *) x));
+}
static void *_p_GISASSimulationTo_p_ISimulation2D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((ISimulation2D *) ((GISASSimulation *) x));
}
@@ -45481,6 +48053,8 @@ static swig_type_info _swigt__p_std__allocatorT_std__string_t = {"_p_std__alloca
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t = {"_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t", "std::vector< std::vector< double > >::allocator_type *|std::allocator< std::vector< double,std::allocator< double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t = {"_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t", "std::vector< std::vector< int > >::allocator_type *|std::allocator< std::vector< int,std::allocator< int > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_unsigned_long_t = {"_p_std__allocatorT_unsigned_long_t", "std::vector< unsigned long >::allocator_type *|std::allocator< unsigned long > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__arrayT_double_3_t = {"_p_std__arrayT_double_3_t", "std::array< double,3 > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__arrayT_std__complexT_double_t_3_t = {"_p_std__arrayT_std__complexT_double_t_3_t", "std::array< std::complex< double >,3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__complexT_double_t = {"_p_std__complexT_double_t", "complex_t *|std::complex< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_bool_fsize_tF_t = {"_p_std__functionT_bool_fsize_tF_t", "std::function< bool (size_t) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
@@ -45587,6 +48161,8 @@ static swig_type_info *swig_type_initial[] = {
&_swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t,
&_swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t,
&_swigt__p_std__allocatorT_unsigned_long_t,
+ &_swigt__p_std__arrayT_double_3_t,
+ &_swigt__p_std__arrayT_std__complexT_double_t_3_t,
&_swigt__p_std__complexT_double_t,
&_swigt__p_std__functionT_bool_fsize_tF_t,
&_swigt__p_std__invalid_argument,
@@ -45693,6 +48269,8 @@ static swig_cast_info _swigc__p_std__allocatorT_std__string_t[] = { {&_swigt__p
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t[] = { {&_swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t[] = { {&_swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_unsigned_long_t[] = { {&_swigt__p_std__allocatorT_unsigned_long_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__arrayT_double_3_t[] = { {&_swigt__p_BasicVector3DT_double_t, _p_BasicVector3DT_double_tTo_p_std__arrayT_double_3_t, 0, 0}, {&_swigt__p_std__arrayT_double_3_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__arrayT_std__complexT_double_t_3_t[] = { {&_swigt__p_std__arrayT_std__complexT_double_t_3_t, 0, 0, 0}, {&_swigt__p_BasicVector3DT_std__complexT_double_t_t, _p_BasicVector3DT_std__complexT_double_t_tTo_p_std__arrayT_std__complexT_double_t_3_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__complexT_double_t[] = { {&_swigt__p_std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_bool_fsize_tF_t[] = { {&_swigt__p_std__functionT_bool_fsize_tF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
@@ -45799,6 +48377,8 @@ static swig_cast_info *swig_cast_initial[] = {
_swigc__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t,
_swigc__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t,
_swigc__p_std__allocatorT_unsigned_long_t,
+ _swigc__p_std__arrayT_double_3_t,
+ _swigc__p_std__arrayT_std__complexT_double_t_3_t,
_swigc__p_std__complexT_double_t,
_swigc__p_std__functionT_bool_fsize_tF_t,
_swigc__p_std__invalid_argument,
diff --git a/auto/Wrap/libBornAgainDevice.py b/auto/Wrap/libBornAgainDevice.py
index 7f0a6adf746..56b5adacec2 100644
--- a/auto/Wrap/libBornAgainDevice.py
+++ b/auto/Wrap/libBornAgainDevice.py
@@ -157,6 +157,230 @@ def deprecated(message):
return deprecated_func
return deprecated_decorator
+class arrayR3_t(object):
+ r"""Proxy of C++ std::array< double,3 > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(arrayR3_t self) -> SwigPyIterator"""
+ return _libBornAgainDevice.arrayR3_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(arrayR3_t self) -> bool"""
+ return _libBornAgainDevice.arrayR3_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(arrayR3_t self) -> bool"""
+ return _libBornAgainDevice.arrayR3_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(arrayR3_t self) -> std::array< double,3 >::size_type"""
+ return _libBornAgainDevice.arrayR3_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j) -> arrayR3_t"""
+ return _libBornAgainDevice.arrayR3_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)
+ __setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j, arrayR3_t v)
+ """
+ return _libBornAgainDevice.arrayR3_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)"""
+ return _libBornAgainDevice.arrayR3_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(arrayR3_t self, std::array< double,3 >::difference_type i)
+ __delitem__(arrayR3_t self, PySliceObject * slice)
+ """
+ return _libBornAgainDevice.arrayR3_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(arrayR3_t self, PySliceObject * slice) -> arrayR3_t
+ __getitem__(arrayR3_t self, std::array< double,3 >::difference_type i) -> std::array< double,3 >::value_type const &
+ """
+ return _libBornAgainDevice.arrayR3_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(arrayR3_t self, PySliceObject * slice, arrayR3_t v)
+ __setitem__(arrayR3_t self, PySliceObject * slice)
+ __setitem__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::value_type const & x)
+ """
+ return _libBornAgainDevice.arrayR3_t___setitem__(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(arrayR3_t self) -> arrayR3_t
+ __init__(arrayR3_t self, arrayR3_t other) -> arrayR3_t
+ """
+ _libBornAgainDevice.arrayR3_t_swiginit(self, _libBornAgainDevice.new_arrayR3_t(*args))
+
+ def empty(self):
+ r"""empty(arrayR3_t self) -> bool"""
+ return _libBornAgainDevice.arrayR3_t_empty(self)
+
+ def size(self):
+ r"""size(arrayR3_t self) -> std::array< double,3 >::size_type"""
+ return _libBornAgainDevice.arrayR3_t_size(self)
+
+ def swap(self, v):
+ r"""swap(arrayR3_t self, arrayR3_t v)"""
+ return _libBornAgainDevice.arrayR3_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(arrayR3_t self) -> std::array< double,3 >::iterator"""
+ return _libBornAgainDevice.arrayR3_t_begin(self)
+
+ def end(self):
+ r"""end(arrayR3_t self) -> std::array< double,3 >::iterator"""
+ return _libBornAgainDevice.arrayR3_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"""
+ return _libBornAgainDevice.arrayR3_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"""
+ return _libBornAgainDevice.arrayR3_t_rend(self)
+
+ def front(self):
+ r"""front(arrayR3_t self) -> std::array< double,3 >::value_type const &"""
+ return _libBornAgainDevice.arrayR3_t_front(self)
+
+ def back(self):
+ r"""back(arrayR3_t self) -> std::array< double,3 >::value_type const &"""
+ return _libBornAgainDevice.arrayR3_t_back(self)
+
+ def fill(self, u):
+ r"""fill(arrayR3_t self, std::array< double,3 >::value_type const & u)"""
+ return _libBornAgainDevice.arrayR3_t_fill(self, u)
+ __swig_destroy__ = _libBornAgainDevice.delete_arrayR3_t
+
+# Register arrayR3_t in _libBornAgainDevice:
+_libBornAgainDevice.arrayR3_t_swigregister(arrayR3_t)
+
+class arrayC3_t(object):
+ r"""Proxy of C++ std::array< std::complex< double >,3 > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(arrayC3_t self) -> SwigPyIterator"""
+ return _libBornAgainDevice.arrayC3_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(arrayC3_t self) -> bool"""
+ return _libBornAgainDevice.arrayC3_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(arrayC3_t self) -> bool"""
+ return _libBornAgainDevice.arrayC3_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"""
+ return _libBornAgainDevice.arrayC3_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j) -> arrayC3_t"""
+ return _libBornAgainDevice.arrayC3_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)
+ __setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j, arrayC3_t v)
+ """
+ return _libBornAgainDevice.arrayC3_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)"""
+ return _libBornAgainDevice.arrayC3_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i)
+ __delitem__(arrayC3_t self, PySliceObject * slice)
+ """
+ return _libBornAgainDevice.arrayC3_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(arrayC3_t self, PySliceObject * slice) -> arrayC3_t
+ __getitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i) -> std::array< std::complex< double >,3 >::value_type const &
+ """
+ return _libBornAgainDevice.arrayC3_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(arrayC3_t self, PySliceObject * slice, arrayC3_t v)
+ __setitem__(arrayC3_t self, PySliceObject * slice)
+ __setitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::value_type const & x)
+ """
+ return _libBornAgainDevice.arrayC3_t___setitem__(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(arrayC3_t self) -> arrayC3_t
+ __init__(arrayC3_t self, arrayC3_t other) -> arrayC3_t
+ """
+ _libBornAgainDevice.arrayC3_t_swiginit(self, _libBornAgainDevice.new_arrayC3_t(*args))
+
+ def empty(self):
+ r"""empty(arrayC3_t self) -> bool"""
+ return _libBornAgainDevice.arrayC3_t_empty(self)
+
+ def size(self):
+ r"""size(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"""
+ return _libBornAgainDevice.arrayC3_t_size(self)
+
+ def swap(self, v):
+ r"""swap(arrayC3_t self, arrayC3_t v)"""
+ return _libBornAgainDevice.arrayC3_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"""
+ return _libBornAgainDevice.arrayC3_t_begin(self)
+
+ def end(self):
+ r"""end(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"""
+ return _libBornAgainDevice.arrayC3_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"""
+ return _libBornAgainDevice.arrayC3_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"""
+ return _libBornAgainDevice.arrayC3_t_rend(self)
+
+ def front(self):
+ r"""front(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"""
+ return _libBornAgainDevice.arrayC3_t_front(self)
+
+ def back(self):
+ r"""back(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"""
+ return _libBornAgainDevice.arrayC3_t_back(self)
+
+ def fill(self, u):
+ r"""fill(arrayC3_t self, std::array< std::complex< double >,3 >::value_type const & u)"""
+ return _libBornAgainDevice.arrayC3_t_fill(self, u)
+ __swig_destroy__ = _libBornAgainDevice.delete_arrayC3_t
+
+# Register arrayC3_t in _libBornAgainDevice:
+_libBornAgainDevice.arrayC3_t_swigregister(arrayC3_t)
+
class vdouble1d_t(object):
r"""Proxy of C++ std::vector< double > class."""
@@ -1680,7 +1904,7 @@ _libBornAgainDevice.vector_pvacuum_double_t_swigregister(vector_pvacuum_double_t
import libBornAgainFit
import libBornAgainBase
-class R3(object):
+class R3(arrayR3_t):
r"""Proxy of C++ BasicVector3D< double > class."""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
@@ -1689,7 +1913,7 @@ class R3(object):
def __init__(self, *args):
r"""
__init__(R3 self) -> R3
- __init__(R3 self, double const x1, double const y1, double const z1) -> R3
+ __init__(R3 self, double const x, double const y, double const z) -> R3
"""
_libBornAgainDevice.R3_swiginit(self, _libBornAgainDevice.new_R3(*args))
@@ -1958,7 +2182,7 @@ class vector_R3(object):
# Register vector_R3 in _libBornAgainDevice:
_libBornAgainDevice.vector_R3_swigregister(vector_R3)
-class C3(object):
+class C3(arrayC3_t):
r"""Proxy of C++ BasicVector3D< std::complex< double > > class."""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
@@ -1967,7 +2191,7 @@ class C3(object):
def __init__(self, *args):
r"""
__init__(C3 self) -> C3
- __init__(C3 self, std::complex< double > const x1, std::complex< double > const y1, std::complex< double > const z1) -> C3
+ __init__(C3 self, std::complex< double > const x, std::complex< double > const y, std::complex< double > const z) -> C3
"""
_libBornAgainDevice.C3_swiginit(self, _libBornAgainDevice.new_C3(*args))
diff --git a/auto/Wrap/libBornAgainDevice_wrap.cpp b/auto/Wrap/libBornAgainDevice_wrap.cpp
index 9a29bb26a48..becae2c0c6d 100644
--- a/auto/Wrap/libBornAgainDevice_wrap.cpp
+++ b/auto/Wrap/libBornAgainDevice_wrap.cpp
@@ -3178,35 +3178,37 @@ namespace Swig {
#define SWIGTYPE_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t swig_types[78]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t swig_types[79]
#define SWIGTYPE_p_std__allocatorT_unsigned_long_t swig_types[80]
-#define SWIGTYPE_p_std__complexT_double_t swig_types[81]
-#define SWIGTYPE_p_std__functionT_void_fSimulationAreaIterator_const_RF_t swig_types[82]
-#define SWIGTYPE_p_std__invalid_argument swig_types[83]
-#define SWIGTYPE_p_std__lessT_std__string_t swig_types[84]
-#define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[85]
-#define SWIGTYPE_p_std__pairT_double_double_t swig_types[86]
-#define SWIGTYPE_p_std__vectorT_AxisInfo_std__allocatorT_AxisInfo_t_t swig_types[87]
-#define SWIGTYPE_p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t swig_types[88]
-#define SWIGTYPE_p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t swig_types[89]
-#define SWIGTYPE_p_std__vectorT_INode_const_p_std__allocatorT_INode_const_p_t_t swig_types[90]
-#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[91]
-#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[92]
-#define SWIGTYPE_p_std__vectorT_size_t_std__allocatorT_size_t_t_t swig_types[93]
-#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[94]
-#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[95]
-#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[96]
-#define SWIGTYPE_p_std__vectorT_std__unique_ptrT_DiffuseElement_t_std__allocatorT_std__unique_ptrT_DiffuseElement_t_t_t swig_types[97]
-#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[98]
-#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[99]
-#define SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t swig_types[100]
-#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[101]
-#define SWIGTYPE_p_swig__SwigPyIterator swig_types[102]
-#define SWIGTYPE_p_unsigned_char swig_types[103]
-#define SWIGTYPE_p_unsigned_int swig_types[104]
-#define SWIGTYPE_p_unsigned_long_long swig_types[105]
-#define SWIGTYPE_p_unsigned_short swig_types[106]
-#define SWIGTYPE_p_value_type swig_types[107]
-static swig_type_info *swig_types[109];
-static swig_module_info swig_module = {swig_types, 108, 0, 0, 0, 0};
+#define SWIGTYPE_p_std__arrayT_double_3_t swig_types[81]
+#define SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t swig_types[82]
+#define SWIGTYPE_p_std__complexT_double_t swig_types[83]
+#define SWIGTYPE_p_std__functionT_void_fSimulationAreaIterator_const_RF_t swig_types[84]
+#define SWIGTYPE_p_std__invalid_argument swig_types[85]
+#define SWIGTYPE_p_std__lessT_std__string_t swig_types[86]
+#define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[87]
+#define SWIGTYPE_p_std__pairT_double_double_t swig_types[88]
+#define SWIGTYPE_p_std__vectorT_AxisInfo_std__allocatorT_AxisInfo_t_t swig_types[89]
+#define SWIGTYPE_p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t swig_types[90]
+#define SWIGTYPE_p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t swig_types[91]
+#define SWIGTYPE_p_std__vectorT_INode_const_p_std__allocatorT_INode_const_p_t_t swig_types[92]
+#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[93]
+#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[94]
+#define SWIGTYPE_p_std__vectorT_size_t_std__allocatorT_size_t_t_t swig_types[95]
+#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[96]
+#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[97]
+#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[98]
+#define SWIGTYPE_p_std__vectorT_std__unique_ptrT_DiffuseElement_t_std__allocatorT_std__unique_ptrT_DiffuseElement_t_t_t swig_types[99]
+#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[100]
+#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[101]
+#define SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t swig_types[102]
+#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[103]
+#define SWIGTYPE_p_swig__SwigPyIterator swig_types[104]
+#define SWIGTYPE_p_unsigned_char swig_types[105]
+#define SWIGTYPE_p_unsigned_int swig_types[106]
+#define SWIGTYPE_p_unsigned_long_long swig_types[107]
+#define SWIGTYPE_p_unsigned_short swig_types[108]
+#define SWIGTYPE_p_value_type swig_types[109]
+static swig_type_info *swig_types[111];
+static swig_module_info swig_module = {swig_types, 110, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
@@ -5041,48 +5043,104 @@ namespace swig {
namespace swig {
- template <class T>
- struct traits_reserve<std::vector<T> > {
- static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
- seq.reserve(n);
+ template <class T, size_t N>
+ struct traits_asptr<std::array<T, N> > {
+ static int asptr(PyObject *obj, std::array<T, N> **vec) {
+ return traits_asptr_stdseq<std::array<T, N> >::asptr(obj, vec);
}
};
- template <class T>
- struct traits_asptr<std::vector<T> > {
- static int asptr(PyObject *obj, std::vector<T> **vec) {
- return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+ template <class T, size_t N>
+ struct traits_from<std::array<T, N> > {
+ static PyObject *from(const std::array<T, N>& vec) {
+ return traits_from_stdseq<std::array<T, N> >::from(vec);
}
};
-
- template <class T>
- struct traits_from<std::vector<T> > {
- static PyObject *from(const std::vector<T>& vec) {
- return traits_from_stdseq<std::vector<T> >::from(vec);
+
+ template <class SwigPySeq, class T, size_t N>
+ inline void
+ assign(const SwigPySeq& swigpyseq, std::array<T, N>* seq) {
+ if (swigpyseq.size() < seq->size())
+ throw std::invalid_argument("std::array cannot be expanded in size");
+ else if (swigpyseq.size() > seq->size())
+ throw std::invalid_argument("std::array cannot be reduced in size");
+ std::copy(swigpyseq.begin(), swigpyseq.end(), seq->begin());
+ }
+
+ template <class T, size_t N>
+ inline void
+ erase(std::array<T, N>* SWIGUNUSEDPARM(seq), const typename std::array<T, N>::iterator& SWIGUNUSEDPARM(position)) {
+ throw std::invalid_argument("std::array object does not support item deletion");
+ }
+
+ // Only limited slicing is supported as std::array is fixed in size
+ template <class T, size_t N, class Difference>
+ inline std::array<T, N>*
+ getslice(const std::array<T, N>* self, Difference i, Difference j, Py_ssize_t step) {
+ typedef std::array<T, N> Sequence;
+ typename Sequence::size_type size = self->size();
+ Difference ii = 0;
+ Difference jj = 0;
+ swig::slice_adjust(i, j, step, size, ii, jj);
+
+ if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
+ Sequence *sequence = new Sequence();
+ std::copy(self->begin(), self->end(), sequence->begin());
+ return sequence;
+ } else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
+ Sequence *sequence = new Sequence();
+ std::copy(self->rbegin(), self->rend(), sequence->begin());
+ return sequence;
+ } else {
+ throw std::invalid_argument("std::array object only supports getting a slice that is the size of the array");
}
- };
+ }
+
+ template <class T, size_t N, class Difference, class InputSeq>
+ inline void
+ setslice(std::array<T, N>* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
+ typedef std::array<T, N> Sequence;
+ typename Sequence::size_type size = self->size();
+ Difference ii = 0;
+ Difference jj = 0;
+ swig::slice_adjust(i, j, step, size, ii, jj, true);
+
+ if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
+ std::copy(is.begin(), is.end(), self->begin());
+ } else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
+ std::copy(is.rbegin(), is.rend(), self->begin());
+ } else {
+ throw std::invalid_argument("std::array object only supports setting a slice that is the size of the array");
+ }
+ }
+
+ template <class T, size_t N, class Difference>
+ inline void
+ delslice(std::array<T, N>* SWIGUNUSEDPARM(self), Difference SWIGUNUSEDPARM(i), Difference SWIGUNUSEDPARM(j), Py_ssize_t SWIGUNUSEDPARM(step)) {
+ throw std::invalid_argument("std::array object does not support item deletion");
+ }
}
namespace swig {
- template <> struct traits<std::vector< double, std::allocator< double > > > {
+ template <> struct traits<std::array< double, 3 > > {
typedef pointer_category category;
static const char* type_name() {
- return "std::vector<" "double" "," "std::allocator< double >" " >";
+ return "std::array<" "double" "," "3" " >";
}
};
}
-SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_array_Sl_double_Sc_3_Sg__iterator(std::array< double,3 > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
+SWIGINTERN bool std_array_Sl_double_Sc_3_Sg____nonzero__(std::array< double,3 > const *self){
return !(self->empty());
}
-SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
+SWIGINTERN bool std_array_Sl_double_Sc_3_Sg____bool__(std::array< double,3 > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
+SWIGINTERN std::array< double,3 >::size_type std_array_Sl_double_Sc_3_Sg____len__(std::array< double,3 > const *self){
return self->size();
}
@@ -5119,66 +5177,66 @@ SWIG_From_size_t (size_t value)
#endif
}
-SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+SWIGINTERN std::array< double,3 > *std_array_Sl_double_Sc_3_Sg____getslice__(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
return swig::getslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
- swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setslice____SWIG_0(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
+ swig::setslice(self, i, j, 1, std::array< double,3 >());
}
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setslice____SWIG_1(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j,std::array< double,3 > const &v){
swig::setslice(self, i, j, 1, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delslice__(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
swig::delslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delitem____SWIG_0(std::array< double,3 > *self,std::array< double,3 >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN std::array< double,3 > *std_array_Sl_double_Sc_3_Sg____getitem____SWIG_0(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_0(std::array< double,3 > *self,PySliceObject *slice,std::array< double,3 > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_1(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delitem____SWIG_1(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
+SWIGINTERN std::array< double,3 >::value_type const &std_array_Sl_double_Sc_3_Sg____getitem____SWIG_1(std::array< double,3 > const *self,std::array< double,3 >::difference_type i){
return *(swig::cgetpos(self, i));
}
@@ -5216,6 +5274,255 @@ namespace swig {
};
}
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_2(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::value_type const &x){
+ *(swig::getpos(self,i)) = x;
+ }
+
+SWIGINTERN int
+SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
+{
+ if (PyComplex_Check(o)) {
+ if (val) *val = std::complex<double>(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
+ return SWIG_OK;
+ } else {
+ double d;
+ int res = SWIG_AddCast(SWIG_AsVal_double (o, &d));
+ if (SWIG_IsOK(res)) {
+ if (val) *val = std::complex<double>(d, 0.0);
+ return res;
+ }
+ }
+ return SWIG_TypeError;
+}
+
+
+SWIGINTERNINLINE PyObject*
+SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/local/share/swig/4.0.2/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+
+const std::complex<double>&
+
+
+
+/*@SWIG@*/ c)
+{
+ return PyComplex_FromDoubles(std::real(c), std::imag(c));
+}
+
+
+namespace swig {
+ template <> struct traits< std::complex<double> > {
+ typedef value_category category;
+ static const char* type_name() { return"std::complex<double>"; }
+ };
+ template <> struct traits_asval< std::complex<double> > {
+ typedef std::complex<double> value_type;
+ static int asval(PyObject *obj, value_type *val) {
+ return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
+ }
+ };
+ template <> struct traits_from< std::complex<double> > {
+ typedef std::complex<double> value_type;
+ static PyObject *from(const value_type& val) {
+ return SWIG_From_std_complex_Sl_double_Sg_ (val);
+ }
+ };
+}
+
+
+ namespace swig {
+ template <> struct traits<std::array< std::complex< double >, 3 > > {
+ typedef pointer_category category;
+ static const char* type_name() {
+ return "std::array<" "std::complex< double >" "," "3" " >";
+ }
+ };
+ }
+
+SWIGINTERN swig::SwigPyIterator *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg__iterator(std::array< std::complex< double >,3 > *self,PyObject **PYTHON_SELF){
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+ }
+SWIGINTERN bool std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____nonzero__(std::array< std::complex< double >,3 > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____bool__(std::array< std::complex< double >,3 > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN std::array< std::complex< double >,3 >::size_type std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____len__(std::array< std::complex< double >,3 > const *self){
+ return self->size();
+ }
+SWIGINTERN std::array< std::complex< double >,3 > *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getslice__(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
+ return swig::getslice(self, i, j, 1);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_0(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
+ swig::setslice(self, i, j, 1, std::array< std::complex< double >,3 >());
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_1(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j,std::array< std::complex< double >,3 > const &v){
+ swig::setslice(self, i, j, 1, v);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delslice__(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
+ swig::delslice(self, i, j, 1);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_0(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i){
+ swig::erase(self, swig::getpos(self, i));
+ }
+SWIGINTERN std::array< std::complex< double >,3 > *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_0(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
+ return swig::getslice(self, id, jd, step);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_0(std::array< std::complex< double >,3 > *self,PySliceObject *slice,std::array< std::complex< double >,3 > const &v){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
+ swig::setslice(self, id, jd, step, v);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_1(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_1(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN std::array< std::complex< double >,3 >::value_type const &std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_1(std::array< std::complex< double >,3 > const *self,std::array< std::complex< double >,3 >::difference_type i){
+ return *(swig::cgetpos(self, i));
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_2(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::value_type const &x){
+ *(swig::getpos(self,i)) = x;
+ }
+
+ namespace swig {
+ template <class T>
+ struct traits_reserve<std::vector<T> > {
+ static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
+ seq.reserve(n);
+ }
+ };
+
+ template <class T>
+ struct traits_asptr<std::vector<T> > {
+ static int asptr(PyObject *obj, std::vector<T> **vec) {
+ return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+ }
+ };
+
+ template <class T>
+ struct traits_from<std::vector<T> > {
+ static PyObject *from(const std::vector<T>& vec) {
+ return traits_from_stdseq<std::vector<T> >::from(vec);
+ }
+ };
+ }
+
+
+ namespace swig {
+ template <> struct traits<std::vector< double, std::allocator< double > > > {
+ typedef pointer_category category;
+ static const char* type_name() {
+ return "std::vector<" "double" "," "std::allocator< double >" " >";
+ }
+ };
+ }
+
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+ }
+SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
+ return self->size();
+ }
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+ return swig::getslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+ swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
+ swig::setslice(self, i, j, 1, v);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+ swig::delslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
+ swig::erase(self, swig::getpos(self, i));
+ }
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ return swig::getslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::setslice(self, id, jd, step, v);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
+ return *(swig::cgetpos(self, i));
+ }
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
@@ -5694,57 +6001,6 @@ SWIGINTERN std::vector< unsigned long >::iterator std_vector_Sl_unsigned_SS_long
SWIGINTERN std::vector< unsigned long >::iterator std_vector_Sl_unsigned_SS_long_Sg__insert__SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::iterator pos,std::vector< unsigned long >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg__insert__SWIG_1(std::vector< unsigned long > *self,std::vector< unsigned long >::iterator pos,std::vector< unsigned long >::size_type n,std::vector< unsigned long >::value_type const &x){ self->insert(pos, n, x); }
-SWIGINTERN int
-SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
-{
- if (PyComplex_Check(o)) {
- if (val) *val = std::complex<double>(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
- return SWIG_OK;
- } else {
- double d;
- int res = SWIG_AddCast(SWIG_AsVal_double (o, &d));
- if (SWIG_IsOK(res)) {
- if (val) *val = std::complex<double>(d, 0.0);
- return res;
- }
- }
- return SWIG_TypeError;
-}
-
-
-SWIGINTERNINLINE PyObject*
-SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/local/share/swig/4.0.2/typemaps/swigmacros.swg,104,%ifcplusplus@*/
-
-const std::complex<double>&
-
-
-
-/*@SWIG@*/ c)
-{
- return PyComplex_FromDoubles(std::real(c), std::imag(c));
-}
-
-
-namespace swig {
- template <> struct traits< std::complex<double> > {
- typedef value_category category;
- static const char* type_name() { return"std::complex<double>"; }
- };
- template <> struct traits_asval< std::complex<double> > {
- typedef std::complex<double> value_type;
- static int asval(PyObject *obj, value_type *val) {
- return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
- }
- };
- template <> struct traits_from< std::complex<double> > {
- typedef std::complex<double> value_type;
- static PyObject *from(const value_type& val) {
- return SWIG_From_std_complex_Sl_double_Sg_ (val);
- }
- };
-}
-
-
namespace swig {
template <> struct traits<std::vector< std::complex< double >, std::allocator< std::complex< double > > > > {
typedef pointer_category category;
@@ -7210,592 +7466,2822 @@ SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(
SWIG_fail;
}
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_decr", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 1) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv);
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_size_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " swig::SwigPyIterator::decr(size_t)\n"
+ " swig::SwigPyIterator::decr()\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ ptrdiff_t result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ try {
+ result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
+ } catch(std::invalid_argument &_e) {
+ SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
+ }
+ resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ bool result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ try {
+ result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
+ } catch(std::invalid_argument &_e) {
+ SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
+ }
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ PyObject *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ try {
+ result = (PyObject *)(arg1)->next();
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = result;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ PyObject *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ try {
+ result = (PyObject *)(arg1)->__next__();
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = result;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ PyObject *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ try {
+ result = (PyObject *)(arg1)->previous();
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = result;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ bool result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ bool result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ ptrdiff_t result;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PyObject **arg2 = (PyObject **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ arg2 = &swig_obj[0];
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_iterator" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (swig::SwigPyIterator *)std_array_Sl_double_Sc_3_Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___nonzero__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)std_array_Sl_double_Sc_3_Sg____nonzero__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___bool__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)std_array_Sl_double_Sc_3_Sg____bool__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___len__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = std_array_Sl_double_Sc_3_Sg____len__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ std::array< double,3 > *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t___getslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___getslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___getslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ result = (std::array< double,3 > *)std_array_Sl_double_Sc_3_Sg____getslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_double_Sc_3_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ std::array< double,3 > *arg4 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ int res4 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res4 = swig::asptr(swig_obj[3], &ptr);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "arrayR3_t___setslice__" "', argument " "4"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t___setslice__" "', argument " "4"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg4 = ptr;
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::array< double,3 > const &)*arg4);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[5] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___setslice__", 0, 4, argv))) SWIG_fail;
+ --argc;
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setslice____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[3], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayR3_t___setslice____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___setslice__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__setslice__(std::array< double,3 >::difference_type,std::array< double,3 >::difference_type)\n"
+ " std::array< double,3 >::__setslice__(std::array< double,3 >::difference_type,std::array< double,3 >::difference_type,std::array< double,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t___delslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___delslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___delslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_double_Sc_3_Sg____delslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___delitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ try {
+ std_array_Sl_double_Sc_3_Sg____delitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ result = (std::array< double,3 > *)std_array_Sl_double_Sc_3_Sg____getitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::array< double,3 > *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res3 = swig::asptr(swig_obj[2], &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg3 = ptr;
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_0(arg1,arg2,(std::array< double,3 > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____delitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___delitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___delitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___delitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__delitem__(std::array< double,3 >::difference_type)\n"
+ " std::array< double,3 >::__delitem__(PySliceObject *)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getitem__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___getitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ try {
+ result = (std::array< double,3 >::value_type *) &std_array_Sl_double_Sc_3_Sg____getitem____SWIG_1((std::array< double,3 > const *)arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___getitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___getitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___getitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__getitem__(PySliceObject *)\n"
+ " std::array< double,3 >::__getitem__(std::array< double,3 >::difference_type) const\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::value_type *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< double,3 >::value_type temp3 ;
+ double val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 >::value_type""'");
+ }
+ temp3 = static_cast< std::array< double,3 >::value_type >(val3);
+ arg3 = &temp3;
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_2(arg1,arg2,(double const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[4] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___setitem__", 0, 3, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_2(self, argc, argv);
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___setitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__setitem__(PySliceObject *,std::array< double,3 > const &)\n"
+ " std::array< double,3 >::__setitem__(PySliceObject *)\n"
+ " std::array< double,3 >::__setitem__(std::array< double,3 >::difference_type,std::array< double,3 >::value_type const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
+ result = (std::array< double,3 > *)new std::array< double,3 >();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_NEW | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = 0 ;
+ int res1 = SWIG_OLDOBJ ;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res1 = swig::asptr(swig_obj[0], &ptr);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg1 = ptr;
+ }
+ result = (std::array< double,3 > *)new std::array< double,3 >((std::array< double,3 > const &)*arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_NEW | 0 );
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[2] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "new_arrayR3_t", 0, 1, argv))) SWIG_fail;
+ --argc;
+ if (argc == 0) {
+ return _wrap_new_arrayR3_t__SWIG_0(self, argc, argv);
+ }
+ if (argc == 1) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_arrayR3_t__SWIG_1(self, argc, argv);
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_arrayR3_t'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::array()\n"
+ " std::array< double,3 >::array(std::array< double,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_empty" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)((std::array< double,3 > const *)arg1)->empty();
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_size" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = ((std::array< double,3 > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 > *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t_swap", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_swap" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__arrayT_double_3_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "arrayR3_t_swap" "', argument " "2"" of type '" "std::array< double,3 > &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t_swap" "', argument " "2"" of type '" "std::array< double,3 > &""'");
+ }
+ arg2 = reinterpret_cast< std::array< double,3 > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_begin" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_end" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::reverse_iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_rbegin" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::reverse_iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_rend" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_front" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (std::array< double,3 >::value_type *) &((std::array< double,3 > const *)arg1)->front();
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_back" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (std::array< double,3 >::value_type *) &((std::array< double,3 > const *)arg1)->back();
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::value_type *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< double,3 >::value_type temp2 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t_fill", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_fill" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t_fill" "', argument " "2"" of type '" "std::array< double,3 >::value_type""'");
+ }
+ temp2 = static_cast< std::array< double,3 >::value_type >(val2);
+ arg2 = &temp2;
+ (arg1)->fill((std::array< double,3 >::value_type const &)*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_arrayR3_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ delete arg1;
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *arrayR3_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__arrayT_double_3_t, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *arrayR3_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PyObject **arg2 = (PyObject **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ arg2 = &swig_obj[0];
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_iterator" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (swig::SwigPyIterator *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___nonzero__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____nonzero__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___bool__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____bool__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___len__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____len__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t___getslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___getslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___getslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ result = (std::array< std::complex< double >,3 > *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ std::array< std::complex< double >,3 > *arg4 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ int res4 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res4 = swig::asptr(swig_obj[3], &ptr);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "arrayC3_t___setslice__" "', argument " "4"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t___setslice__" "', argument " "4"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg4 = ptr;
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::array< std::complex< double >,3 > const &)*arg4);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[5] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___setslice__", 0, 4, argv))) SWIG_fail;
+ --argc;
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setslice____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[3], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayC3_t___setslice____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___setslice__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__setslice__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::difference_type)\n"
+ " std::array< std::complex< double >,3 >::__setslice__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t___delslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___delslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___delslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___delitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ result = (std::array< std::complex< double >,3 > *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::array< std::complex< double >,3 > *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res3 = swig::asptr(swig_obj[2], &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg3 = ptr;
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_0(arg1,arg2,(std::array< std::complex< double >,3 > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___delitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___delitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___delitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__delitem__(std::array< std::complex< double >,3 >::difference_type)\n"
+ " std::array< std::complex< double >,3 >::__delitem__(PySliceObject *)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___getitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ try {
+ result = (std::array< std::complex< double >,3 >::value_type *) &std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_1((std::array< std::complex< double >,3 > const *)arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___getitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___getitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___getitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__getitem__(PySliceObject *)\n"
+ " std::array< std::complex< double >,3 >::__getitem__(std::array< std::complex< double >,3 >::difference_type) const\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::value_type *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< std::complex< double >,3 >::value_type temp3 ;
+ std::complex< double > val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_std_complex_Sl_double_Sg_(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::value_type""'");
+ }
+ temp3 = static_cast< std::array< std::complex< double >,3 >::value_type >(val3);
+ arg3 = &temp3;
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_2(arg1,arg2,(std::complex< double > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
- PyObject *argv[3] = {
+ PyObject *argv[4] = {
0
};
- if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_decr", 0, 2, argv))) SWIG_fail;
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___setitem__", 0, 3, argv))) SWIG_fail;
--argc;
- if (argc == 1) {
+ if (argc == 2) {
int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- return _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv);
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_1(self, argc, argv);
+ }
}
}
- if (argc == 2) {
+ if (argc == 3) {
int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
- int res = SWIG_AsVal_size_t(argv[1], NULL);
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
- return _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv);
+ {
+ int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_2(self, argc, argv);
+ }
}
}
}
fail:
- SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " swig::SwigPyIterator::decr(size_t)\n"
- " swig::SwigPyIterator::decr()\n");
+ " std::array< std::complex< double >,3 >::__setitem__(PySliceObject *,std::array< std::complex< double >,3 > const &)\n"
+ " std::array< std::complex< double >,3 >::__setitem__(PySliceObject *)\n"
+ " std::array< std::complex< double >,3 >::__setitem__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::value_type const &)\n");
return 0;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_arrayC3_t__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- ptrdiff_t result;
+ std::array< std::complex< double >,3 > *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- try {
- result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
- } catch(std::invalid_argument &_e) {
- SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
- }
- resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
+ result = (std::array< std::complex< double >,3 > *)new std::array< std::complex< double >,3 >();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_arrayC3_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- bool result;
+ std::array< std::complex< double >,3 > *arg1 = 0 ;
+ int res1 = SWIG_OLDOBJ ;
+ std::array< std::complex< double >,3 > *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- try {
- result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
- } catch(std::invalid_argument &_e) {
- SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
+ if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res1 = swig::asptr(swig_obj[0], &ptr);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg1 = ptr;
}
- resultobj = SWIG_From_bool(static_cast< bool >(result));
+ result = (std::array< std::complex< double >,3 > *)new std::array< std::complex< double >,3 >((std::array< std::complex< double >,3 > const &)*arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_NEW | 0 );
+ if (SWIG_IsNewObj(res1)) delete arg1;
return resultobj;
fail:
+ if (SWIG_IsNewObj(res1)) delete arg1;
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject *swig_obj[1] ;
- swig::SwigPyIterator *result = 0 ;
+SWIGINTERN PyObject *_wrap_new_arrayC3_t(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[2] = {
+ 0
+ };
- if (!args) SWIG_fail;
- swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ if (!(argc = SWIG_Python_UnpackTuple(args, "new_arrayC3_t", 0, 1, argv))) SWIG_fail;
+ --argc;
+ if (argc == 0) {
+ return _wrap_new_arrayC3_t__SWIG_0(self, argc, argv);
}
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
- return resultobj;
+ if (argc == 1) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_arrayC3_t__SWIG_1(self, argc, argv);
+ }
+ }
+
fail:
- return NULL;
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_arrayC3_t'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::array()\n"
+ " std::array< std::complex< double >,3 >::array(std::array< std::complex< double >,3 > const &)\n");
+ return 0;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
- PyObject *result = 0 ;
+ bool result;
if (!args) SWIG_fail;
swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- try {
- result = (PyObject *)(arg1)->next();
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_empty" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = result;
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)((std::array< std::complex< double >,3 > const *)arg1)->empty();
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
- PyObject *result = 0 ;
+ std::array< std::complex< double >,3 >::size_type result;
if (!args) SWIG_fail;
swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- try {
- result = (PyObject *)(arg1)->__next__();
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_size" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = result;
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = ((std::array< std::complex< double >,3 > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- PyObject *swig_obj[1] ;
- PyObject *result = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!args) SWIG_fail;
- swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t_swap", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_swap" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- try {
- result = (PyObject *)(arg1)->previous();
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "arrayC3_t_swap" "', argument " "2"" of type '" "std::array< std::complex< double >,3 > &""'");
}
- resultobj = result;
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t_swap" "', argument " "2"" of type '" "std::array< std::complex< double >,3 > &""'");
+ }
+ arg2 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_begin" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- bool result;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_end" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_bool(static_cast< bool >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- bool result;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::reverse_iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_rbegin" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_bool(static_cast< bool >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::reverse_iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_rend" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
- }
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_front" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (std::array< std::complex< double >,3 >::value_type *) &((std::array< std::complex< double >,3 > const *)arg1)->front();
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_back" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (std::array< std::complex< double >,3 >::value_type *) &((std::array< std::complex< double >,3 > const *)arg1)->back();
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
+ std::array< std::complex< double >,3 >::value_type temp2 ;
+ std::complex< double > val2 ;
int ecode2 = 0 ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[2] ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t_fill", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_fill" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t_fill" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::value_type""'");
}
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
- }
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ temp2 = static_cast< std::array< std::complex< double >,3 >::value_type >(val2);
+ arg2 = &temp2;
+ (arg1)->fill((std::array< std::complex< double >,3 >::value_type const &)*arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_delete_arrayC3_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- ptrdiff_t result;
+ PyObject *swig_obj[1] ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ delete arg1;
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
-}
-
-
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
- Py_ssize_t argc;
- PyObject *argv[3] = {
- 0
- };
-
- if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
- --argc;
- if (argc == 2) {
- int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
- }
- }
- }
- if (argc == 2) {
- int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- {
- int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
- _v = SWIG_CheckState(res);
- }
- if (_v) {
- return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
- }
- }
- }
-
-fail:
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *arrayC3_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
+SWIGINTERN PyObject *arrayC3_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
SWIGINTERN PyObject *_wrap_vdouble1d_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
@@ -44133,6 +46619,86 @@ static PyMethodDef SwigMethods[] = {
"SwigPyIterator___sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t\n"
""},
{ "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
+ { "arrayR3_t_iterator", _wrap_arrayR3_t_iterator, METH_O, "arrayR3_t_iterator(arrayR3_t self) -> SwigPyIterator"},
+ { "arrayR3_t___nonzero__", _wrap_arrayR3_t___nonzero__, METH_O, "arrayR3_t___nonzero__(arrayR3_t self) -> bool"},
+ { "arrayR3_t___bool__", _wrap_arrayR3_t___bool__, METH_O, "arrayR3_t___bool__(arrayR3_t self) -> bool"},
+ { "arrayR3_t___len__", _wrap_arrayR3_t___len__, METH_O, "arrayR3_t___len__(arrayR3_t self) -> std::array< double,3 >::size_type"},
+ { "arrayR3_t___getslice__", _wrap_arrayR3_t___getslice__, METH_VARARGS, "arrayR3_t___getslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j) -> arrayR3_t"},
+ { "arrayR3_t___setslice__", _wrap_arrayR3_t___setslice__, METH_VARARGS, "\n"
+ "arrayR3_t___setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)\n"
+ "arrayR3_t___setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j, arrayR3_t v)\n"
+ ""},
+ { "arrayR3_t___delslice__", _wrap_arrayR3_t___delslice__, METH_VARARGS, "arrayR3_t___delslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)"},
+ { "arrayR3_t___delitem__", _wrap_arrayR3_t___delitem__, METH_VARARGS, "\n"
+ "arrayR3_t___delitem__(arrayR3_t self, std::array< double,3 >::difference_type i)\n"
+ "arrayR3_t___delitem__(arrayR3_t self, PySliceObject * slice)\n"
+ ""},
+ { "arrayR3_t___getitem__", _wrap_arrayR3_t___getitem__, METH_VARARGS, "\n"
+ "arrayR3_t___getitem__(arrayR3_t self, PySliceObject * slice) -> arrayR3_t\n"
+ "arrayR3_t___getitem__(arrayR3_t self, std::array< double,3 >::difference_type i) -> std::array< double,3 >::value_type const &\n"
+ ""},
+ { "arrayR3_t___setitem__", _wrap_arrayR3_t___setitem__, METH_VARARGS, "\n"
+ "arrayR3_t___setitem__(arrayR3_t self, PySliceObject * slice, arrayR3_t v)\n"
+ "arrayR3_t___setitem__(arrayR3_t self, PySliceObject * slice)\n"
+ "arrayR3_t___setitem__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::value_type const & x)\n"
+ ""},
+ { "new_arrayR3_t", _wrap_new_arrayR3_t, METH_VARARGS, "\n"
+ "arrayR3_t()\n"
+ "new_arrayR3_t(arrayR3_t other) -> arrayR3_t\n"
+ ""},
+ { "arrayR3_t_empty", _wrap_arrayR3_t_empty, METH_O, "arrayR3_t_empty(arrayR3_t self) -> bool"},
+ { "arrayR3_t_size", _wrap_arrayR3_t_size, METH_O, "arrayR3_t_size(arrayR3_t self) -> std::array< double,3 >::size_type"},
+ { "arrayR3_t_swap", _wrap_arrayR3_t_swap, METH_VARARGS, "arrayR3_t_swap(arrayR3_t self, arrayR3_t v)"},
+ { "arrayR3_t_begin", _wrap_arrayR3_t_begin, METH_O, "arrayR3_t_begin(arrayR3_t self) -> std::array< double,3 >::iterator"},
+ { "arrayR3_t_end", _wrap_arrayR3_t_end, METH_O, "arrayR3_t_end(arrayR3_t self) -> std::array< double,3 >::iterator"},
+ { "arrayR3_t_rbegin", _wrap_arrayR3_t_rbegin, METH_O, "arrayR3_t_rbegin(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"},
+ { "arrayR3_t_rend", _wrap_arrayR3_t_rend, METH_O, "arrayR3_t_rend(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"},
+ { "arrayR3_t_front", _wrap_arrayR3_t_front, METH_O, "arrayR3_t_front(arrayR3_t self) -> std::array< double,3 >::value_type const &"},
+ { "arrayR3_t_back", _wrap_arrayR3_t_back, METH_O, "arrayR3_t_back(arrayR3_t self) -> std::array< double,3 >::value_type const &"},
+ { "arrayR3_t_fill", _wrap_arrayR3_t_fill, METH_VARARGS, "arrayR3_t_fill(arrayR3_t self, std::array< double,3 >::value_type const & u)"},
+ { "delete_arrayR3_t", _wrap_delete_arrayR3_t, METH_O, "delete_arrayR3_t(arrayR3_t self)"},
+ { "arrayR3_t_swigregister", arrayR3_t_swigregister, METH_O, NULL},
+ { "arrayR3_t_swiginit", arrayR3_t_swiginit, METH_VARARGS, NULL},
+ { "arrayC3_t_iterator", _wrap_arrayC3_t_iterator, METH_O, "arrayC3_t_iterator(arrayC3_t self) -> SwigPyIterator"},
+ { "arrayC3_t___nonzero__", _wrap_arrayC3_t___nonzero__, METH_O, "arrayC3_t___nonzero__(arrayC3_t self) -> bool"},
+ { "arrayC3_t___bool__", _wrap_arrayC3_t___bool__, METH_O, "arrayC3_t___bool__(arrayC3_t self) -> bool"},
+ { "arrayC3_t___len__", _wrap_arrayC3_t___len__, METH_O, "arrayC3_t___len__(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"},
+ { "arrayC3_t___getslice__", _wrap_arrayC3_t___getslice__, METH_VARARGS, "arrayC3_t___getslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j) -> arrayC3_t"},
+ { "arrayC3_t___setslice__", _wrap_arrayC3_t___setslice__, METH_VARARGS, "\n"
+ "arrayC3_t___setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)\n"
+ "arrayC3_t___setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j, arrayC3_t v)\n"
+ ""},
+ { "arrayC3_t___delslice__", _wrap_arrayC3_t___delslice__, METH_VARARGS, "arrayC3_t___delslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)"},
+ { "arrayC3_t___delitem__", _wrap_arrayC3_t___delitem__, METH_VARARGS, "\n"
+ "arrayC3_t___delitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i)\n"
+ "arrayC3_t___delitem__(arrayC3_t self, PySliceObject * slice)\n"
+ ""},
+ { "arrayC3_t___getitem__", _wrap_arrayC3_t___getitem__, METH_VARARGS, "\n"
+ "arrayC3_t___getitem__(arrayC3_t self, PySliceObject * slice) -> arrayC3_t\n"
+ "arrayC3_t___getitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i) -> std::array< std::complex< double >,3 >::value_type const &\n"
+ ""},
+ { "arrayC3_t___setitem__", _wrap_arrayC3_t___setitem__, METH_VARARGS, "\n"
+ "arrayC3_t___setitem__(arrayC3_t self, PySliceObject * slice, arrayC3_t v)\n"
+ "arrayC3_t___setitem__(arrayC3_t self, PySliceObject * slice)\n"
+ "arrayC3_t___setitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::value_type const & x)\n"
+ ""},
+ { "new_arrayC3_t", _wrap_new_arrayC3_t, METH_VARARGS, "\n"
+ "arrayC3_t()\n"
+ "new_arrayC3_t(arrayC3_t other) -> arrayC3_t\n"
+ ""},
+ { "arrayC3_t_empty", _wrap_arrayC3_t_empty, METH_O, "arrayC3_t_empty(arrayC3_t self) -> bool"},
+ { "arrayC3_t_size", _wrap_arrayC3_t_size, METH_O, "arrayC3_t_size(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"},
+ { "arrayC3_t_swap", _wrap_arrayC3_t_swap, METH_VARARGS, "arrayC3_t_swap(arrayC3_t self, arrayC3_t v)"},
+ { "arrayC3_t_begin", _wrap_arrayC3_t_begin, METH_O, "arrayC3_t_begin(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"},
+ { "arrayC3_t_end", _wrap_arrayC3_t_end, METH_O, "arrayC3_t_end(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"},
+ { "arrayC3_t_rbegin", _wrap_arrayC3_t_rbegin, METH_O, "arrayC3_t_rbegin(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"},
+ { "arrayC3_t_rend", _wrap_arrayC3_t_rend, METH_O, "arrayC3_t_rend(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"},
+ { "arrayC3_t_front", _wrap_arrayC3_t_front, METH_O, "arrayC3_t_front(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"},
+ { "arrayC3_t_back", _wrap_arrayC3_t_back, METH_O, "arrayC3_t_back(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"},
+ { "arrayC3_t_fill", _wrap_arrayC3_t_fill, METH_VARARGS, "arrayC3_t_fill(arrayC3_t self, std::array< std::complex< double >,3 >::value_type const & u)"},
+ { "delete_arrayC3_t", _wrap_delete_arrayC3_t, METH_O, "delete_arrayC3_t(arrayC3_t self)"},
+ { "arrayC3_t_swigregister", arrayC3_t_swigregister, METH_O, NULL},
+ { "arrayC3_t_swiginit", arrayC3_t_swiginit, METH_VARARGS, NULL},
{ "vdouble1d_t_iterator", _wrap_vdouble1d_t_iterator, METH_O, "vdouble1d_t_iterator(vdouble1d_t self) -> SwigPyIterator"},
{ "vdouble1d_t___nonzero__", _wrap_vdouble1d_t___nonzero__, METH_O, "vdouble1d_t___nonzero__(vdouble1d_t self) -> bool"},
{ "vdouble1d_t___bool__", _wrap_vdouble1d_t___bool__, METH_O, "vdouble1d_t___bool__(vdouble1d_t self) -> bool"},
@@ -44687,7 +47253,7 @@ static PyMethodDef SwigMethods[] = {
{ "vector_pvacuum_double_t_swiginit", vector_pvacuum_double_t_swiginit, METH_VARARGS, NULL},
{ "new_R3", _wrap_new_R3, METH_VARARGS, "\n"
"R3()\n"
- "new_R3(double const x1, double const y1, double const z1) -> R3\n"
+ "new_R3(double const x, double const y, double const z) -> R3\n"
""},
{ "R3_x", _wrap_R3_x, METH_O, "R3_x(R3 self) -> double"},
{ "R3_y", _wrap_R3_y, METH_O, "R3_y(R3 self) -> double"},
@@ -44784,7 +47350,7 @@ static PyMethodDef SwigMethods[] = {
{ "vector_R3_swiginit", vector_R3_swiginit, METH_VARARGS, NULL},
{ "new_C3", _wrap_new_C3, METH_VARARGS, "\n"
"C3()\n"
- "new_C3(std::complex< double > const x1, std::complex< double > const y1, std::complex< double > const z1) -> C3\n"
+ "new_C3(std::complex< double > const x, std::complex< double > const y, std::complex< double > const z) -> C3\n"
""},
{ "C3_x", _wrap_C3_x, METH_O, "C3_x(C3 self) -> std::complex< double >"},
{ "C3_y", _wrap_C3_y, METH_O, "C3_y(C3 self) -> std::complex< double >"},
@@ -47062,6 +49628,12 @@ static void *_p_FootprintGaussTo_p_INode(void *x, int *SWIGUNUSEDPARM(newmemory)
static void *_p_IDetector2DTo_p_INode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((INode *) (IDetector *) ((IDetector2D *) x));
}
+static void *_p_BasicVector3DT_std__complexT_double_t_tTo_p_std__arrayT_std__complexT_double_t_3_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((std::array< std::complex< double >,3 > *) ((BasicVector3D< std::complex< double > > *) x));
+}
+static void *_p_BasicVector3DT_double_tTo_p_std__arrayT_double_3_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((std::array< double,3 > *) ((BasicVector3D< double > *) x));
+}
static void *_p_ResolutionFunction2DGaussianTo_p_IResolutionFunction2D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((IResolutionFunction2D *) ((ResolutionFunction2DGaussian *) x));
}
@@ -47197,6 +49769,8 @@ static swig_type_info _swigt__p_std__allocatorT_std__string_t = {"_p_std__alloca
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t = {"_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t", "std::vector< std::vector< double > >::allocator_type *|std::allocator< std::vector< double,std::allocator< double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t = {"_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t", "std::vector< std::vector< int > >::allocator_type *|std::allocator< std::vector< int,std::allocator< int > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_unsigned_long_t = {"_p_std__allocatorT_unsigned_long_t", "std::vector< unsigned long >::allocator_type *|std::allocator< unsigned long > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__arrayT_double_3_t = {"_p_std__arrayT_double_3_t", "std::array< double,3 > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__arrayT_std__complexT_double_t_3_t = {"_p_std__arrayT_std__complexT_double_t_3_t", "std::array< std::complex< double >,3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__complexT_double_t = {"_p_std__complexT_double_t", "complex_t *|std::complex< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_void_fSimulationAreaIterator_const_RF_t = {"_p_std__functionT_void_fSimulationAreaIterator_const_RF_t", "std::function< void (IDetector::const_iterator) > *|std::function< void (SimulationAreaIterator const &) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
@@ -47307,6 +49881,8 @@ static swig_type_info *swig_type_initial[] = {
&_swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t,
&_swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t,
&_swigt__p_std__allocatorT_unsigned_long_t,
+ &_swigt__p_std__arrayT_double_3_t,
+ &_swigt__p_std__arrayT_std__complexT_double_t_3_t,
&_swigt__p_std__complexT_double_t,
&_swigt__p_std__functionT_void_fSimulationAreaIterator_const_RF_t,
&_swigt__p_std__invalid_argument,
@@ -47417,6 +49993,8 @@ static swig_cast_info _swigc__p_std__allocatorT_std__string_t[] = { {&_swigt__p
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t[] = { {&_swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t[] = { {&_swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_unsigned_long_t[] = { {&_swigt__p_std__allocatorT_unsigned_long_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__arrayT_double_3_t[] = { {&_swigt__p_BasicVector3DT_double_t, _p_BasicVector3DT_double_tTo_p_std__arrayT_double_3_t, 0, 0}, {&_swigt__p_std__arrayT_double_3_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__arrayT_std__complexT_double_t_3_t[] = { {&_swigt__p_std__arrayT_std__complexT_double_t_3_t, 0, 0, 0}, {&_swigt__p_BasicVector3DT_std__complexT_double_t_t, _p_BasicVector3DT_std__complexT_double_t_tTo_p_std__arrayT_std__complexT_double_t_3_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__complexT_double_t[] = { {&_swigt__p_std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_void_fSimulationAreaIterator_const_RF_t[] = { {&_swigt__p_std__functionT_void_fSimulationAreaIterator_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
@@ -47527,6 +50105,8 @@ static swig_cast_info *swig_cast_initial[] = {
_swigc__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t,
_swigc__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t,
_swigc__p_std__allocatorT_unsigned_long_t,
+ _swigc__p_std__arrayT_double_3_t,
+ _swigc__p_std__arrayT_std__complexT_double_t_3_t,
_swigc__p_std__complexT_double_t,
_swigc__p_std__functionT_void_fSimulationAreaIterator_const_RF_t,
_swigc__p_std__invalid_argument,
diff --git a/auto/Wrap/libBornAgainFit.py b/auto/Wrap/libBornAgainFit.py
index a248b30d0b6..8630b92f331 100644
--- a/auto/Wrap/libBornAgainFit.py
+++ b/auto/Wrap/libBornAgainFit.py
@@ -157,6 +157,230 @@ def deprecated(message):
return deprecated_func
return deprecated_decorator
+class arrayR3_t(object):
+ r"""Proxy of C++ std::array< double,3 > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(arrayR3_t self) -> SwigPyIterator"""
+ return _libBornAgainFit.arrayR3_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(arrayR3_t self) -> bool"""
+ return _libBornAgainFit.arrayR3_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(arrayR3_t self) -> bool"""
+ return _libBornAgainFit.arrayR3_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(arrayR3_t self) -> std::array< double,3 >::size_type"""
+ return _libBornAgainFit.arrayR3_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j) -> arrayR3_t"""
+ return _libBornAgainFit.arrayR3_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)
+ __setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j, arrayR3_t v)
+ """
+ return _libBornAgainFit.arrayR3_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)"""
+ return _libBornAgainFit.arrayR3_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(arrayR3_t self, std::array< double,3 >::difference_type i)
+ __delitem__(arrayR3_t self, PySliceObject * slice)
+ """
+ return _libBornAgainFit.arrayR3_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(arrayR3_t self, PySliceObject * slice) -> arrayR3_t
+ __getitem__(arrayR3_t self, std::array< double,3 >::difference_type i) -> std::array< double,3 >::value_type const &
+ """
+ return _libBornAgainFit.arrayR3_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(arrayR3_t self, PySliceObject * slice, arrayR3_t v)
+ __setitem__(arrayR3_t self, PySliceObject * slice)
+ __setitem__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::value_type const & x)
+ """
+ return _libBornAgainFit.arrayR3_t___setitem__(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(arrayR3_t self) -> arrayR3_t
+ __init__(arrayR3_t self, arrayR3_t other) -> arrayR3_t
+ """
+ _libBornAgainFit.arrayR3_t_swiginit(self, _libBornAgainFit.new_arrayR3_t(*args))
+
+ def empty(self):
+ r"""empty(arrayR3_t self) -> bool"""
+ return _libBornAgainFit.arrayR3_t_empty(self)
+
+ def size(self):
+ r"""size(arrayR3_t self) -> std::array< double,3 >::size_type"""
+ return _libBornAgainFit.arrayR3_t_size(self)
+
+ def swap(self, v):
+ r"""swap(arrayR3_t self, arrayR3_t v)"""
+ return _libBornAgainFit.arrayR3_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(arrayR3_t self) -> std::array< double,3 >::iterator"""
+ return _libBornAgainFit.arrayR3_t_begin(self)
+
+ def end(self):
+ r"""end(arrayR3_t self) -> std::array< double,3 >::iterator"""
+ return _libBornAgainFit.arrayR3_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"""
+ return _libBornAgainFit.arrayR3_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"""
+ return _libBornAgainFit.arrayR3_t_rend(self)
+
+ def front(self):
+ r"""front(arrayR3_t self) -> std::array< double,3 >::value_type const &"""
+ return _libBornAgainFit.arrayR3_t_front(self)
+
+ def back(self):
+ r"""back(arrayR3_t self) -> std::array< double,3 >::value_type const &"""
+ return _libBornAgainFit.arrayR3_t_back(self)
+
+ def fill(self, u):
+ r"""fill(arrayR3_t self, std::array< double,3 >::value_type const & u)"""
+ return _libBornAgainFit.arrayR3_t_fill(self, u)
+ __swig_destroy__ = _libBornAgainFit.delete_arrayR3_t
+
+# Register arrayR3_t in _libBornAgainFit:
+_libBornAgainFit.arrayR3_t_swigregister(arrayR3_t)
+
+class arrayC3_t(object):
+ r"""Proxy of C++ std::array< std::complex< double >,3 > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(arrayC3_t self) -> SwigPyIterator"""
+ return _libBornAgainFit.arrayC3_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(arrayC3_t self) -> bool"""
+ return _libBornAgainFit.arrayC3_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(arrayC3_t self) -> bool"""
+ return _libBornAgainFit.arrayC3_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"""
+ return _libBornAgainFit.arrayC3_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j) -> arrayC3_t"""
+ return _libBornAgainFit.arrayC3_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)
+ __setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j, arrayC3_t v)
+ """
+ return _libBornAgainFit.arrayC3_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)"""
+ return _libBornAgainFit.arrayC3_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i)
+ __delitem__(arrayC3_t self, PySliceObject * slice)
+ """
+ return _libBornAgainFit.arrayC3_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(arrayC3_t self, PySliceObject * slice) -> arrayC3_t
+ __getitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i) -> std::array< std::complex< double >,3 >::value_type const &
+ """
+ return _libBornAgainFit.arrayC3_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(arrayC3_t self, PySliceObject * slice, arrayC3_t v)
+ __setitem__(arrayC3_t self, PySliceObject * slice)
+ __setitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::value_type const & x)
+ """
+ return _libBornAgainFit.arrayC3_t___setitem__(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(arrayC3_t self) -> arrayC3_t
+ __init__(arrayC3_t self, arrayC3_t other) -> arrayC3_t
+ """
+ _libBornAgainFit.arrayC3_t_swiginit(self, _libBornAgainFit.new_arrayC3_t(*args))
+
+ def empty(self):
+ r"""empty(arrayC3_t self) -> bool"""
+ return _libBornAgainFit.arrayC3_t_empty(self)
+
+ def size(self):
+ r"""size(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"""
+ return _libBornAgainFit.arrayC3_t_size(self)
+
+ def swap(self, v):
+ r"""swap(arrayC3_t self, arrayC3_t v)"""
+ return _libBornAgainFit.arrayC3_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"""
+ return _libBornAgainFit.arrayC3_t_begin(self)
+
+ def end(self):
+ r"""end(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"""
+ return _libBornAgainFit.arrayC3_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"""
+ return _libBornAgainFit.arrayC3_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"""
+ return _libBornAgainFit.arrayC3_t_rend(self)
+
+ def front(self):
+ r"""front(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"""
+ return _libBornAgainFit.arrayC3_t_front(self)
+
+ def back(self):
+ r"""back(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"""
+ return _libBornAgainFit.arrayC3_t_back(self)
+
+ def fill(self, u):
+ r"""fill(arrayC3_t self, std::array< std::complex< double >,3 >::value_type const & u)"""
+ return _libBornAgainFit.arrayC3_t_fill(self, u)
+ __swig_destroy__ = _libBornAgainFit.delete_arrayC3_t
+
+# Register arrayC3_t in _libBornAgainFit:
+_libBornAgainFit.arrayC3_t_swigregister(arrayC3_t)
+
class vdouble1d_t(object):
r"""Proxy of C++ std::vector< double > class."""
diff --git a/auto/Wrap/libBornAgainFit_wrap.cpp b/auto/Wrap/libBornAgainFit_wrap.cpp
index a1ed1611925..678b6a1666c 100644
--- a/auto/Wrap/libBornAgainFit_wrap.cpp
+++ b/auto/Wrap/libBornAgainFit_wrap.cpp
@@ -3136,28 +3136,30 @@ namespace Swig {
#define SWIGTYPE_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t swig_types[36]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t swig_types[37]
#define SWIGTYPE_p_std__allocatorT_unsigned_long_t swig_types[38]
-#define SWIGTYPE_p_std__invalid_argument swig_types[39]
-#define SWIGTYPE_p_std__lessT_std__string_t swig_types[40]
-#define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[41]
-#define SWIGTYPE_p_std__pairT_double_double_t swig_types[42]
-#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[43]
-#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[44]
-#define SWIGTYPE_p_std__vectorT_mumufit__Parameter_std__allocatorT_mumufit__Parameter_t_t__const_iterator swig_types[45]
-#define SWIGTYPE_p_std__vectorT_mumufit__Parameter_std__allocatorT_mumufit__Parameter_t_t__iterator swig_types[46]
-#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[47]
-#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[48]
-#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[49]
-#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[50]
-#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[51]
-#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[52]
-#define SWIGTYPE_p_swig__SwigPyIterator swig_types[53]
-#define SWIGTYPE_p_unsigned_char swig_types[54]
-#define SWIGTYPE_p_unsigned_int swig_types[55]
-#define SWIGTYPE_p_unsigned_long_long swig_types[56]
-#define SWIGTYPE_p_unsigned_short swig_types[57]
-#define SWIGTYPE_p_value_type swig_types[58]
-static swig_type_info *swig_types[60];
-static swig_module_info swig_module = {swig_types, 59, 0, 0, 0, 0};
+#define SWIGTYPE_p_std__arrayT_double_3_t swig_types[39]
+#define SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t swig_types[40]
+#define SWIGTYPE_p_std__invalid_argument swig_types[41]
+#define SWIGTYPE_p_std__lessT_std__string_t swig_types[42]
+#define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[43]
+#define SWIGTYPE_p_std__pairT_double_double_t swig_types[44]
+#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[45]
+#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[46]
+#define SWIGTYPE_p_std__vectorT_mumufit__Parameter_std__allocatorT_mumufit__Parameter_t_t__const_iterator swig_types[47]
+#define SWIGTYPE_p_std__vectorT_mumufit__Parameter_std__allocatorT_mumufit__Parameter_t_t__iterator swig_types[48]
+#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[49]
+#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[50]
+#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[51]
+#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[52]
+#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[53]
+#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[54]
+#define SWIGTYPE_p_swig__SwigPyIterator swig_types[55]
+#define SWIGTYPE_p_unsigned_char swig_types[56]
+#define SWIGTYPE_p_unsigned_int swig_types[57]
+#define SWIGTYPE_p_unsigned_long_long swig_types[58]
+#define SWIGTYPE_p_unsigned_short swig_types[59]
+#define SWIGTYPE_p_value_type swig_types[60]
+static swig_type_info *swig_types[62];
+static swig_module_info swig_module = {swig_types, 61, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
@@ -4992,48 +4994,104 @@ namespace swig {
namespace swig {
- template <class T>
- struct traits_reserve<std::vector<T> > {
- static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
- seq.reserve(n);
+ template <class T, size_t N>
+ struct traits_asptr<std::array<T, N> > {
+ static int asptr(PyObject *obj, std::array<T, N> **vec) {
+ return traits_asptr_stdseq<std::array<T, N> >::asptr(obj, vec);
}
};
- template <class T>
- struct traits_asptr<std::vector<T> > {
- static int asptr(PyObject *obj, std::vector<T> **vec) {
- return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+ template <class T, size_t N>
+ struct traits_from<std::array<T, N> > {
+ static PyObject *from(const std::array<T, N>& vec) {
+ return traits_from_stdseq<std::array<T, N> >::from(vec);
}
};
-
- template <class T>
- struct traits_from<std::vector<T> > {
- static PyObject *from(const std::vector<T>& vec) {
- return traits_from_stdseq<std::vector<T> >::from(vec);
+
+ template <class SwigPySeq, class T, size_t N>
+ inline void
+ assign(const SwigPySeq& swigpyseq, std::array<T, N>* seq) {
+ if (swigpyseq.size() < seq->size())
+ throw std::invalid_argument("std::array cannot be expanded in size");
+ else if (swigpyseq.size() > seq->size())
+ throw std::invalid_argument("std::array cannot be reduced in size");
+ std::copy(swigpyseq.begin(), swigpyseq.end(), seq->begin());
+ }
+
+ template <class T, size_t N>
+ inline void
+ erase(std::array<T, N>* SWIGUNUSEDPARM(seq), const typename std::array<T, N>::iterator& SWIGUNUSEDPARM(position)) {
+ throw std::invalid_argument("std::array object does not support item deletion");
+ }
+
+ // Only limited slicing is supported as std::array is fixed in size
+ template <class T, size_t N, class Difference>
+ inline std::array<T, N>*
+ getslice(const std::array<T, N>* self, Difference i, Difference j, Py_ssize_t step) {
+ typedef std::array<T, N> Sequence;
+ typename Sequence::size_type size = self->size();
+ Difference ii = 0;
+ Difference jj = 0;
+ swig::slice_adjust(i, j, step, size, ii, jj);
+
+ if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
+ Sequence *sequence = new Sequence();
+ std::copy(self->begin(), self->end(), sequence->begin());
+ return sequence;
+ } else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
+ Sequence *sequence = new Sequence();
+ std::copy(self->rbegin(), self->rend(), sequence->begin());
+ return sequence;
+ } else {
+ throw std::invalid_argument("std::array object only supports getting a slice that is the size of the array");
}
- };
+ }
+
+ template <class T, size_t N, class Difference, class InputSeq>
+ inline void
+ setslice(std::array<T, N>* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
+ typedef std::array<T, N> Sequence;
+ typename Sequence::size_type size = self->size();
+ Difference ii = 0;
+ Difference jj = 0;
+ swig::slice_adjust(i, j, step, size, ii, jj, true);
+
+ if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
+ std::copy(is.begin(), is.end(), self->begin());
+ } else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
+ std::copy(is.rbegin(), is.rend(), self->begin());
+ } else {
+ throw std::invalid_argument("std::array object only supports setting a slice that is the size of the array");
+ }
+ }
+
+ template <class T, size_t N, class Difference>
+ inline void
+ delslice(std::array<T, N>* SWIGUNUSEDPARM(self), Difference SWIGUNUSEDPARM(i), Difference SWIGUNUSEDPARM(j), Py_ssize_t SWIGUNUSEDPARM(step)) {
+ throw std::invalid_argument("std::array object does not support item deletion");
+ }
}
namespace swig {
- template <> struct traits<std::vector< double, std::allocator< double > > > {
+ template <> struct traits<std::array< double, 3 > > {
typedef pointer_category category;
static const char* type_name() {
- return "std::vector<" "double" "," "std::allocator< double >" " >";
+ return "std::array<" "double" "," "3" " >";
}
};
}
-SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_array_Sl_double_Sc_3_Sg__iterator(std::array< double,3 > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
+SWIGINTERN bool std_array_Sl_double_Sc_3_Sg____nonzero__(std::array< double,3 > const *self){
return !(self->empty());
}
-SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
+SWIGINTERN bool std_array_Sl_double_Sc_3_Sg____bool__(std::array< double,3 > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
+SWIGINTERN std::array< double,3 >::size_type std_array_Sl_double_Sc_3_Sg____len__(std::array< double,3 > const *self){
return self->size();
}
@@ -5070,66 +5128,66 @@ SWIG_From_size_t (size_t value)
#endif
}
-SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+SWIGINTERN std::array< double,3 > *std_array_Sl_double_Sc_3_Sg____getslice__(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
return swig::getslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
- swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setslice____SWIG_0(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
+ swig::setslice(self, i, j, 1, std::array< double,3 >());
}
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setslice____SWIG_1(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j,std::array< double,3 > const &v){
swig::setslice(self, i, j, 1, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delslice__(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
swig::delslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delitem____SWIG_0(std::array< double,3 > *self,std::array< double,3 >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN std::array< double,3 > *std_array_Sl_double_Sc_3_Sg____getitem____SWIG_0(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_0(std::array< double,3 > *self,PySliceObject *slice,std::array< double,3 > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_1(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delitem____SWIG_1(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
+SWIGINTERN std::array< double,3 >::value_type const &std_array_Sl_double_Sc_3_Sg____getitem____SWIG_1(std::array< double,3 > const *self,std::array< double,3 >::difference_type i){
return *(swig::cgetpos(self, i));
}
@@ -5167,227 +5225,476 @@ namespace swig {
};
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_2(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
-SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
- if (self->size() == 0)
- throw std::out_of_range("pop from empty container");
- std::vector< double,std::allocator< double > >::value_type x = self->back();
- self->pop_back();
- return x;
+
+SWIGINTERN int
+SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
+{
+ if (PyComplex_Check(o)) {
+ if (val) *val = std::complex<double>(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
+ return SWIG_OK;
+ } else {
+ double d;
+ int res = SWIG_AddCast(SWIG_AsVal_double (o, &d));
+ if (SWIG_IsOK(res)) {
+ if (val) *val = std::complex<double>(d, 0.0);
+ return res;
}
-SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
- self->push_back(x);
+ }
+ return SWIG_TypeError;
+}
+
+
+SWIGINTERNINLINE PyObject*
+SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/local/share/swig/4.0.2/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+
+const std::complex<double>&
+
+
+
+/*@SWIG@*/ c)
+{
+ return PyComplex_FromDoubles(std::real(c), std::imag(c));
+}
+
+
+namespace swig {
+ template <> struct traits< std::complex<double> > {
+ typedef value_category category;
+ static const char* type_name() { return"std::complex<double>"; }
+ };
+ template <> struct traits_asval< std::complex<double> > {
+ typedef std::complex<double> value_type;
+ static int asval(PyObject *obj, value_type *val) {
+ return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
}
-SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos){ return self->erase(pos); }
-SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_1(std::vector< double > *self,std::vector< double >::iterator first,std::vector< double >::iterator last){ return self->erase(first, last); }
-SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::value_type const &x){ return self->insert(pos, x); }
-SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }
+ };
+ template <> struct traits_from< std::complex<double> > {
+ typedef std::complex<double> value_type;
+ static PyObject *from(const value_type& val) {
+ return SWIG_From_std_complex_Sl_double_Sg_ (val);
+ }
+ };
+}
+
namespace swig {
- template <> struct traits<std::vector< std::vector< double,std::allocator< double > >, std::allocator< std::vector< double,std::allocator< double > > > > > {
+ template <> struct traits<std::array< std::complex< double >, 3 > > {
typedef pointer_category category;
static const char* type_name() {
- return "std::vector<" "std::vector< double,std::allocator< double > >" "," "std::allocator< std::vector< double,std::allocator< double > > >" " >";
+ return "std::array<" "std::complex< double >" "," "3" " >";
}
};
}
-SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_vector_Sl_double_Sg__Sg__iterator(std::vector< std::vector< double > > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg__iterator(std::array< std::complex< double >,3 > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____nonzero__(std::vector< std::vector< double > > const *self){
+SWIGINTERN bool std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____nonzero__(std::array< std::complex< double >,3 > const *self){
return !(self->empty());
}
-SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____bool__(std::vector< std::vector< double > > const *self){
+SWIGINTERN bool std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____bool__(std::array< std::complex< double >,3 > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector< std::vector< double > >::size_type std_vector_Sl_std_vector_Sl_double_Sg__Sg____len__(std::vector< std::vector< double > > const *self){
+SWIGINTERN std::array< std::complex< double >,3 >::size_type std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____len__(std::array< std::complex< double >,3 > const *self){
return self->size();
}
-SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
+SWIGINTERN std::array< std::complex< double >,3 > *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getslice__(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
return swig::getslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
- swig::setslice(self, i, j, 1, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >());
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_0(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
+ swig::setslice(self, i, j, 1, std::array< std::complex< double >,3 >());
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_1(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j,std::array< std::complex< double >,3 > const &v){
swig::setslice(self, i, j, 1, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delslice__(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
swig::delslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_0(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN std::array< std::complex< double >,3 > *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_0(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_0(std::array< std::complex< double >,3 > *self,PySliceObject *slice,std::array< std::complex< double >,3 > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_1(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_1(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN std::vector< std::vector< double > >::value_type const &std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_1(std::vector< std::vector< double > > const *self,std::vector< std::vector< double > >::difference_type i){
+SWIGINTERN std::array< std::complex< double >,3 >::value_type const &std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_1(std::array< std::complex< double >,3 > const *self,std::array< std::complex< double >,3 >::difference_type i){
return *(swig::cgetpos(self, i));
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_2(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::value_type const &x){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_2(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
-SWIGINTERN std::vector< std::vector< double > >::value_type std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(std::vector< std::vector< double > > *self){
- if (self->size() == 0)
- throw std::out_of_range("pop from empty container");
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type x = self->back();
- self->pop_back();
- return x;
- }
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__append(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::value_type const &x){
- self->push_back(x);
- }
-SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos){ return self->erase(pos); }
-SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator first,std::vector< std::vector< double > >::iterator last){ return self->erase(first, last); }
-SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos,std::vector< std::vector< double > >::value_type const &x){ return self->insert(pos, x); }
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos,std::vector< std::vector< double > >::size_type n,std::vector< std::vector< double > >::value_type const &x){ self->insert(pos, n, x); }
-
-SWIGINTERN int
-SWIG_AsVal_int (PyObject * obj, int *val)
-{
- long v;
- int res = SWIG_AsVal_long (obj, &v);
- if (SWIG_IsOK(res)) {
- if ((v < INT_MIN || v > INT_MAX)) {
- return SWIG_OverflowError;
- } else {
- if (val) *val = static_cast< int >(v);
- }
- }
- return res;
-}
+ namespace swig {
+ template <class T>
+ struct traits_reserve<std::vector<T> > {
+ static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
+ seq.reserve(n);
+ }
+ };
-namespace swig {
- template <> struct traits< int > {
- typedef value_category category;
- static const char* type_name() { return"int"; }
- };
- template <> struct traits_asval< int > {
- typedef int value_type;
- static int asval(PyObject *obj, value_type *val) {
- return SWIG_AsVal_int (obj, val);
- }
- };
- template <> struct traits_from< int > {
- typedef int value_type;
- static PyObject *from(const value_type& val) {
- return SWIG_From_int (val);
- }
- };
-}
+ template <class T>
+ struct traits_asptr<std::vector<T> > {
+ static int asptr(PyObject *obj, std::vector<T> **vec) {
+ return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+ }
+ };
+
+ template <class T>
+ struct traits_from<std::vector<T> > {
+ static PyObject *from(const std::vector<T>& vec) {
+ return traits_from_stdseq<std::vector<T> >::from(vec);
+ }
+ };
+ }
namespace swig {
- template <> struct traits<std::vector< int, std::allocator< int > > > {
+ template <> struct traits<std::vector< double, std::allocator< double > > > {
typedef pointer_category category;
static const char* type_name() {
- return "std::vector<" "int" "," "std::allocator< int >" " >";
+ return "std::vector<" "double" "," "std::allocator< double >" " >";
}
};
}
-SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
+SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
return !(self->empty());
}
-SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
+SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
+SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
return self->size();
}
-SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
return swig::getslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
- swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >());
+SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+ swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
}
-SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
swig::setslice(self, i, j, 1, v);
}
-SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
+SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
swig::delslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< int,std::allocator< int > >::difference_type id = i;
- std::vector< int,std::allocator< int > >::difference_type jd = j;
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< int,std::allocator< int > >::difference_type id = i;
- std::vector< int,std::allocator< int > >::difference_type jd = j;
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< int,std::allocator< int > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
+ return *(swig::cgetpos(self, i));
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
+ *(swig::getpos(self,i)) = x;
+ }
+SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
+ if (self->size() == 0)
+ throw std::out_of_range("pop from empty container");
+ std::vector< double,std::allocator< double > >::value_type x = self->back();
+ self->pop_back();
+ return x;
+ }
+SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
+ self->push_back(x);
+ }
+SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos){ return self->erase(pos); }
+SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_1(std::vector< double > *self,std::vector< double >::iterator first,std::vector< double >::iterator last){ return self->erase(first, last); }
+SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::value_type const &x){ return self->insert(pos, x); }
+SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }
+
+ namespace swig {
+ template <> struct traits<std::vector< std::vector< double,std::allocator< double > >, std::allocator< std::vector< double,std::allocator< double > > > > > {
+ typedef pointer_category category;
+ static const char* type_name() {
+ return "std::vector<" "std::vector< double,std::allocator< double > >" "," "std::allocator< std::vector< double,std::allocator< double > > >" " >";
+ }
+ };
+ }
+
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_vector_Sl_double_Sg__Sg__iterator(std::vector< std::vector< double > > *self,PyObject **PYTHON_SELF){
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+ }
+SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____nonzero__(std::vector< std::vector< double > > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____bool__(std::vector< std::vector< double > > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN std::vector< std::vector< double > >::size_type std_vector_Sl_std_vector_Sl_double_Sg__Sg____len__(std::vector< std::vector< double > > const *self){
+ return self->size();
+ }
+SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
+ return swig::getslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
+ swig::setslice(self, i, j, 1, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >());
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+ swig::setslice(self, i, j, 1, v);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
+ swig::delslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
+ swig::erase(self, swig::getpos(self, i));
+ }
+SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ return swig::getslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ swig::setslice(self, id, jd, step, v);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN std::vector< std::vector< double > >::value_type const &std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_1(std::vector< std::vector< double > > const *self,std::vector< std::vector< double > >::difference_type i){
+ return *(swig::cgetpos(self, i));
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_2(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::value_type const &x){
+ *(swig::getpos(self,i)) = x;
+ }
+SWIGINTERN std::vector< std::vector< double > >::value_type std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(std::vector< std::vector< double > > *self){
+ if (self->size() == 0)
+ throw std::out_of_range("pop from empty container");
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type x = self->back();
+ self->pop_back();
+ return x;
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__append(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::value_type const &x){
+ self->push_back(x);
+ }
+SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos){ return self->erase(pos); }
+SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator first,std::vector< std::vector< double > >::iterator last){ return self->erase(first, last); }
+SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos,std::vector< std::vector< double > >::value_type const &x){ return self->insert(pos, x); }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos,std::vector< std::vector< double > >::size_type n,std::vector< std::vector< double > >::value_type const &x){ self->insert(pos, n, x); }
+
+SWIGINTERN int
+SWIG_AsVal_int (PyObject * obj, int *val)
+{
+ long v;
+ int res = SWIG_AsVal_long (obj, &v);
+ if (SWIG_IsOK(res)) {
+ if ((v < INT_MIN || v > INT_MAX)) {
+ return SWIG_OverflowError;
+ } else {
+ if (val) *val = static_cast< int >(v);
+ }
+ }
+ return res;
+}
+
+
+namespace swig {
+ template <> struct traits< int > {
+ typedef value_category category;
+ static const char* type_name() { return"int"; }
+ };
+ template <> struct traits_asval< int > {
+ typedef int value_type;
+ static int asval(PyObject *obj, value_type *val) {
+ return SWIG_AsVal_int (obj, val);
+ }
+ };
+ template <> struct traits_from< int > {
+ typedef int value_type;
+ static PyObject *from(const value_type& val) {
+ return SWIG_From_int (val);
+ }
+ };
+}
+
+
+ namespace swig {
+ template <> struct traits<std::vector< int, std::allocator< int > > > {
+ typedef pointer_category category;
+ static const char* type_name() {
+ return "std::vector<" "int" "," "std::allocator< int >" " >";
+ }
+ };
+ }
+
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+ }
+SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
+ return self->size();
+ }
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
+ return swig::getslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
+ swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >());
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
+ swig::setslice(self, i, j, 1, v);
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
+ swig::delslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
+ swig::erase(self, swig::getpos(self, i));
+ }
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< int,std::allocator< int > >::difference_type id = i;
+ std::vector< int,std::allocator< int > >::difference_type jd = j;
+ return swig::getslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< int,std::allocator< int > >::difference_type id = i;
+ std::vector< int,std::allocator< int > >::difference_type jd = j;
+ swig::setslice(self, id, jd, step, v);
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
@@ -5645,57 +5952,6 @@ SWIGINTERN std::vector< unsigned long >::iterator std_vector_Sl_unsigned_SS_long
SWIGINTERN std::vector< unsigned long >::iterator std_vector_Sl_unsigned_SS_long_Sg__insert__SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::iterator pos,std::vector< unsigned long >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg__insert__SWIG_1(std::vector< unsigned long > *self,std::vector< unsigned long >::iterator pos,std::vector< unsigned long >::size_type n,std::vector< unsigned long >::value_type const &x){ self->insert(pos, n, x); }
-SWIGINTERN int
-SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
-{
- if (PyComplex_Check(o)) {
- if (val) *val = std::complex<double>(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
- return SWIG_OK;
- } else {
- double d;
- int res = SWIG_AddCast(SWIG_AsVal_double (o, &d));
- if (SWIG_IsOK(res)) {
- if (val) *val = std::complex<double>(d, 0.0);
- return res;
- }
- }
- return SWIG_TypeError;
-}
-
-
-SWIGINTERNINLINE PyObject*
-SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/local/share/swig/4.0.2/typemaps/swigmacros.swg,104,%ifcplusplus@*/
-
-const std::complex<double>&
-
-
-
-/*@SWIG@*/ c)
-{
- return PyComplex_FromDoubles(std::real(c), std::imag(c));
-}
-
-
-namespace swig {
- template <> struct traits< std::complex<double> > {
- typedef value_category category;
- static const char* type_name() { return"std::complex<double>"; }
- };
- template <> struct traits_asval< std::complex<double> > {
- typedef std::complex<double> value_type;
- static int asval(PyObject *obj, value_type *val) {
- return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
- }
- };
- template <> struct traits_from< std::complex<double> > {
- typedef std::complex<double> value_type;
- static PyObject *from(const value_type& val) {
- return SWIG_From_std_complex_Sl_double_Sg_ (val);
- }
- };
-}
-
-
namespace swig {
template <> struct traits<std::vector< std::complex< double >, std::allocator< std::complex< double > > > > {
typedef pointer_category category;
@@ -7294,280 +7550,2510 @@ fail:
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ bool result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ ptrdiff_t result;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PyObject **arg2 = (PyObject **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ arg2 = &swig_obj[0];
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_iterator" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (swig::SwigPyIterator *)std_array_Sl_double_Sc_3_Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___nonzero__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)std_array_Sl_double_Sc_3_Sg____nonzero__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___bool__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)std_array_Sl_double_Sc_3_Sg____bool__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___len__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = std_array_Sl_double_Sc_3_Sg____len__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ std::array< double,3 > *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t___getslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___getslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___getslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ result = (std::array< double,3 > *)std_array_Sl_double_Sc_3_Sg____getslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_double_Sc_3_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ std::array< double,3 > *arg4 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ int res4 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res4 = swig::asptr(swig_obj[3], &ptr);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "arrayR3_t___setslice__" "', argument " "4"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t___setslice__" "', argument " "4"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg4 = ptr;
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::array< double,3 > const &)*arg4);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[5] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___setslice__", 0, 4, argv))) SWIG_fail;
+ --argc;
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setslice____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[3], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayR3_t___setslice____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___setslice__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__setslice__(std::array< double,3 >::difference_type,std::array< double,3 >::difference_type)\n"
+ " std::array< double,3 >::__setslice__(std::array< double,3 >::difference_type,std::array< double,3 >::difference_type,std::array< double,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t___delslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___delslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___delslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_double_Sc_3_Sg____delslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___delitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ try {
+ std_array_Sl_double_Sc_3_Sg____delitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ result = (std::array< double,3 > *)std_array_Sl_double_Sc_3_Sg____getitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::array< double,3 > *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res3 = swig::asptr(swig_obj[2], &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg3 = ptr;
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_0(arg1,arg2,(std::array< double,3 > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____delitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___delitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___delitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___delitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__delitem__(std::array< double,3 >::difference_type)\n"
+ " std::array< double,3 >::__delitem__(PySliceObject *)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getitem__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___getitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ try {
+ result = (std::array< double,3 >::value_type *) &std_array_Sl_double_Sc_3_Sg____getitem____SWIG_1((std::array< double,3 > const *)arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___getitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___getitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___getitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__getitem__(PySliceObject *)\n"
+ " std::array< double,3 >::__getitem__(std::array< double,3 >::difference_type) const\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::value_type *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< double,3 >::value_type temp3 ;
+ double val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 >::value_type""'");
+ }
+ temp3 = static_cast< std::array< double,3 >::value_type >(val3);
+ arg3 = &temp3;
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_2(arg1,arg2,(double const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[4] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___setitem__", 0, 3, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_2(self, argc, argv);
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___setitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__setitem__(PySliceObject *,std::array< double,3 > const &)\n"
+ " std::array< double,3 >::__setitem__(PySliceObject *)\n"
+ " std::array< double,3 >::__setitem__(std::array< double,3 >::difference_type,std::array< double,3 >::value_type const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
+ result = (std::array< double,3 > *)new std::array< double,3 >();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_NEW | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = 0 ;
+ int res1 = SWIG_OLDOBJ ;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res1 = swig::asptr(swig_obj[0], &ptr);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg1 = ptr;
+ }
+ result = (std::array< double,3 > *)new std::array< double,3 >((std::array< double,3 > const &)*arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_NEW | 0 );
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[2] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "new_arrayR3_t", 0, 1, argv))) SWIG_fail;
+ --argc;
+ if (argc == 0) {
+ return _wrap_new_arrayR3_t__SWIG_0(self, argc, argv);
+ }
+ if (argc == 1) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_arrayR3_t__SWIG_1(self, argc, argv);
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_arrayR3_t'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::array()\n"
+ " std::array< double,3 >::array(std::array< double,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_empty" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)((std::array< double,3 > const *)arg1)->empty();
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_size" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = ((std::array< double,3 > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 > *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t_swap", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_swap" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__arrayT_double_3_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "arrayR3_t_swap" "', argument " "2"" of type '" "std::array< double,3 > &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t_swap" "', argument " "2"" of type '" "std::array< double,3 > &""'");
+ }
+ arg2 = reinterpret_cast< std::array< double,3 > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_begin" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_end" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::reverse_iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_rbegin" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::reverse_iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_rend" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_front" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (std::array< double,3 >::value_type *) &((std::array< double,3 > const *)arg1)->front();
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_back" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (std::array< double,3 >::value_type *) &((std::array< double,3 > const *)arg1)->back();
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::value_type *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< double,3 >::value_type temp2 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t_fill", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_fill" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t_fill" "', argument " "2"" of type '" "std::array< double,3 >::value_type""'");
+ }
+ temp2 = static_cast< std::array< double,3 >::value_type >(val2);
+ arg2 = &temp2;
+ (arg1)->fill((std::array< double,3 >::value_type const &)*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_arrayR3_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ delete arg1;
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *arrayR3_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__arrayT_double_3_t, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *arrayR3_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PyObject **arg2 = (PyObject **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ arg2 = &swig_obj[0];
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_iterator" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (swig::SwigPyIterator *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___nonzero__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____nonzero__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___bool__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____bool__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___len__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____len__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t___getslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___getslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___getslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ result = (std::array< std::complex< double >,3 > *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ std::array< std::complex< double >,3 > *arg4 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ int res4 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res4 = swig::asptr(swig_obj[3], &ptr);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "arrayC3_t___setslice__" "', argument " "4"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t___setslice__" "', argument " "4"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg4 = ptr;
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::array< std::complex< double >,3 > const &)*arg4);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[5] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___setslice__", 0, 4, argv))) SWIG_fail;
+ --argc;
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setslice____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[3], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayC3_t___setslice____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___setslice__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__setslice__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::difference_type)\n"
+ " std::array< std::complex< double >,3 >::__setslice__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t___delslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___delslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___delslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___delitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ result = (std::array< std::complex< double >,3 > *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::array< std::complex< double >,3 > *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res3 = swig::asptr(swig_obj[2], &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg3 = ptr;
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_0(arg1,arg2,(std::array< std::complex< double >,3 > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___delitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___delitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___delitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__delitem__(std::array< std::complex< double >,3 >::difference_type)\n"
+ " std::array< std::complex< double >,3 >::__delitem__(PySliceObject *)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___getitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ try {
+ result = (std::array< std::complex< double >,3 >::value_type *) &std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_1((std::array< std::complex< double >,3 > const *)arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___getitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___getitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___getitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__getitem__(PySliceObject *)\n"
+ " std::array< std::complex< double >,3 >::__getitem__(std::array< std::complex< double >,3 >::difference_type) const\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::value_type *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< std::complex< double >,3 >::value_type temp3 ;
+ std::complex< double > val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_std_complex_Sl_double_Sg_(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::value_type""'");
+ }
+ temp3 = static_cast< std::array< std::complex< double >,3 >::value_type >(val3);
+ arg3 = &temp3;
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_2(arg1,arg2,(std::complex< double > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[4] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___setitem__", 0, 3, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_2(self, argc, argv);
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___setitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__setitem__(PySliceObject *,std::array< std::complex< double >,3 > const &)\n"
+ " std::array< std::complex< double >,3 >::__setitem__(PySliceObject *)\n"
+ " std::array< std::complex< double >,3 >::__setitem__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::value_type const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayC3_t__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
+ result = (std::array< std::complex< double >,3 > *)new std::array< std::complex< double >,3 >();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_NEW | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayC3_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = 0 ;
+ int res1 = SWIG_OLDOBJ ;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res1 = swig::asptr(swig_obj[0], &ptr);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg1 = ptr;
+ }
+ result = (std::array< std::complex< double >,3 > *)new std::array< std::complex< double >,3 >((std::array< std::complex< double >,3 > const &)*arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_NEW | 0 );
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayC3_t(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[2] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "new_arrayC3_t", 0, 1, argv))) SWIG_fail;
+ --argc;
+ if (argc == 0) {
+ return _wrap_new_arrayC3_t__SWIG_0(self, argc, argv);
+ }
+ if (argc == 1) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_arrayC3_t__SWIG_1(self, argc, argv);
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_arrayC3_t'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::array()\n"
+ " std::array< std::complex< double >,3 >::array(std::array< std::complex< double >,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_empty" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)((std::array< std::complex< double >,3 > const *)arg1)->empty();
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_size" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = ((std::array< std::complex< double >,3 > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 > *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t_swap", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_swap" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "arrayC3_t_swap" "', argument " "2"" of type '" "std::array< std::complex< double >,3 > &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t_swap" "', argument " "2"" of type '" "std::array< std::complex< double >,3 > &""'");
+ }
+ arg2 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_begin" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- bool result;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_end" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_bool(static_cast< bool >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::reverse_iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_rbegin" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::reverse_iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_rend" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_front" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (std::array< std::complex< double >,3 >::value_type *) &((std::array< std::complex< double >,3 > const *)arg1)->front();
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_back" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (std::array< std::complex< double >,3 >::value_type *) &((std::array< std::complex< double >,3 > const *)arg1)->back();
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- ptrdiff_t result;
+ std::array< std::complex< double >,3 >::value_type temp2 ;
+ std::complex< double > val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t_fill", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_fill" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t_fill" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::value_type""'");
+ }
+ temp2 = static_cast< std::array< std::complex< double >,3 >::value_type >(val2);
+ arg2 = &temp2;
+ (arg1)->fill((std::array< std::complex< double >,3 >::value_type const &)*arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
- Py_ssize_t argc;
- PyObject *argv[3] = {
- 0
- };
+SWIGINTERN PyObject *_wrap_delete_arrayC3_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
- if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
- --argc;
- if (argc == 2) {
- int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
- }
- }
- }
- if (argc == 2) {
- int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- {
- int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
- _v = SWIG_CheckState(res);
- }
- if (_v) {
- return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
- }
- }
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
-
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ delete arg1;
+ resultobj = SWIG_Py_Void();
+ return resultobj;
fail:
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *arrayC3_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
+SWIGINTERN PyObject *arrayC3_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
SWIGINTERN PyObject *_wrap_vdouble1d_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
@@ -27641,6 +30127,86 @@ static PyMethodDef SwigMethods[] = {
"SwigPyIterator___sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t\n"
""},
{ "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
+ { "arrayR3_t_iterator", _wrap_arrayR3_t_iterator, METH_O, "arrayR3_t_iterator(arrayR3_t self) -> SwigPyIterator"},
+ { "arrayR3_t___nonzero__", _wrap_arrayR3_t___nonzero__, METH_O, "arrayR3_t___nonzero__(arrayR3_t self) -> bool"},
+ { "arrayR3_t___bool__", _wrap_arrayR3_t___bool__, METH_O, "arrayR3_t___bool__(arrayR3_t self) -> bool"},
+ { "arrayR3_t___len__", _wrap_arrayR3_t___len__, METH_O, "arrayR3_t___len__(arrayR3_t self) -> std::array< double,3 >::size_type"},
+ { "arrayR3_t___getslice__", _wrap_arrayR3_t___getslice__, METH_VARARGS, "arrayR3_t___getslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j) -> arrayR3_t"},
+ { "arrayR3_t___setslice__", _wrap_arrayR3_t___setslice__, METH_VARARGS, "\n"
+ "arrayR3_t___setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)\n"
+ "arrayR3_t___setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j, arrayR3_t v)\n"
+ ""},
+ { "arrayR3_t___delslice__", _wrap_arrayR3_t___delslice__, METH_VARARGS, "arrayR3_t___delslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)"},
+ { "arrayR3_t___delitem__", _wrap_arrayR3_t___delitem__, METH_VARARGS, "\n"
+ "arrayR3_t___delitem__(arrayR3_t self, std::array< double,3 >::difference_type i)\n"
+ "arrayR3_t___delitem__(arrayR3_t self, PySliceObject * slice)\n"
+ ""},
+ { "arrayR3_t___getitem__", _wrap_arrayR3_t___getitem__, METH_VARARGS, "\n"
+ "arrayR3_t___getitem__(arrayR3_t self, PySliceObject * slice) -> arrayR3_t\n"
+ "arrayR3_t___getitem__(arrayR3_t self, std::array< double,3 >::difference_type i) -> std::array< double,3 >::value_type const &\n"
+ ""},
+ { "arrayR3_t___setitem__", _wrap_arrayR3_t___setitem__, METH_VARARGS, "\n"
+ "arrayR3_t___setitem__(arrayR3_t self, PySliceObject * slice, arrayR3_t v)\n"
+ "arrayR3_t___setitem__(arrayR3_t self, PySliceObject * slice)\n"
+ "arrayR3_t___setitem__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::value_type const & x)\n"
+ ""},
+ { "new_arrayR3_t", _wrap_new_arrayR3_t, METH_VARARGS, "\n"
+ "arrayR3_t()\n"
+ "new_arrayR3_t(arrayR3_t other) -> arrayR3_t\n"
+ ""},
+ { "arrayR3_t_empty", _wrap_arrayR3_t_empty, METH_O, "arrayR3_t_empty(arrayR3_t self) -> bool"},
+ { "arrayR3_t_size", _wrap_arrayR3_t_size, METH_O, "arrayR3_t_size(arrayR3_t self) -> std::array< double,3 >::size_type"},
+ { "arrayR3_t_swap", _wrap_arrayR3_t_swap, METH_VARARGS, "arrayR3_t_swap(arrayR3_t self, arrayR3_t v)"},
+ { "arrayR3_t_begin", _wrap_arrayR3_t_begin, METH_O, "arrayR3_t_begin(arrayR3_t self) -> std::array< double,3 >::iterator"},
+ { "arrayR3_t_end", _wrap_arrayR3_t_end, METH_O, "arrayR3_t_end(arrayR3_t self) -> std::array< double,3 >::iterator"},
+ { "arrayR3_t_rbegin", _wrap_arrayR3_t_rbegin, METH_O, "arrayR3_t_rbegin(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"},
+ { "arrayR3_t_rend", _wrap_arrayR3_t_rend, METH_O, "arrayR3_t_rend(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"},
+ { "arrayR3_t_front", _wrap_arrayR3_t_front, METH_O, "arrayR3_t_front(arrayR3_t self) -> std::array< double,3 >::value_type const &"},
+ { "arrayR3_t_back", _wrap_arrayR3_t_back, METH_O, "arrayR3_t_back(arrayR3_t self) -> std::array< double,3 >::value_type const &"},
+ { "arrayR3_t_fill", _wrap_arrayR3_t_fill, METH_VARARGS, "arrayR3_t_fill(arrayR3_t self, std::array< double,3 >::value_type const & u)"},
+ { "delete_arrayR3_t", _wrap_delete_arrayR3_t, METH_O, "delete_arrayR3_t(arrayR3_t self)"},
+ { "arrayR3_t_swigregister", arrayR3_t_swigregister, METH_O, NULL},
+ { "arrayR3_t_swiginit", arrayR3_t_swiginit, METH_VARARGS, NULL},
+ { "arrayC3_t_iterator", _wrap_arrayC3_t_iterator, METH_O, "arrayC3_t_iterator(arrayC3_t self) -> SwigPyIterator"},
+ { "arrayC3_t___nonzero__", _wrap_arrayC3_t___nonzero__, METH_O, "arrayC3_t___nonzero__(arrayC3_t self) -> bool"},
+ { "arrayC3_t___bool__", _wrap_arrayC3_t___bool__, METH_O, "arrayC3_t___bool__(arrayC3_t self) -> bool"},
+ { "arrayC3_t___len__", _wrap_arrayC3_t___len__, METH_O, "arrayC3_t___len__(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"},
+ { "arrayC3_t___getslice__", _wrap_arrayC3_t___getslice__, METH_VARARGS, "arrayC3_t___getslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j) -> arrayC3_t"},
+ { "arrayC3_t___setslice__", _wrap_arrayC3_t___setslice__, METH_VARARGS, "\n"
+ "arrayC3_t___setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)\n"
+ "arrayC3_t___setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j, arrayC3_t v)\n"
+ ""},
+ { "arrayC3_t___delslice__", _wrap_arrayC3_t___delslice__, METH_VARARGS, "arrayC3_t___delslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)"},
+ { "arrayC3_t___delitem__", _wrap_arrayC3_t___delitem__, METH_VARARGS, "\n"
+ "arrayC3_t___delitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i)\n"
+ "arrayC3_t___delitem__(arrayC3_t self, PySliceObject * slice)\n"
+ ""},
+ { "arrayC3_t___getitem__", _wrap_arrayC3_t___getitem__, METH_VARARGS, "\n"
+ "arrayC3_t___getitem__(arrayC3_t self, PySliceObject * slice) -> arrayC3_t\n"
+ "arrayC3_t___getitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i) -> std::array< std::complex< double >,3 >::value_type const &\n"
+ ""},
+ { "arrayC3_t___setitem__", _wrap_arrayC3_t___setitem__, METH_VARARGS, "\n"
+ "arrayC3_t___setitem__(arrayC3_t self, PySliceObject * slice, arrayC3_t v)\n"
+ "arrayC3_t___setitem__(arrayC3_t self, PySliceObject * slice)\n"
+ "arrayC3_t___setitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::value_type const & x)\n"
+ ""},
+ { "new_arrayC3_t", _wrap_new_arrayC3_t, METH_VARARGS, "\n"
+ "arrayC3_t()\n"
+ "new_arrayC3_t(arrayC3_t other) -> arrayC3_t\n"
+ ""},
+ { "arrayC3_t_empty", _wrap_arrayC3_t_empty, METH_O, "arrayC3_t_empty(arrayC3_t self) -> bool"},
+ { "arrayC3_t_size", _wrap_arrayC3_t_size, METH_O, "arrayC3_t_size(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"},
+ { "arrayC3_t_swap", _wrap_arrayC3_t_swap, METH_VARARGS, "arrayC3_t_swap(arrayC3_t self, arrayC3_t v)"},
+ { "arrayC3_t_begin", _wrap_arrayC3_t_begin, METH_O, "arrayC3_t_begin(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"},
+ { "arrayC3_t_end", _wrap_arrayC3_t_end, METH_O, "arrayC3_t_end(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"},
+ { "arrayC3_t_rbegin", _wrap_arrayC3_t_rbegin, METH_O, "arrayC3_t_rbegin(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"},
+ { "arrayC3_t_rend", _wrap_arrayC3_t_rend, METH_O, "arrayC3_t_rend(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"},
+ { "arrayC3_t_front", _wrap_arrayC3_t_front, METH_O, "arrayC3_t_front(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"},
+ { "arrayC3_t_back", _wrap_arrayC3_t_back, METH_O, "arrayC3_t_back(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"},
+ { "arrayC3_t_fill", _wrap_arrayC3_t_fill, METH_VARARGS, "arrayC3_t_fill(arrayC3_t self, std::array< std::complex< double >,3 >::value_type const & u)"},
+ { "delete_arrayC3_t", _wrap_delete_arrayC3_t, METH_O, "delete_arrayC3_t(arrayC3_t self)"},
+ { "arrayC3_t_swigregister", arrayC3_t_swigregister, METH_O, NULL},
+ { "arrayC3_t_swiginit", arrayC3_t_swiginit, METH_VARARGS, NULL},
{ "vdouble1d_t_iterator", _wrap_vdouble1d_t_iterator, METH_O, "vdouble1d_t_iterator(vdouble1d_t self) -> SwigPyIterator"},
{ "vdouble1d_t___nonzero__", _wrap_vdouble1d_t___nonzero__, METH_O, "vdouble1d_t___nonzero__(vdouble1d_t self) -> bool"},
{ "vdouble1d_t___bool__", _wrap_vdouble1d_t___bool__, METH_O, "vdouble1d_t___bool__(vdouble1d_t self) -> bool"},
@@ -28826,6 +31392,8 @@ static swig_type_info _swigt__p_std__allocatorT_std__string_t = {"_p_std__alloca
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t = {"_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t", "std::vector< std::vector< double > >::allocator_type *|std::allocator< std::vector< double,std::allocator< double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t = {"_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t", "std::vector< std::vector< int > >::allocator_type *|std::allocator< std::vector< int,std::allocator< int > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_unsigned_long_t = {"_p_std__allocatorT_unsigned_long_t", "std::vector< unsigned long >::allocator_type *|std::allocator< unsigned long > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__arrayT_double_3_t = {"_p_std__arrayT_double_3_t", "std::array< double,3 > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__arrayT_std__complexT_double_t_3_t = {"_p_std__arrayT_std__complexT_double_t_3_t", "std::array< std::complex< double >,3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__lessT_std__string_t = {"_p_std__lessT_std__string_t", "std::less< std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t = {"_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t", "std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *|std::map< std::string,double > *", 0, 0, (void*)0, 0};
@@ -28887,6 +31455,8 @@ static swig_type_info *swig_type_initial[] = {
&_swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t,
&_swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t,
&_swigt__p_std__allocatorT_unsigned_long_t,
+ &_swigt__p_std__arrayT_double_3_t,
+ &_swigt__p_std__arrayT_std__complexT_double_t_3_t,
&_swigt__p_std__invalid_argument,
&_swigt__p_std__lessT_std__string_t,
&_swigt__p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t,
@@ -28948,6 +31518,8 @@ static swig_cast_info _swigc__p_std__allocatorT_std__string_t[] = { {&_swigt__p
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t[] = { {&_swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t[] = { {&_swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_unsigned_long_t[] = { {&_swigt__p_std__allocatorT_unsigned_long_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__arrayT_double_3_t[] = { {&_swigt__p_std__arrayT_double_3_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__arrayT_std__complexT_double_t_3_t[] = { {&_swigt__p_std__arrayT_std__complexT_double_t_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__lessT_std__string_t[] = { {&_swigt__p_std__lessT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t[] = { {&_swigt__p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -29009,6 +31581,8 @@ static swig_cast_info *swig_cast_initial[] = {
_swigc__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t,
_swigc__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t,
_swigc__p_std__allocatorT_unsigned_long_t,
+ _swigc__p_std__arrayT_double_3_t,
+ _swigc__p_std__arrayT_std__complexT_double_t_3_t,
_swigc__p_std__invalid_argument,
_swigc__p_std__lessT_std__string_t,
_swigc__p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t,
diff --git a/auto/Wrap/libBornAgainParam.py b/auto/Wrap/libBornAgainParam.py
index feb2f25178e..9b9f9935ac6 100644
--- a/auto/Wrap/libBornAgainParam.py
+++ b/auto/Wrap/libBornAgainParam.py
@@ -157,6 +157,230 @@ def deprecated(message):
return deprecated_func
return deprecated_decorator
+class arrayR3_t(object):
+ r"""Proxy of C++ std::array< double,3 > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(arrayR3_t self) -> SwigPyIterator"""
+ return _libBornAgainParam.arrayR3_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(arrayR3_t self) -> bool"""
+ return _libBornAgainParam.arrayR3_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(arrayR3_t self) -> bool"""
+ return _libBornAgainParam.arrayR3_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(arrayR3_t self) -> std::array< double,3 >::size_type"""
+ return _libBornAgainParam.arrayR3_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j) -> arrayR3_t"""
+ return _libBornAgainParam.arrayR3_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)
+ __setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j, arrayR3_t v)
+ """
+ return _libBornAgainParam.arrayR3_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)"""
+ return _libBornAgainParam.arrayR3_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(arrayR3_t self, std::array< double,3 >::difference_type i)
+ __delitem__(arrayR3_t self, PySliceObject * slice)
+ """
+ return _libBornAgainParam.arrayR3_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(arrayR3_t self, PySliceObject * slice) -> arrayR3_t
+ __getitem__(arrayR3_t self, std::array< double,3 >::difference_type i) -> std::array< double,3 >::value_type const &
+ """
+ return _libBornAgainParam.arrayR3_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(arrayR3_t self, PySliceObject * slice, arrayR3_t v)
+ __setitem__(arrayR3_t self, PySliceObject * slice)
+ __setitem__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::value_type const & x)
+ """
+ return _libBornAgainParam.arrayR3_t___setitem__(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(arrayR3_t self) -> arrayR3_t
+ __init__(arrayR3_t self, arrayR3_t other) -> arrayR3_t
+ """
+ _libBornAgainParam.arrayR3_t_swiginit(self, _libBornAgainParam.new_arrayR3_t(*args))
+
+ def empty(self):
+ r"""empty(arrayR3_t self) -> bool"""
+ return _libBornAgainParam.arrayR3_t_empty(self)
+
+ def size(self):
+ r"""size(arrayR3_t self) -> std::array< double,3 >::size_type"""
+ return _libBornAgainParam.arrayR3_t_size(self)
+
+ def swap(self, v):
+ r"""swap(arrayR3_t self, arrayR3_t v)"""
+ return _libBornAgainParam.arrayR3_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(arrayR3_t self) -> std::array< double,3 >::iterator"""
+ return _libBornAgainParam.arrayR3_t_begin(self)
+
+ def end(self):
+ r"""end(arrayR3_t self) -> std::array< double,3 >::iterator"""
+ return _libBornAgainParam.arrayR3_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"""
+ return _libBornAgainParam.arrayR3_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"""
+ return _libBornAgainParam.arrayR3_t_rend(self)
+
+ def front(self):
+ r"""front(arrayR3_t self) -> std::array< double,3 >::value_type const &"""
+ return _libBornAgainParam.arrayR3_t_front(self)
+
+ def back(self):
+ r"""back(arrayR3_t self) -> std::array< double,3 >::value_type const &"""
+ return _libBornAgainParam.arrayR3_t_back(self)
+
+ def fill(self, u):
+ r"""fill(arrayR3_t self, std::array< double,3 >::value_type const & u)"""
+ return _libBornAgainParam.arrayR3_t_fill(self, u)
+ __swig_destroy__ = _libBornAgainParam.delete_arrayR3_t
+
+# Register arrayR3_t in _libBornAgainParam:
+_libBornAgainParam.arrayR3_t_swigregister(arrayR3_t)
+
+class arrayC3_t(object):
+ r"""Proxy of C++ std::array< std::complex< double >,3 > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(arrayC3_t self) -> SwigPyIterator"""
+ return _libBornAgainParam.arrayC3_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(arrayC3_t self) -> bool"""
+ return _libBornAgainParam.arrayC3_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(arrayC3_t self) -> bool"""
+ return _libBornAgainParam.arrayC3_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"""
+ return _libBornAgainParam.arrayC3_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j) -> arrayC3_t"""
+ return _libBornAgainParam.arrayC3_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)
+ __setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j, arrayC3_t v)
+ """
+ return _libBornAgainParam.arrayC3_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)"""
+ return _libBornAgainParam.arrayC3_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i)
+ __delitem__(arrayC3_t self, PySliceObject * slice)
+ """
+ return _libBornAgainParam.arrayC3_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(arrayC3_t self, PySliceObject * slice) -> arrayC3_t
+ __getitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i) -> std::array< std::complex< double >,3 >::value_type const &
+ """
+ return _libBornAgainParam.arrayC3_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(arrayC3_t self, PySliceObject * slice, arrayC3_t v)
+ __setitem__(arrayC3_t self, PySliceObject * slice)
+ __setitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::value_type const & x)
+ """
+ return _libBornAgainParam.arrayC3_t___setitem__(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(arrayC3_t self) -> arrayC3_t
+ __init__(arrayC3_t self, arrayC3_t other) -> arrayC3_t
+ """
+ _libBornAgainParam.arrayC3_t_swiginit(self, _libBornAgainParam.new_arrayC3_t(*args))
+
+ def empty(self):
+ r"""empty(arrayC3_t self) -> bool"""
+ return _libBornAgainParam.arrayC3_t_empty(self)
+
+ def size(self):
+ r"""size(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"""
+ return _libBornAgainParam.arrayC3_t_size(self)
+
+ def swap(self, v):
+ r"""swap(arrayC3_t self, arrayC3_t v)"""
+ return _libBornAgainParam.arrayC3_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"""
+ return _libBornAgainParam.arrayC3_t_begin(self)
+
+ def end(self):
+ r"""end(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"""
+ return _libBornAgainParam.arrayC3_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"""
+ return _libBornAgainParam.arrayC3_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"""
+ return _libBornAgainParam.arrayC3_t_rend(self)
+
+ def front(self):
+ r"""front(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"""
+ return _libBornAgainParam.arrayC3_t_front(self)
+
+ def back(self):
+ r"""back(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"""
+ return _libBornAgainParam.arrayC3_t_back(self)
+
+ def fill(self, u):
+ r"""fill(arrayC3_t self, std::array< std::complex< double >,3 >::value_type const & u)"""
+ return _libBornAgainParam.arrayC3_t_fill(self, u)
+ __swig_destroy__ = _libBornAgainParam.delete_arrayC3_t
+
+# Register arrayC3_t in _libBornAgainParam:
+_libBornAgainParam.arrayC3_t_swigregister(arrayC3_t)
+
class vdouble1d_t(object):
r"""Proxy of C++ std::vector< double > class."""
diff --git a/auto/Wrap/libBornAgainParam_wrap.cpp b/auto/Wrap/libBornAgainParam_wrap.cpp
index a92de01ac4e..e0c7eb1c918 100644
--- a/auto/Wrap/libBornAgainParam_wrap.cpp
+++ b/auto/Wrap/libBornAgainParam_wrap.cpp
@@ -3254,31 +3254,33 @@ namespace Swig {
#define SWIGTYPE_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t swig_types[154]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t swig_types[155]
#define SWIGTYPE_p_std__allocatorT_unsigned_long_t swig_types[156]
-#define SWIGTYPE_p_std__complexT_double_t swig_types[157]
-#define SWIGTYPE_p_std__invalid_argument swig_types[158]
-#define SWIGTYPE_p_std__lessT_std__string_t swig_types[159]
-#define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[160]
-#define SWIGTYPE_p_std__pairT_double_double_t swig_types[161]
-#define SWIGTYPE_p_std__vectorT_INode_const_p_std__allocatorT_INode_const_p_t_t swig_types[162]
-#define SWIGTYPE_p_std__vectorT_INode_p_std__allocatorT_INode_p_t_t swig_types[163]
-#define SWIGTYPE_p_std__vectorT_ParaMeta_std__allocatorT_ParaMeta_t_t swig_types[164]
-#define SWIGTYPE_p_std__vectorT_ParameterSample_std__allocatorT_ParameterSample_t_t swig_types[165]
-#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[166]
-#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[167]
-#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[168]
-#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[169]
-#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[170]
-#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[171]
-#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[172]
-#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[173]
-#define SWIGTYPE_p_swig__SwigPyIterator swig_types[174]
-#define SWIGTYPE_p_unsigned_char swig_types[175]
-#define SWIGTYPE_p_unsigned_int swig_types[176]
-#define SWIGTYPE_p_unsigned_long_long swig_types[177]
-#define SWIGTYPE_p_unsigned_short swig_types[178]
-#define SWIGTYPE_p_value_type swig_types[179]
-static swig_type_info *swig_types[181];
-static swig_module_info swig_module = {swig_types, 180, 0, 0, 0, 0};
+#define SWIGTYPE_p_std__arrayT_double_3_t swig_types[157]
+#define SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t swig_types[158]
+#define SWIGTYPE_p_std__complexT_double_t swig_types[159]
+#define SWIGTYPE_p_std__invalid_argument swig_types[160]
+#define SWIGTYPE_p_std__lessT_std__string_t swig_types[161]
+#define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[162]
+#define SWIGTYPE_p_std__pairT_double_double_t swig_types[163]
+#define SWIGTYPE_p_std__vectorT_INode_const_p_std__allocatorT_INode_const_p_t_t swig_types[164]
+#define SWIGTYPE_p_std__vectorT_INode_p_std__allocatorT_INode_p_t_t swig_types[165]
+#define SWIGTYPE_p_std__vectorT_ParaMeta_std__allocatorT_ParaMeta_t_t swig_types[166]
+#define SWIGTYPE_p_std__vectorT_ParameterSample_std__allocatorT_ParameterSample_t_t swig_types[167]
+#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[168]
+#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[169]
+#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[170]
+#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[171]
+#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[172]
+#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[173]
+#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[174]
+#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[175]
+#define SWIGTYPE_p_swig__SwigPyIterator swig_types[176]
+#define SWIGTYPE_p_unsigned_char swig_types[177]
+#define SWIGTYPE_p_unsigned_int swig_types[178]
+#define SWIGTYPE_p_unsigned_long_long swig_types[179]
+#define SWIGTYPE_p_unsigned_short swig_types[180]
+#define SWIGTYPE_p_value_type swig_types[181]
+static swig_type_info *swig_types[183];
+static swig_module_info swig_module = {swig_types, 182, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
@@ -5113,48 +5115,104 @@ namespace swig {
namespace swig {
- template <class T>
- struct traits_reserve<std::vector<T> > {
- static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
- seq.reserve(n);
+ template <class T, size_t N>
+ struct traits_asptr<std::array<T, N> > {
+ static int asptr(PyObject *obj, std::array<T, N> **vec) {
+ return traits_asptr_stdseq<std::array<T, N> >::asptr(obj, vec);
}
};
- template <class T>
- struct traits_asptr<std::vector<T> > {
- static int asptr(PyObject *obj, std::vector<T> **vec) {
- return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+ template <class T, size_t N>
+ struct traits_from<std::array<T, N> > {
+ static PyObject *from(const std::array<T, N>& vec) {
+ return traits_from_stdseq<std::array<T, N> >::from(vec);
}
};
-
- template <class T>
- struct traits_from<std::vector<T> > {
- static PyObject *from(const std::vector<T>& vec) {
- return traits_from_stdseq<std::vector<T> >::from(vec);
+
+ template <class SwigPySeq, class T, size_t N>
+ inline void
+ assign(const SwigPySeq& swigpyseq, std::array<T, N>* seq) {
+ if (swigpyseq.size() < seq->size())
+ throw std::invalid_argument("std::array cannot be expanded in size");
+ else if (swigpyseq.size() > seq->size())
+ throw std::invalid_argument("std::array cannot be reduced in size");
+ std::copy(swigpyseq.begin(), swigpyseq.end(), seq->begin());
+ }
+
+ template <class T, size_t N>
+ inline void
+ erase(std::array<T, N>* SWIGUNUSEDPARM(seq), const typename std::array<T, N>::iterator& SWIGUNUSEDPARM(position)) {
+ throw std::invalid_argument("std::array object does not support item deletion");
+ }
+
+ // Only limited slicing is supported as std::array is fixed in size
+ template <class T, size_t N, class Difference>
+ inline std::array<T, N>*
+ getslice(const std::array<T, N>* self, Difference i, Difference j, Py_ssize_t step) {
+ typedef std::array<T, N> Sequence;
+ typename Sequence::size_type size = self->size();
+ Difference ii = 0;
+ Difference jj = 0;
+ swig::slice_adjust(i, j, step, size, ii, jj);
+
+ if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
+ Sequence *sequence = new Sequence();
+ std::copy(self->begin(), self->end(), sequence->begin());
+ return sequence;
+ } else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
+ Sequence *sequence = new Sequence();
+ std::copy(self->rbegin(), self->rend(), sequence->begin());
+ return sequence;
+ } else {
+ throw std::invalid_argument("std::array object only supports getting a slice that is the size of the array");
}
- };
+ }
+
+ template <class T, size_t N, class Difference, class InputSeq>
+ inline void
+ setslice(std::array<T, N>* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
+ typedef std::array<T, N> Sequence;
+ typename Sequence::size_type size = self->size();
+ Difference ii = 0;
+ Difference jj = 0;
+ swig::slice_adjust(i, j, step, size, ii, jj, true);
+
+ if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
+ std::copy(is.begin(), is.end(), self->begin());
+ } else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
+ std::copy(is.rbegin(), is.rend(), self->begin());
+ } else {
+ throw std::invalid_argument("std::array object only supports setting a slice that is the size of the array");
+ }
+ }
+
+ template <class T, size_t N, class Difference>
+ inline void
+ delslice(std::array<T, N>* SWIGUNUSEDPARM(self), Difference SWIGUNUSEDPARM(i), Difference SWIGUNUSEDPARM(j), Py_ssize_t SWIGUNUSEDPARM(step)) {
+ throw std::invalid_argument("std::array object does not support item deletion");
+ }
}
namespace swig {
- template <> struct traits<std::vector< double, std::allocator< double > > > {
+ template <> struct traits<std::array< double, 3 > > {
typedef pointer_category category;
static const char* type_name() {
- return "std::vector<" "double" "," "std::allocator< double >" " >";
+ return "std::array<" "double" "," "3" " >";
}
};
}
-SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_array_Sl_double_Sc_3_Sg__iterator(std::array< double,3 > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
+SWIGINTERN bool std_array_Sl_double_Sc_3_Sg____nonzero__(std::array< double,3 > const *self){
return !(self->empty());
}
-SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
+SWIGINTERN bool std_array_Sl_double_Sc_3_Sg____bool__(std::array< double,3 > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
+SWIGINTERN std::array< double,3 >::size_type std_array_Sl_double_Sc_3_Sg____len__(std::array< double,3 > const *self){
return self->size();
}
@@ -5191,66 +5249,66 @@ SWIG_From_size_t (size_t value)
#endif
}
-SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+SWIGINTERN std::array< double,3 > *std_array_Sl_double_Sc_3_Sg____getslice__(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
return swig::getslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
- swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setslice____SWIG_0(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
+ swig::setslice(self, i, j, 1, std::array< double,3 >());
}
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setslice____SWIG_1(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j,std::array< double,3 > const &v){
swig::setslice(self, i, j, 1, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delslice__(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
swig::delslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delitem____SWIG_0(std::array< double,3 > *self,std::array< double,3 >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN std::array< double,3 > *std_array_Sl_double_Sc_3_Sg____getitem____SWIG_0(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_0(std::array< double,3 > *self,PySliceObject *slice,std::array< double,3 > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_1(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delitem____SWIG_1(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
+SWIGINTERN std::array< double,3 >::value_type const &std_array_Sl_double_Sc_3_Sg____getitem____SWIG_1(std::array< double,3 > const *self,std::array< double,3 >::difference_type i){
return *(swig::cgetpos(self, i));
}
@@ -5288,6 +5346,255 @@ namespace swig {
};
}
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_2(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::value_type const &x){
+ *(swig::getpos(self,i)) = x;
+ }
+
+SWIGINTERN int
+SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
+{
+ if (PyComplex_Check(o)) {
+ if (val) *val = std::complex<double>(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
+ return SWIG_OK;
+ } else {
+ double d;
+ int res = SWIG_AddCast(SWIG_AsVal_double (o, &d));
+ if (SWIG_IsOK(res)) {
+ if (val) *val = std::complex<double>(d, 0.0);
+ return res;
+ }
+ }
+ return SWIG_TypeError;
+}
+
+
+SWIGINTERNINLINE PyObject*
+SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/local/share/swig/4.0.2/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+
+const std::complex<double>&
+
+
+
+/*@SWIG@*/ c)
+{
+ return PyComplex_FromDoubles(std::real(c), std::imag(c));
+}
+
+
+namespace swig {
+ template <> struct traits< std::complex<double> > {
+ typedef value_category category;
+ static const char* type_name() { return"std::complex<double>"; }
+ };
+ template <> struct traits_asval< std::complex<double> > {
+ typedef std::complex<double> value_type;
+ static int asval(PyObject *obj, value_type *val) {
+ return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
+ }
+ };
+ template <> struct traits_from< std::complex<double> > {
+ typedef std::complex<double> value_type;
+ static PyObject *from(const value_type& val) {
+ return SWIG_From_std_complex_Sl_double_Sg_ (val);
+ }
+ };
+}
+
+
+ namespace swig {
+ template <> struct traits<std::array< std::complex< double >, 3 > > {
+ typedef pointer_category category;
+ static const char* type_name() {
+ return "std::array<" "std::complex< double >" "," "3" " >";
+ }
+ };
+ }
+
+SWIGINTERN swig::SwigPyIterator *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg__iterator(std::array< std::complex< double >,3 > *self,PyObject **PYTHON_SELF){
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+ }
+SWIGINTERN bool std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____nonzero__(std::array< std::complex< double >,3 > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____bool__(std::array< std::complex< double >,3 > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN std::array< std::complex< double >,3 >::size_type std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____len__(std::array< std::complex< double >,3 > const *self){
+ return self->size();
+ }
+SWIGINTERN std::array< std::complex< double >,3 > *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getslice__(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
+ return swig::getslice(self, i, j, 1);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_0(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
+ swig::setslice(self, i, j, 1, std::array< std::complex< double >,3 >());
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_1(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j,std::array< std::complex< double >,3 > const &v){
+ swig::setslice(self, i, j, 1, v);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delslice__(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
+ swig::delslice(self, i, j, 1);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_0(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i){
+ swig::erase(self, swig::getpos(self, i));
+ }
+SWIGINTERN std::array< std::complex< double >,3 > *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_0(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
+ return swig::getslice(self, id, jd, step);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_0(std::array< std::complex< double >,3 > *self,PySliceObject *slice,std::array< std::complex< double >,3 > const &v){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
+ swig::setslice(self, id, jd, step, v);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_1(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_1(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN std::array< std::complex< double >,3 >::value_type const &std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_1(std::array< std::complex< double >,3 > const *self,std::array< std::complex< double >,3 >::difference_type i){
+ return *(swig::cgetpos(self, i));
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_2(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::value_type const &x){
+ *(swig::getpos(self,i)) = x;
+ }
+
+ namespace swig {
+ template <class T>
+ struct traits_reserve<std::vector<T> > {
+ static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
+ seq.reserve(n);
+ }
+ };
+
+ template <class T>
+ struct traits_asptr<std::vector<T> > {
+ static int asptr(PyObject *obj, std::vector<T> **vec) {
+ return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+ }
+ };
+
+ template <class T>
+ struct traits_from<std::vector<T> > {
+ static PyObject *from(const std::vector<T>& vec) {
+ return traits_from_stdseq<std::vector<T> >::from(vec);
+ }
+ };
+ }
+
+
+ namespace swig {
+ template <> struct traits<std::vector< double, std::allocator< double > > > {
+ typedef pointer_category category;
+ static const char* type_name() {
+ return "std::vector<" "double" "," "std::allocator< double >" " >";
+ }
+ };
+ }
+
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+ }
+SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
+ return self->size();
+ }
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+ return swig::getslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+ swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
+ swig::setslice(self, i, j, 1, v);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+ swig::delslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
+ swig::erase(self, swig::getpos(self, i));
+ }
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ return swig::getslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::setslice(self, id, jd, step, v);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
+ return *(swig::cgetpos(self, i));
+ }
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
@@ -5766,57 +6073,6 @@ SWIGINTERN std::vector< unsigned long >::iterator std_vector_Sl_unsigned_SS_long
SWIGINTERN std::vector< unsigned long >::iterator std_vector_Sl_unsigned_SS_long_Sg__insert__SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::iterator pos,std::vector< unsigned long >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg__insert__SWIG_1(std::vector< unsigned long > *self,std::vector< unsigned long >::iterator pos,std::vector< unsigned long >::size_type n,std::vector< unsigned long >::value_type const &x){ self->insert(pos, n, x); }
-SWIGINTERN int
-SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
-{
- if (PyComplex_Check(o)) {
- if (val) *val = std::complex<double>(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
- return SWIG_OK;
- } else {
- double d;
- int res = SWIG_AddCast(SWIG_AsVal_double (o, &d));
- if (SWIG_IsOK(res)) {
- if (val) *val = std::complex<double>(d, 0.0);
- return res;
- }
- }
- return SWIG_TypeError;
-}
-
-
-SWIGINTERNINLINE PyObject*
-SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/local/share/swig/4.0.2/typemaps/swigmacros.swg,104,%ifcplusplus@*/
-
-const std::complex<double>&
-
-
-
-/*@SWIG@*/ c)
-{
- return PyComplex_FromDoubles(std::real(c), std::imag(c));
-}
-
-
-namespace swig {
- template <> struct traits< std::complex<double> > {
- typedef value_category category;
- static const char* type_name() { return"std::complex<double>"; }
- };
- template <> struct traits_asval< std::complex<double> > {
- typedef std::complex<double> value_type;
- static int asval(PyObject *obj, value_type *val) {
- return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
- }
- };
- template <> struct traits_from< std::complex<double> > {
- typedef std::complex<double> value_type;
- static PyObject *from(const value_type& val) {
- return SWIG_From_std_complex_Sl_double_Sg_ (val);
- }
- };
-}
-
-
namespace swig {
template <> struct traits<std::vector< std::complex< double >, std::allocator< std::complex< double > > > > {
typedef pointer_category category;
@@ -7453,592 +7709,2822 @@ SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(
SWIG_fail;
}
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_decr", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 1) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv);
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_size_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " swig::SwigPyIterator::decr(size_t)\n"
+ " swig::SwigPyIterator::decr()\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ ptrdiff_t result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ try {
+ result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
+ } catch(std::invalid_argument &_e) {
+ SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
+ }
+ resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ bool result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ try {
+ result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
+ } catch(std::invalid_argument &_e) {
+ SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
+ }
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ PyObject *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ try {
+ result = (PyObject *)(arg1)->next();
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = result;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ PyObject *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ try {
+ result = (PyObject *)(arg1)->__next__();
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = result;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ PyObject *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ try {
+ result = (PyObject *)(arg1)->previous();
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = result;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ bool result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ bool result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ ptrdiff_t result;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PyObject **arg2 = (PyObject **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ arg2 = &swig_obj[0];
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_iterator" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (swig::SwigPyIterator *)std_array_Sl_double_Sc_3_Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___nonzero__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)std_array_Sl_double_Sc_3_Sg____nonzero__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___bool__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)std_array_Sl_double_Sc_3_Sg____bool__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___len__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = std_array_Sl_double_Sc_3_Sg____len__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ std::array< double,3 > *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t___getslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___getslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___getslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ result = (std::array< double,3 > *)std_array_Sl_double_Sc_3_Sg____getslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_double_Sc_3_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ std::array< double,3 > *arg4 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ int res4 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res4 = swig::asptr(swig_obj[3], &ptr);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "arrayR3_t___setslice__" "', argument " "4"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t___setslice__" "', argument " "4"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg4 = ptr;
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::array< double,3 > const &)*arg4);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[5] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___setslice__", 0, 4, argv))) SWIG_fail;
+ --argc;
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setslice____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[3], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayR3_t___setslice____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___setslice__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__setslice__(std::array< double,3 >::difference_type,std::array< double,3 >::difference_type)\n"
+ " std::array< double,3 >::__setslice__(std::array< double,3 >::difference_type,std::array< double,3 >::difference_type,std::array< double,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t___delslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___delslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___delslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_double_Sc_3_Sg____delslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___delitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ try {
+ std_array_Sl_double_Sc_3_Sg____delitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ result = (std::array< double,3 > *)std_array_Sl_double_Sc_3_Sg____getitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::array< double,3 > *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res3 = swig::asptr(swig_obj[2], &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg3 = ptr;
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_0(arg1,arg2,(std::array< double,3 > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____delitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___delitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___delitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___delitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__delitem__(std::array< double,3 >::difference_type)\n"
+ " std::array< double,3 >::__delitem__(PySliceObject *)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getitem__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___getitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ try {
+ result = (std::array< double,3 >::value_type *) &std_array_Sl_double_Sc_3_Sg____getitem____SWIG_1((std::array< double,3 > const *)arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___getitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___getitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___getitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__getitem__(PySliceObject *)\n"
+ " std::array< double,3 >::__getitem__(std::array< double,3 >::difference_type) const\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::value_type *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< double,3 >::value_type temp3 ;
+ double val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 >::value_type""'");
+ }
+ temp3 = static_cast< std::array< double,3 >::value_type >(val3);
+ arg3 = &temp3;
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_2(arg1,arg2,(double const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[4] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___setitem__", 0, 3, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_2(self, argc, argv);
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___setitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__setitem__(PySliceObject *,std::array< double,3 > const &)\n"
+ " std::array< double,3 >::__setitem__(PySliceObject *)\n"
+ " std::array< double,3 >::__setitem__(std::array< double,3 >::difference_type,std::array< double,3 >::value_type const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
+ result = (std::array< double,3 > *)new std::array< double,3 >();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_NEW | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = 0 ;
+ int res1 = SWIG_OLDOBJ ;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res1 = swig::asptr(swig_obj[0], &ptr);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg1 = ptr;
+ }
+ result = (std::array< double,3 > *)new std::array< double,3 >((std::array< double,3 > const &)*arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_NEW | 0 );
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[2] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "new_arrayR3_t", 0, 1, argv))) SWIG_fail;
+ --argc;
+ if (argc == 0) {
+ return _wrap_new_arrayR3_t__SWIG_0(self, argc, argv);
+ }
+ if (argc == 1) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_arrayR3_t__SWIG_1(self, argc, argv);
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_arrayR3_t'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::array()\n"
+ " std::array< double,3 >::array(std::array< double,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_empty" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)((std::array< double,3 > const *)arg1)->empty();
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_size" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = ((std::array< double,3 > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 > *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t_swap", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_swap" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__arrayT_double_3_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "arrayR3_t_swap" "', argument " "2"" of type '" "std::array< double,3 > &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t_swap" "', argument " "2"" of type '" "std::array< double,3 > &""'");
+ }
+ arg2 = reinterpret_cast< std::array< double,3 > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_begin" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_end" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::reverse_iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_rbegin" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::reverse_iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_rend" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_front" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (std::array< double,3 >::value_type *) &((std::array< double,3 > const *)arg1)->front();
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_back" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (std::array< double,3 >::value_type *) &((std::array< double,3 > const *)arg1)->back();
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::value_type *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< double,3 >::value_type temp2 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t_fill", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_fill" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t_fill" "', argument " "2"" of type '" "std::array< double,3 >::value_type""'");
+ }
+ temp2 = static_cast< std::array< double,3 >::value_type >(val2);
+ arg2 = &temp2;
+ (arg1)->fill((std::array< double,3 >::value_type const &)*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_arrayR3_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ delete arg1;
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *arrayR3_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__arrayT_double_3_t, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *arrayR3_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PyObject **arg2 = (PyObject **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ arg2 = &swig_obj[0];
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_iterator" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (swig::SwigPyIterator *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___nonzero__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____nonzero__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___bool__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____bool__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___len__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____len__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t___getslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___getslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___getslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ result = (std::array< std::complex< double >,3 > *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ std::array< std::complex< double >,3 > *arg4 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ int res4 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res4 = swig::asptr(swig_obj[3], &ptr);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "arrayC3_t___setslice__" "', argument " "4"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t___setslice__" "', argument " "4"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg4 = ptr;
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::array< std::complex< double >,3 > const &)*arg4);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[5] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___setslice__", 0, 4, argv))) SWIG_fail;
+ --argc;
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setslice____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[3], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayC3_t___setslice____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___setslice__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__setslice__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::difference_type)\n"
+ " std::array< std::complex< double >,3 >::__setslice__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t___delslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___delslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___delslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___delitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ result = (std::array< std::complex< double >,3 > *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::array< std::complex< double >,3 > *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res3 = swig::asptr(swig_obj[2], &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg3 = ptr;
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_0(arg1,arg2,(std::array< std::complex< double >,3 > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___delitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___delitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___delitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__delitem__(std::array< std::complex< double >,3 >::difference_type)\n"
+ " std::array< std::complex< double >,3 >::__delitem__(PySliceObject *)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___getitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ try {
+ result = (std::array< std::complex< double >,3 >::value_type *) &std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_1((std::array< std::complex< double >,3 > const *)arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___getitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___getitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___getitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__getitem__(PySliceObject *)\n"
+ " std::array< std::complex< double >,3 >::__getitem__(std::array< std::complex< double >,3 >::difference_type) const\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::value_type *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< std::complex< double >,3 >::value_type temp3 ;
+ std::complex< double > val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_std_complex_Sl_double_Sg_(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::value_type""'");
+ }
+ temp3 = static_cast< std::array< std::complex< double >,3 >::value_type >(val3);
+ arg3 = &temp3;
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_2(arg1,arg2,(std::complex< double > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
- PyObject *argv[3] = {
+ PyObject *argv[4] = {
0
};
- if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_decr", 0, 2, argv))) SWIG_fail;
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___setitem__", 0, 3, argv))) SWIG_fail;
--argc;
- if (argc == 1) {
+ if (argc == 2) {
int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- return _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv);
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_1(self, argc, argv);
+ }
}
}
- if (argc == 2) {
+ if (argc == 3) {
int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
- int res = SWIG_AsVal_size_t(argv[1], NULL);
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
- return _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv);
+ {
+ int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_2(self, argc, argv);
+ }
}
}
}
fail:
- SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " swig::SwigPyIterator::decr(size_t)\n"
- " swig::SwigPyIterator::decr()\n");
+ " std::array< std::complex< double >,3 >::__setitem__(PySliceObject *,std::array< std::complex< double >,3 > const &)\n"
+ " std::array< std::complex< double >,3 >::__setitem__(PySliceObject *)\n"
+ " std::array< std::complex< double >,3 >::__setitem__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::value_type const &)\n");
return 0;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_arrayC3_t__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- ptrdiff_t result;
+ std::array< std::complex< double >,3 > *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- try {
- result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
- } catch(std::invalid_argument &_e) {
- SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
- }
- resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
+ result = (std::array< std::complex< double >,3 > *)new std::array< std::complex< double >,3 >();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_arrayC3_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- bool result;
+ std::array< std::complex< double >,3 > *arg1 = 0 ;
+ int res1 = SWIG_OLDOBJ ;
+ std::array< std::complex< double >,3 > *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- try {
- result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
- } catch(std::invalid_argument &_e) {
- SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
+ if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res1 = swig::asptr(swig_obj[0], &ptr);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg1 = ptr;
}
- resultobj = SWIG_From_bool(static_cast< bool >(result));
+ result = (std::array< std::complex< double >,3 > *)new std::array< std::complex< double >,3 >((std::array< std::complex< double >,3 > const &)*arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_NEW | 0 );
+ if (SWIG_IsNewObj(res1)) delete arg1;
return resultobj;
fail:
+ if (SWIG_IsNewObj(res1)) delete arg1;
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject *swig_obj[1] ;
- swig::SwigPyIterator *result = 0 ;
+SWIGINTERN PyObject *_wrap_new_arrayC3_t(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[2] = {
+ 0
+ };
- if (!args) SWIG_fail;
- swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ if (!(argc = SWIG_Python_UnpackTuple(args, "new_arrayC3_t", 0, 1, argv))) SWIG_fail;
+ --argc;
+ if (argc == 0) {
+ return _wrap_new_arrayC3_t__SWIG_0(self, argc, argv);
}
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
- return resultobj;
+ if (argc == 1) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_arrayC3_t__SWIG_1(self, argc, argv);
+ }
+ }
+
fail:
- return NULL;
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_arrayC3_t'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::array()\n"
+ " std::array< std::complex< double >,3 >::array(std::array< std::complex< double >,3 > const &)\n");
+ return 0;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
- PyObject *result = 0 ;
+ bool result;
if (!args) SWIG_fail;
swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- try {
- result = (PyObject *)(arg1)->next();
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_empty" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = result;
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)((std::array< std::complex< double >,3 > const *)arg1)->empty();
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
- PyObject *result = 0 ;
+ std::array< std::complex< double >,3 >::size_type result;
if (!args) SWIG_fail;
swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- try {
- result = (PyObject *)(arg1)->__next__();
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_size" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = result;
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = ((std::array< std::complex< double >,3 > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- PyObject *swig_obj[1] ;
- PyObject *result = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!args) SWIG_fail;
- swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t_swap", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_swap" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- try {
- result = (PyObject *)(arg1)->previous();
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "arrayC3_t_swap" "', argument " "2"" of type '" "std::array< std::complex< double >,3 > &""'");
}
- resultobj = result;
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t_swap" "', argument " "2"" of type '" "std::array< std::complex< double >,3 > &""'");
+ }
+ arg2 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_begin" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- bool result;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_end" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_bool(static_cast< bool >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- bool result;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::reverse_iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_rbegin" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_bool(static_cast< bool >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::reverse_iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_rend" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_front" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (std::array< std::complex< double >,3 >::value_type *) &((std::array< std::complex< double >,3 > const *)arg1)->front();
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_back" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (std::array< std::complex< double >,3 >::value_type *) &((std::array< std::complex< double >,3 > const *)arg1)->back();
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
+ std::array< std::complex< double >,3 >::value_type temp2 ;
+ std::complex< double > val2 ;
int ecode2 = 0 ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[2] ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t_fill", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_fill" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t_fill" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::value_type""'");
}
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
- }
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ temp2 = static_cast< std::array< std::complex< double >,3 >::value_type >(val2);
+ arg2 = &temp2;
+ (arg1)->fill((std::array< std::complex< double >,3 >::value_type const &)*arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_delete_arrayC3_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- ptrdiff_t result;
+ PyObject *swig_obj[1] ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ delete arg1;
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
-}
-
-
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
- Py_ssize_t argc;
- PyObject *argv[3] = {
- 0
- };
-
- if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
- --argc;
- if (argc == 2) {
- int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
- }
- }
- }
- if (argc == 2) {
- int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- {
- int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
- _v = SWIG_CheckState(res);
- }
- if (_v) {
- return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
- }
- }
- }
-
-fail:
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *arrayC3_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
+SWIGINTERN PyObject *arrayC3_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
SWIGINTERN PyObject *_wrap_vdouble1d_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
@@ -41678,6 +44164,86 @@ static PyMethodDef SwigMethods[] = {
"SwigPyIterator___sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t\n"
""},
{ "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
+ { "arrayR3_t_iterator", _wrap_arrayR3_t_iterator, METH_O, "arrayR3_t_iterator(arrayR3_t self) -> SwigPyIterator"},
+ { "arrayR3_t___nonzero__", _wrap_arrayR3_t___nonzero__, METH_O, "arrayR3_t___nonzero__(arrayR3_t self) -> bool"},
+ { "arrayR3_t___bool__", _wrap_arrayR3_t___bool__, METH_O, "arrayR3_t___bool__(arrayR3_t self) -> bool"},
+ { "arrayR3_t___len__", _wrap_arrayR3_t___len__, METH_O, "arrayR3_t___len__(arrayR3_t self) -> std::array< double,3 >::size_type"},
+ { "arrayR3_t___getslice__", _wrap_arrayR3_t___getslice__, METH_VARARGS, "arrayR3_t___getslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j) -> arrayR3_t"},
+ { "arrayR3_t___setslice__", _wrap_arrayR3_t___setslice__, METH_VARARGS, "\n"
+ "arrayR3_t___setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)\n"
+ "arrayR3_t___setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j, arrayR3_t v)\n"
+ ""},
+ { "arrayR3_t___delslice__", _wrap_arrayR3_t___delslice__, METH_VARARGS, "arrayR3_t___delslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)"},
+ { "arrayR3_t___delitem__", _wrap_arrayR3_t___delitem__, METH_VARARGS, "\n"
+ "arrayR3_t___delitem__(arrayR3_t self, std::array< double,3 >::difference_type i)\n"
+ "arrayR3_t___delitem__(arrayR3_t self, PySliceObject * slice)\n"
+ ""},
+ { "arrayR3_t___getitem__", _wrap_arrayR3_t___getitem__, METH_VARARGS, "\n"
+ "arrayR3_t___getitem__(arrayR3_t self, PySliceObject * slice) -> arrayR3_t\n"
+ "arrayR3_t___getitem__(arrayR3_t self, std::array< double,3 >::difference_type i) -> std::array< double,3 >::value_type const &\n"
+ ""},
+ { "arrayR3_t___setitem__", _wrap_arrayR3_t___setitem__, METH_VARARGS, "\n"
+ "arrayR3_t___setitem__(arrayR3_t self, PySliceObject * slice, arrayR3_t v)\n"
+ "arrayR3_t___setitem__(arrayR3_t self, PySliceObject * slice)\n"
+ "arrayR3_t___setitem__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::value_type const & x)\n"
+ ""},
+ { "new_arrayR3_t", _wrap_new_arrayR3_t, METH_VARARGS, "\n"
+ "arrayR3_t()\n"
+ "new_arrayR3_t(arrayR3_t other) -> arrayR3_t\n"
+ ""},
+ { "arrayR3_t_empty", _wrap_arrayR3_t_empty, METH_O, "arrayR3_t_empty(arrayR3_t self) -> bool"},
+ { "arrayR3_t_size", _wrap_arrayR3_t_size, METH_O, "arrayR3_t_size(arrayR3_t self) -> std::array< double,3 >::size_type"},
+ { "arrayR3_t_swap", _wrap_arrayR3_t_swap, METH_VARARGS, "arrayR3_t_swap(arrayR3_t self, arrayR3_t v)"},
+ { "arrayR3_t_begin", _wrap_arrayR3_t_begin, METH_O, "arrayR3_t_begin(arrayR3_t self) -> std::array< double,3 >::iterator"},
+ { "arrayR3_t_end", _wrap_arrayR3_t_end, METH_O, "arrayR3_t_end(arrayR3_t self) -> std::array< double,3 >::iterator"},
+ { "arrayR3_t_rbegin", _wrap_arrayR3_t_rbegin, METH_O, "arrayR3_t_rbegin(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"},
+ { "arrayR3_t_rend", _wrap_arrayR3_t_rend, METH_O, "arrayR3_t_rend(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"},
+ { "arrayR3_t_front", _wrap_arrayR3_t_front, METH_O, "arrayR3_t_front(arrayR3_t self) -> std::array< double,3 >::value_type const &"},
+ { "arrayR3_t_back", _wrap_arrayR3_t_back, METH_O, "arrayR3_t_back(arrayR3_t self) -> std::array< double,3 >::value_type const &"},
+ { "arrayR3_t_fill", _wrap_arrayR3_t_fill, METH_VARARGS, "arrayR3_t_fill(arrayR3_t self, std::array< double,3 >::value_type const & u)"},
+ { "delete_arrayR3_t", _wrap_delete_arrayR3_t, METH_O, "delete_arrayR3_t(arrayR3_t self)"},
+ { "arrayR3_t_swigregister", arrayR3_t_swigregister, METH_O, NULL},
+ { "arrayR3_t_swiginit", arrayR3_t_swiginit, METH_VARARGS, NULL},
+ { "arrayC3_t_iterator", _wrap_arrayC3_t_iterator, METH_O, "arrayC3_t_iterator(arrayC3_t self) -> SwigPyIterator"},
+ { "arrayC3_t___nonzero__", _wrap_arrayC3_t___nonzero__, METH_O, "arrayC3_t___nonzero__(arrayC3_t self) -> bool"},
+ { "arrayC3_t___bool__", _wrap_arrayC3_t___bool__, METH_O, "arrayC3_t___bool__(arrayC3_t self) -> bool"},
+ { "arrayC3_t___len__", _wrap_arrayC3_t___len__, METH_O, "arrayC3_t___len__(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"},
+ { "arrayC3_t___getslice__", _wrap_arrayC3_t___getslice__, METH_VARARGS, "arrayC3_t___getslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j) -> arrayC3_t"},
+ { "arrayC3_t___setslice__", _wrap_arrayC3_t___setslice__, METH_VARARGS, "\n"
+ "arrayC3_t___setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)\n"
+ "arrayC3_t___setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j, arrayC3_t v)\n"
+ ""},
+ { "arrayC3_t___delslice__", _wrap_arrayC3_t___delslice__, METH_VARARGS, "arrayC3_t___delslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)"},
+ { "arrayC3_t___delitem__", _wrap_arrayC3_t___delitem__, METH_VARARGS, "\n"
+ "arrayC3_t___delitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i)\n"
+ "arrayC3_t___delitem__(arrayC3_t self, PySliceObject * slice)\n"
+ ""},
+ { "arrayC3_t___getitem__", _wrap_arrayC3_t___getitem__, METH_VARARGS, "\n"
+ "arrayC3_t___getitem__(arrayC3_t self, PySliceObject * slice) -> arrayC3_t\n"
+ "arrayC3_t___getitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i) -> std::array< std::complex< double >,3 >::value_type const &\n"
+ ""},
+ { "arrayC3_t___setitem__", _wrap_arrayC3_t___setitem__, METH_VARARGS, "\n"
+ "arrayC3_t___setitem__(arrayC3_t self, PySliceObject * slice, arrayC3_t v)\n"
+ "arrayC3_t___setitem__(arrayC3_t self, PySliceObject * slice)\n"
+ "arrayC3_t___setitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::value_type const & x)\n"
+ ""},
+ { "new_arrayC3_t", _wrap_new_arrayC3_t, METH_VARARGS, "\n"
+ "arrayC3_t()\n"
+ "new_arrayC3_t(arrayC3_t other) -> arrayC3_t\n"
+ ""},
+ { "arrayC3_t_empty", _wrap_arrayC3_t_empty, METH_O, "arrayC3_t_empty(arrayC3_t self) -> bool"},
+ { "arrayC3_t_size", _wrap_arrayC3_t_size, METH_O, "arrayC3_t_size(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"},
+ { "arrayC3_t_swap", _wrap_arrayC3_t_swap, METH_VARARGS, "arrayC3_t_swap(arrayC3_t self, arrayC3_t v)"},
+ { "arrayC3_t_begin", _wrap_arrayC3_t_begin, METH_O, "arrayC3_t_begin(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"},
+ { "arrayC3_t_end", _wrap_arrayC3_t_end, METH_O, "arrayC3_t_end(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"},
+ { "arrayC3_t_rbegin", _wrap_arrayC3_t_rbegin, METH_O, "arrayC3_t_rbegin(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"},
+ { "arrayC3_t_rend", _wrap_arrayC3_t_rend, METH_O, "arrayC3_t_rend(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"},
+ { "arrayC3_t_front", _wrap_arrayC3_t_front, METH_O, "arrayC3_t_front(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"},
+ { "arrayC3_t_back", _wrap_arrayC3_t_back, METH_O, "arrayC3_t_back(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"},
+ { "arrayC3_t_fill", _wrap_arrayC3_t_fill, METH_VARARGS, "arrayC3_t_fill(arrayC3_t self, std::array< std::complex< double >,3 >::value_type const & u)"},
+ { "delete_arrayC3_t", _wrap_delete_arrayC3_t, METH_O, "delete_arrayC3_t(arrayC3_t self)"},
+ { "arrayC3_t_swigregister", arrayC3_t_swigregister, METH_O, NULL},
+ { "arrayC3_t_swiginit", arrayC3_t_swiginit, METH_VARARGS, NULL},
{ "vdouble1d_t_iterator", _wrap_vdouble1d_t_iterator, METH_O, "vdouble1d_t_iterator(vdouble1d_t self) -> SwigPyIterator"},
{ "vdouble1d_t___nonzero__", _wrap_vdouble1d_t___nonzero__, METH_O, "vdouble1d_t___nonzero__(vdouble1d_t self) -> bool"},
{ "vdouble1d_t___bool__", _wrap_vdouble1d_t___bool__, METH_O, "vdouble1d_t___bool__(vdouble1d_t self) -> bool"},
@@ -43571,6 +46137,8 @@ static swig_type_info _swigt__p_std__allocatorT_std__string_t = {"_p_std__alloca
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t = {"_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t", "std::vector< std::vector< double > >::allocator_type *|std::allocator< std::vector< double,std::allocator< double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t = {"_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t", "std::vector< std::vector< int > >::allocator_type *|std::allocator< std::vector< int,std::allocator< int > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_unsigned_long_t = {"_p_std__allocatorT_unsigned_long_t", "std::vector< unsigned long >::allocator_type *|std::allocator< unsigned long > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__arrayT_double_3_t = {"_p_std__arrayT_double_3_t", "std::array< double,3 > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__arrayT_std__complexT_double_t_3_t = {"_p_std__arrayT_std__complexT_double_t_3_t", "std::array< std::complex< double >,3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__complexT_double_t = {"_p_std__complexT_double_t", "complex_t *|std::complex< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__lessT_std__string_t = {"_p_std__lessT_std__string_t", "std::less< std::string > *", 0, 0, (void*)0, 0};
@@ -43753,6 +46321,8 @@ static swig_type_info *swig_type_initial[] = {
&_swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t,
&_swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t,
&_swigt__p_std__allocatorT_unsigned_long_t,
+ &_swigt__p_std__arrayT_double_3_t,
+ &_swigt__p_std__arrayT_std__complexT_double_t_3_t,
&_swigt__p_std__complexT_double_t,
&_swigt__p_std__invalid_argument,
&_swigt__p_std__lessT_std__string_t,
@@ -43935,6 +46505,8 @@ static swig_cast_info _swigc__p_std__allocatorT_std__string_t[] = { {&_swigt__p
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t[] = { {&_swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t[] = { {&_swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_unsigned_long_t[] = { {&_swigt__p_std__allocatorT_unsigned_long_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__arrayT_double_3_t[] = { {&_swigt__p_std__arrayT_double_3_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__arrayT_std__complexT_double_t_3_t[] = { {&_swigt__p_std__arrayT_std__complexT_double_t_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__complexT_double_t[] = { {&_swigt__p_std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__lessT_std__string_t[] = { {&_swigt__p_std__lessT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -44117,6 +46689,8 @@ static swig_cast_info *swig_cast_initial[] = {
_swigc__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t,
_swigc__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t,
_swigc__p_std__allocatorT_unsigned_long_t,
+ _swigc__p_std__arrayT_double_3_t,
+ _swigc__p_std__arrayT_std__complexT_double_t_3_t,
_swigc__p_std__complexT_double_t,
_swigc__p_std__invalid_argument,
_swigc__p_std__lessT_std__string_t,
diff --git a/auto/Wrap/libBornAgainResample.py b/auto/Wrap/libBornAgainResample.py
index b20f1173f3a..f5a00afd1c2 100644
--- a/auto/Wrap/libBornAgainResample.py
+++ b/auto/Wrap/libBornAgainResample.py
@@ -157,6 +157,230 @@ def deprecated(message):
return deprecated_func
return deprecated_decorator
+class arrayR3_t(object):
+ r"""Proxy of C++ std::array< double,3 > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(arrayR3_t self) -> SwigPyIterator"""
+ return _libBornAgainResample.arrayR3_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(arrayR3_t self) -> bool"""
+ return _libBornAgainResample.arrayR3_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(arrayR3_t self) -> bool"""
+ return _libBornAgainResample.arrayR3_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(arrayR3_t self) -> std::array< double,3 >::size_type"""
+ return _libBornAgainResample.arrayR3_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j) -> arrayR3_t"""
+ return _libBornAgainResample.arrayR3_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)
+ __setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j, arrayR3_t v)
+ """
+ return _libBornAgainResample.arrayR3_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)"""
+ return _libBornAgainResample.arrayR3_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(arrayR3_t self, std::array< double,3 >::difference_type i)
+ __delitem__(arrayR3_t self, PySliceObject * slice)
+ """
+ return _libBornAgainResample.arrayR3_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(arrayR3_t self, PySliceObject * slice) -> arrayR3_t
+ __getitem__(arrayR3_t self, std::array< double,3 >::difference_type i) -> std::array< double,3 >::value_type const &
+ """
+ return _libBornAgainResample.arrayR3_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(arrayR3_t self, PySliceObject * slice, arrayR3_t v)
+ __setitem__(arrayR3_t self, PySliceObject * slice)
+ __setitem__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::value_type const & x)
+ """
+ return _libBornAgainResample.arrayR3_t___setitem__(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(arrayR3_t self) -> arrayR3_t
+ __init__(arrayR3_t self, arrayR3_t other) -> arrayR3_t
+ """
+ _libBornAgainResample.arrayR3_t_swiginit(self, _libBornAgainResample.new_arrayR3_t(*args))
+
+ def empty(self):
+ r"""empty(arrayR3_t self) -> bool"""
+ return _libBornAgainResample.arrayR3_t_empty(self)
+
+ def size(self):
+ r"""size(arrayR3_t self) -> std::array< double,3 >::size_type"""
+ return _libBornAgainResample.arrayR3_t_size(self)
+
+ def swap(self, v):
+ r"""swap(arrayR3_t self, arrayR3_t v)"""
+ return _libBornAgainResample.arrayR3_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(arrayR3_t self) -> std::array< double,3 >::iterator"""
+ return _libBornAgainResample.arrayR3_t_begin(self)
+
+ def end(self):
+ r"""end(arrayR3_t self) -> std::array< double,3 >::iterator"""
+ return _libBornAgainResample.arrayR3_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"""
+ return _libBornAgainResample.arrayR3_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"""
+ return _libBornAgainResample.arrayR3_t_rend(self)
+
+ def front(self):
+ r"""front(arrayR3_t self) -> std::array< double,3 >::value_type const &"""
+ return _libBornAgainResample.arrayR3_t_front(self)
+
+ def back(self):
+ r"""back(arrayR3_t self) -> std::array< double,3 >::value_type const &"""
+ return _libBornAgainResample.arrayR3_t_back(self)
+
+ def fill(self, u):
+ r"""fill(arrayR3_t self, std::array< double,3 >::value_type const & u)"""
+ return _libBornAgainResample.arrayR3_t_fill(self, u)
+ __swig_destroy__ = _libBornAgainResample.delete_arrayR3_t
+
+# Register arrayR3_t in _libBornAgainResample:
+_libBornAgainResample.arrayR3_t_swigregister(arrayR3_t)
+
+class arrayC3_t(object):
+ r"""Proxy of C++ std::array< std::complex< double >,3 > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(arrayC3_t self) -> SwigPyIterator"""
+ return _libBornAgainResample.arrayC3_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(arrayC3_t self) -> bool"""
+ return _libBornAgainResample.arrayC3_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(arrayC3_t self) -> bool"""
+ return _libBornAgainResample.arrayC3_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"""
+ return _libBornAgainResample.arrayC3_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j) -> arrayC3_t"""
+ return _libBornAgainResample.arrayC3_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)
+ __setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j, arrayC3_t v)
+ """
+ return _libBornAgainResample.arrayC3_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)"""
+ return _libBornAgainResample.arrayC3_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i)
+ __delitem__(arrayC3_t self, PySliceObject * slice)
+ """
+ return _libBornAgainResample.arrayC3_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(arrayC3_t self, PySliceObject * slice) -> arrayC3_t
+ __getitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i) -> std::array< std::complex< double >,3 >::value_type const &
+ """
+ return _libBornAgainResample.arrayC3_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(arrayC3_t self, PySliceObject * slice, arrayC3_t v)
+ __setitem__(arrayC3_t self, PySliceObject * slice)
+ __setitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::value_type const & x)
+ """
+ return _libBornAgainResample.arrayC3_t___setitem__(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(arrayC3_t self) -> arrayC3_t
+ __init__(arrayC3_t self, arrayC3_t other) -> arrayC3_t
+ """
+ _libBornAgainResample.arrayC3_t_swiginit(self, _libBornAgainResample.new_arrayC3_t(*args))
+
+ def empty(self):
+ r"""empty(arrayC3_t self) -> bool"""
+ return _libBornAgainResample.arrayC3_t_empty(self)
+
+ def size(self):
+ r"""size(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"""
+ return _libBornAgainResample.arrayC3_t_size(self)
+
+ def swap(self, v):
+ r"""swap(arrayC3_t self, arrayC3_t v)"""
+ return _libBornAgainResample.arrayC3_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"""
+ return _libBornAgainResample.arrayC3_t_begin(self)
+
+ def end(self):
+ r"""end(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"""
+ return _libBornAgainResample.arrayC3_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"""
+ return _libBornAgainResample.arrayC3_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"""
+ return _libBornAgainResample.arrayC3_t_rend(self)
+
+ def front(self):
+ r"""front(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"""
+ return _libBornAgainResample.arrayC3_t_front(self)
+
+ def back(self):
+ r"""back(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"""
+ return _libBornAgainResample.arrayC3_t_back(self)
+
+ def fill(self, u):
+ r"""fill(arrayC3_t self, std::array< std::complex< double >,3 >::value_type const & u)"""
+ return _libBornAgainResample.arrayC3_t_fill(self, u)
+ __swig_destroy__ = _libBornAgainResample.delete_arrayC3_t
+
+# Register arrayC3_t in _libBornAgainResample:
+_libBornAgainResample.arrayC3_t_swigregister(arrayC3_t)
+
class vdouble1d_t(object):
r"""Proxy of C++ std::vector< double > class."""
@@ -1836,7 +2060,7 @@ _libBornAgainResample.SimulationOptions_swigregister(SimulationOptions)
import libBornAgainFit
import libBornAgainBase
-class R3(object):
+class R3(arrayR3_t):
r"""Proxy of C++ BasicVector3D< double > class."""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
@@ -1845,7 +2069,7 @@ class R3(object):
def __init__(self, *args):
r"""
__init__(R3 self) -> R3
- __init__(R3 self, double const x1, double const y1, double const z1) -> R3
+ __init__(R3 self, double const x, double const y, double const z) -> R3
"""
_libBornAgainResample.R3_swiginit(self, _libBornAgainResample.new_R3(*args))
@@ -2124,7 +2348,7 @@ class vector_R3(object):
# Register vector_R3 in _libBornAgainResample:
_libBornAgainResample.vector_R3_swigregister(vector_R3)
-class C3(object):
+class C3(arrayC3_t):
r"""Proxy of C++ BasicVector3D< std::complex< double > > class."""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
@@ -2133,7 +2357,7 @@ class C3(object):
def __init__(self, *args):
r"""
__init__(C3 self) -> C3
- __init__(C3 self, std::complex< double > const x1, std::complex< double > const y1, std::complex< double > const z1) -> C3
+ __init__(C3 self, std::complex< double > const x, std::complex< double > const y, std::complex< double > const z) -> C3
"""
_libBornAgainResample.C3_swiginit(self, _libBornAgainResample.new_C3(*args))
diff --git a/auto/Wrap/libBornAgainResample_wrap.cpp b/auto/Wrap/libBornAgainResample_wrap.cpp
index 815cde9ef52..3aa82646ffc 100644
--- a/auto/Wrap/libBornAgainResample_wrap.cpp
+++ b/auto/Wrap/libBornAgainResample_wrap.cpp
@@ -3127,29 +3127,31 @@ namespace Swig {
#define SWIGTYPE_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t swig_types[27]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t swig_types[28]
#define SWIGTYPE_p_std__allocatorT_unsigned_long_t swig_types[29]
-#define SWIGTYPE_p_std__complexT_double_t swig_types[30]
-#define SWIGTYPE_p_std__invalid_argument swig_types[31]
-#define SWIGTYPE_p_std__lessT_std__string_t swig_types[32]
-#define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[33]
-#define SWIGTYPE_p_std__pairT_double_double_t swig_types[34]
-#define SWIGTYPE_p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t swig_types[35]
-#define SWIGTYPE_p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t swig_types[36]
-#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[37]
-#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[38]
-#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[39]
-#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[40]
-#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[41]
-#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[42]
-#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[43]
-#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[44]
-#define SWIGTYPE_p_swig__SwigPyIterator swig_types[45]
-#define SWIGTYPE_p_unsigned_char swig_types[46]
-#define SWIGTYPE_p_unsigned_int swig_types[47]
-#define SWIGTYPE_p_unsigned_long_long swig_types[48]
-#define SWIGTYPE_p_unsigned_short swig_types[49]
-#define SWIGTYPE_p_value_type swig_types[50]
-static swig_type_info *swig_types[52];
-static swig_module_info swig_module = {swig_types, 51, 0, 0, 0, 0};
+#define SWIGTYPE_p_std__arrayT_double_3_t swig_types[30]
+#define SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t swig_types[31]
+#define SWIGTYPE_p_std__complexT_double_t swig_types[32]
+#define SWIGTYPE_p_std__invalid_argument swig_types[33]
+#define SWIGTYPE_p_std__lessT_std__string_t swig_types[34]
+#define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[35]
+#define SWIGTYPE_p_std__pairT_double_double_t swig_types[36]
+#define SWIGTYPE_p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t swig_types[37]
+#define SWIGTYPE_p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t swig_types[38]
+#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[39]
+#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[40]
+#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[41]
+#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[42]
+#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[43]
+#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[44]
+#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[45]
+#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[46]
+#define SWIGTYPE_p_swig__SwigPyIterator swig_types[47]
+#define SWIGTYPE_p_unsigned_char swig_types[48]
+#define SWIGTYPE_p_unsigned_int swig_types[49]
+#define SWIGTYPE_p_unsigned_long_long swig_types[50]
+#define SWIGTYPE_p_unsigned_short swig_types[51]
+#define SWIGTYPE_p_value_type swig_types[52]
+static swig_type_info *swig_types[54];
+static swig_module_info swig_module = {swig_types, 53, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
@@ -4984,48 +4986,104 @@ namespace swig {
namespace swig {
- template <class T>
- struct traits_reserve<std::vector<T> > {
- static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
- seq.reserve(n);
+ template <class T, size_t N>
+ struct traits_asptr<std::array<T, N> > {
+ static int asptr(PyObject *obj, std::array<T, N> **vec) {
+ return traits_asptr_stdseq<std::array<T, N> >::asptr(obj, vec);
}
};
- template <class T>
- struct traits_asptr<std::vector<T> > {
- static int asptr(PyObject *obj, std::vector<T> **vec) {
- return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+ template <class T, size_t N>
+ struct traits_from<std::array<T, N> > {
+ static PyObject *from(const std::array<T, N>& vec) {
+ return traits_from_stdseq<std::array<T, N> >::from(vec);
}
};
-
- template <class T>
- struct traits_from<std::vector<T> > {
- static PyObject *from(const std::vector<T>& vec) {
- return traits_from_stdseq<std::vector<T> >::from(vec);
+
+ template <class SwigPySeq, class T, size_t N>
+ inline void
+ assign(const SwigPySeq& swigpyseq, std::array<T, N>* seq) {
+ if (swigpyseq.size() < seq->size())
+ throw std::invalid_argument("std::array cannot be expanded in size");
+ else if (swigpyseq.size() > seq->size())
+ throw std::invalid_argument("std::array cannot be reduced in size");
+ std::copy(swigpyseq.begin(), swigpyseq.end(), seq->begin());
+ }
+
+ template <class T, size_t N>
+ inline void
+ erase(std::array<T, N>* SWIGUNUSEDPARM(seq), const typename std::array<T, N>::iterator& SWIGUNUSEDPARM(position)) {
+ throw std::invalid_argument("std::array object does not support item deletion");
+ }
+
+ // Only limited slicing is supported as std::array is fixed in size
+ template <class T, size_t N, class Difference>
+ inline std::array<T, N>*
+ getslice(const std::array<T, N>* self, Difference i, Difference j, Py_ssize_t step) {
+ typedef std::array<T, N> Sequence;
+ typename Sequence::size_type size = self->size();
+ Difference ii = 0;
+ Difference jj = 0;
+ swig::slice_adjust(i, j, step, size, ii, jj);
+
+ if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
+ Sequence *sequence = new Sequence();
+ std::copy(self->begin(), self->end(), sequence->begin());
+ return sequence;
+ } else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
+ Sequence *sequence = new Sequence();
+ std::copy(self->rbegin(), self->rend(), sequence->begin());
+ return sequence;
+ } else {
+ throw std::invalid_argument("std::array object only supports getting a slice that is the size of the array");
}
- };
+ }
+
+ template <class T, size_t N, class Difference, class InputSeq>
+ inline void
+ setslice(std::array<T, N>* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
+ typedef std::array<T, N> Sequence;
+ typename Sequence::size_type size = self->size();
+ Difference ii = 0;
+ Difference jj = 0;
+ swig::slice_adjust(i, j, step, size, ii, jj, true);
+
+ if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
+ std::copy(is.begin(), is.end(), self->begin());
+ } else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
+ std::copy(is.rbegin(), is.rend(), self->begin());
+ } else {
+ throw std::invalid_argument("std::array object only supports setting a slice that is the size of the array");
+ }
+ }
+
+ template <class T, size_t N, class Difference>
+ inline void
+ delslice(std::array<T, N>* SWIGUNUSEDPARM(self), Difference SWIGUNUSEDPARM(i), Difference SWIGUNUSEDPARM(j), Py_ssize_t SWIGUNUSEDPARM(step)) {
+ throw std::invalid_argument("std::array object does not support item deletion");
+ }
}
namespace swig {
- template <> struct traits<std::vector< double, std::allocator< double > > > {
+ template <> struct traits<std::array< double, 3 > > {
typedef pointer_category category;
static const char* type_name() {
- return "std::vector<" "double" "," "std::allocator< double >" " >";
+ return "std::array<" "double" "," "3" " >";
}
};
}
-SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_array_Sl_double_Sc_3_Sg__iterator(std::array< double,3 > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
+SWIGINTERN bool std_array_Sl_double_Sc_3_Sg____nonzero__(std::array< double,3 > const *self){
return !(self->empty());
}
-SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
+SWIGINTERN bool std_array_Sl_double_Sc_3_Sg____bool__(std::array< double,3 > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
+SWIGINTERN std::array< double,3 >::size_type std_array_Sl_double_Sc_3_Sg____len__(std::array< double,3 > const *self){
return self->size();
}
@@ -5062,66 +5120,66 @@ SWIG_From_size_t (size_t value)
#endif
}
-SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+SWIGINTERN std::array< double,3 > *std_array_Sl_double_Sc_3_Sg____getslice__(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
return swig::getslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
- swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setslice____SWIG_0(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
+ swig::setslice(self, i, j, 1, std::array< double,3 >());
}
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setslice____SWIG_1(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j,std::array< double,3 > const &v){
swig::setslice(self, i, j, 1, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delslice__(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
swig::delslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delitem____SWIG_0(std::array< double,3 > *self,std::array< double,3 >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN std::array< double,3 > *std_array_Sl_double_Sc_3_Sg____getitem____SWIG_0(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_0(std::array< double,3 > *self,PySliceObject *slice,std::array< double,3 > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_1(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delitem____SWIG_1(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
+SWIGINTERN std::array< double,3 >::value_type const &std_array_Sl_double_Sc_3_Sg____getitem____SWIG_1(std::array< double,3 > const *self,std::array< double,3 >::difference_type i){
return *(swig::cgetpos(self, i));
}
@@ -5159,227 +5217,476 @@ namespace swig {
};
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_2(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
-SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
- if (self->size() == 0)
- throw std::out_of_range("pop from empty container");
- std::vector< double,std::allocator< double > >::value_type x = self->back();
- self->pop_back();
- return x;
+
+SWIGINTERN int
+SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
+{
+ if (PyComplex_Check(o)) {
+ if (val) *val = std::complex<double>(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
+ return SWIG_OK;
+ } else {
+ double d;
+ int res = SWIG_AddCast(SWIG_AsVal_double (o, &d));
+ if (SWIG_IsOK(res)) {
+ if (val) *val = std::complex<double>(d, 0.0);
+ return res;
}
-SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
- self->push_back(x);
+ }
+ return SWIG_TypeError;
+}
+
+
+SWIGINTERNINLINE PyObject*
+SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/local/share/swig/4.0.2/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+
+const std::complex<double>&
+
+
+
+/*@SWIG@*/ c)
+{
+ return PyComplex_FromDoubles(std::real(c), std::imag(c));
+}
+
+
+namespace swig {
+ template <> struct traits< std::complex<double> > {
+ typedef value_category category;
+ static const char* type_name() { return"std::complex<double>"; }
+ };
+ template <> struct traits_asval< std::complex<double> > {
+ typedef std::complex<double> value_type;
+ static int asval(PyObject *obj, value_type *val) {
+ return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
}
-SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos){ return self->erase(pos); }
-SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_1(std::vector< double > *self,std::vector< double >::iterator first,std::vector< double >::iterator last){ return self->erase(first, last); }
-SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::value_type const &x){ return self->insert(pos, x); }
-SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }
+ };
+ template <> struct traits_from< std::complex<double> > {
+ typedef std::complex<double> value_type;
+ static PyObject *from(const value_type& val) {
+ return SWIG_From_std_complex_Sl_double_Sg_ (val);
+ }
+ };
+}
+
namespace swig {
- template <> struct traits<std::vector< std::vector< double,std::allocator< double > >, std::allocator< std::vector< double,std::allocator< double > > > > > {
+ template <> struct traits<std::array< std::complex< double >, 3 > > {
typedef pointer_category category;
static const char* type_name() {
- return "std::vector<" "std::vector< double,std::allocator< double > >" "," "std::allocator< std::vector< double,std::allocator< double > > >" " >";
+ return "std::array<" "std::complex< double >" "," "3" " >";
}
};
}
-SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_vector_Sl_double_Sg__Sg__iterator(std::vector< std::vector< double > > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg__iterator(std::array< std::complex< double >,3 > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____nonzero__(std::vector< std::vector< double > > const *self){
+SWIGINTERN bool std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____nonzero__(std::array< std::complex< double >,3 > const *self){
return !(self->empty());
}
-SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____bool__(std::vector< std::vector< double > > const *self){
+SWIGINTERN bool std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____bool__(std::array< std::complex< double >,3 > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector< std::vector< double > >::size_type std_vector_Sl_std_vector_Sl_double_Sg__Sg____len__(std::vector< std::vector< double > > const *self){
+SWIGINTERN std::array< std::complex< double >,3 >::size_type std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____len__(std::array< std::complex< double >,3 > const *self){
return self->size();
}
-SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
+SWIGINTERN std::array< std::complex< double >,3 > *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getslice__(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
return swig::getslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
- swig::setslice(self, i, j, 1, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >());
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_0(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
+ swig::setslice(self, i, j, 1, std::array< std::complex< double >,3 >());
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_1(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j,std::array< std::complex< double >,3 > const &v){
swig::setslice(self, i, j, 1, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delslice__(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
swig::delslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_0(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN std::array< std::complex< double >,3 > *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_0(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_0(std::array< std::complex< double >,3 > *self,PySliceObject *slice,std::array< std::complex< double >,3 > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_1(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_1(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN std::vector< std::vector< double > >::value_type const &std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_1(std::vector< std::vector< double > > const *self,std::vector< std::vector< double > >::difference_type i){
+SWIGINTERN std::array< std::complex< double >,3 >::value_type const &std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_1(std::array< std::complex< double >,3 > const *self,std::array< std::complex< double >,3 >::difference_type i){
return *(swig::cgetpos(self, i));
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_2(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::value_type const &x){
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_2(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
-SWIGINTERN std::vector< std::vector< double > >::value_type std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(std::vector< std::vector< double > > *self){
- if (self->size() == 0)
- throw std::out_of_range("pop from empty container");
- std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type x = self->back();
- self->pop_back();
- return x;
- }
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__append(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::value_type const &x){
- self->push_back(x);
- }
-SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos){ return self->erase(pos); }
-SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator first,std::vector< std::vector< double > >::iterator last){ return self->erase(first, last); }
-SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos,std::vector< std::vector< double > >::value_type const &x){ return self->insert(pos, x); }
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos,std::vector< std::vector< double > >::size_type n,std::vector< std::vector< double > >::value_type const &x){ self->insert(pos, n, x); }
-
-SWIGINTERN int
-SWIG_AsVal_int (PyObject * obj, int *val)
-{
- long v;
- int res = SWIG_AsVal_long (obj, &v);
- if (SWIG_IsOK(res)) {
- if ((v < INT_MIN || v > INT_MAX)) {
- return SWIG_OverflowError;
- } else {
- if (val) *val = static_cast< int >(v);
- }
- }
- return res;
-}
+ namespace swig {
+ template <class T>
+ struct traits_reserve<std::vector<T> > {
+ static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
+ seq.reserve(n);
+ }
+ };
-namespace swig {
- template <> struct traits< int > {
- typedef value_category category;
- static const char* type_name() { return"int"; }
- };
- template <> struct traits_asval< int > {
- typedef int value_type;
- static int asval(PyObject *obj, value_type *val) {
- return SWIG_AsVal_int (obj, val);
- }
- };
- template <> struct traits_from< int > {
- typedef int value_type;
- static PyObject *from(const value_type& val) {
- return SWIG_From_int (val);
- }
- };
-}
+ template <class T>
+ struct traits_asptr<std::vector<T> > {
+ static int asptr(PyObject *obj, std::vector<T> **vec) {
+ return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+ }
+ };
+
+ template <class T>
+ struct traits_from<std::vector<T> > {
+ static PyObject *from(const std::vector<T>& vec) {
+ return traits_from_stdseq<std::vector<T> >::from(vec);
+ }
+ };
+ }
namespace swig {
- template <> struct traits<std::vector< int, std::allocator< int > > > {
+ template <> struct traits<std::vector< double, std::allocator< double > > > {
typedef pointer_category category;
static const char* type_name() {
- return "std::vector<" "int" "," "std::allocator< int >" " >";
+ return "std::vector<" "double" "," "std::allocator< double >" " >";
}
};
}
-SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
+SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
return !(self->empty());
}
-SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
+SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
+SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
return self->size();
}
-SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
return swig::getslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
- swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >());
+SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+ swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
}
-SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
swig::setslice(self, i, j, 1, v);
}
-SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
+SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
swig::delslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< int,std::allocator< int > >::difference_type id = i;
- std::vector< int,std::allocator< int > >::difference_type jd = j;
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< int,std::allocator< int > >::difference_type id = i;
- std::vector< int,std::allocator< int > >::difference_type jd = j;
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< int,std::allocator< int > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
+ return *(swig::cgetpos(self, i));
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
+ *(swig::getpos(self,i)) = x;
+ }
+SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
+ if (self->size() == 0)
+ throw std::out_of_range("pop from empty container");
+ std::vector< double,std::allocator< double > >::value_type x = self->back();
+ self->pop_back();
+ return x;
+ }
+SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
+ self->push_back(x);
+ }
+SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos){ return self->erase(pos); }
+SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_1(std::vector< double > *self,std::vector< double >::iterator first,std::vector< double >::iterator last){ return self->erase(first, last); }
+SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::value_type const &x){ return self->insert(pos, x); }
+SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }
+
+ namespace swig {
+ template <> struct traits<std::vector< std::vector< double,std::allocator< double > >, std::allocator< std::vector< double,std::allocator< double > > > > > {
+ typedef pointer_category category;
+ static const char* type_name() {
+ return "std::vector<" "std::vector< double,std::allocator< double > >" "," "std::allocator< std::vector< double,std::allocator< double > > >" " >";
+ }
+ };
+ }
+
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_vector_Sl_double_Sg__Sg__iterator(std::vector< std::vector< double > > *self,PyObject **PYTHON_SELF){
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+ }
+SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____nonzero__(std::vector< std::vector< double > > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____bool__(std::vector< std::vector< double > > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN std::vector< std::vector< double > >::size_type std_vector_Sl_std_vector_Sl_double_Sg__Sg____len__(std::vector< std::vector< double > > const *self){
+ return self->size();
+ }
+SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
+ return swig::getslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
+ swig::setslice(self, i, j, 1, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >());
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+ swig::setslice(self, i, j, 1, v);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
+ swig::delslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
+ swig::erase(self, swig::getpos(self, i));
+ }
+SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ return swig::getslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ swig::setslice(self, id, jd, step, v);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN std::vector< std::vector< double > >::value_type const &std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_1(std::vector< std::vector< double > > const *self,std::vector< std::vector< double > >::difference_type i){
+ return *(swig::cgetpos(self, i));
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_2(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::value_type const &x){
+ *(swig::getpos(self,i)) = x;
+ }
+SWIGINTERN std::vector< std::vector< double > >::value_type std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(std::vector< std::vector< double > > *self){
+ if (self->size() == 0)
+ throw std::out_of_range("pop from empty container");
+ std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type x = self->back();
+ self->pop_back();
+ return x;
+ }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__append(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::value_type const &x){
+ self->push_back(x);
+ }
+SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos){ return self->erase(pos); }
+SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator first,std::vector< std::vector< double > >::iterator last){ return self->erase(first, last); }
+SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos,std::vector< std::vector< double > >::value_type const &x){ return self->insert(pos, x); }
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos,std::vector< std::vector< double > >::size_type n,std::vector< std::vector< double > >::value_type const &x){ self->insert(pos, n, x); }
+
+SWIGINTERN int
+SWIG_AsVal_int (PyObject * obj, int *val)
+{
+ long v;
+ int res = SWIG_AsVal_long (obj, &v);
+ if (SWIG_IsOK(res)) {
+ if ((v < INT_MIN || v > INT_MAX)) {
+ return SWIG_OverflowError;
+ } else {
+ if (val) *val = static_cast< int >(v);
+ }
+ }
+ return res;
+}
+
+
+namespace swig {
+ template <> struct traits< int > {
+ typedef value_category category;
+ static const char* type_name() { return"int"; }
+ };
+ template <> struct traits_asval< int > {
+ typedef int value_type;
+ static int asval(PyObject *obj, value_type *val) {
+ return SWIG_AsVal_int (obj, val);
+ }
+ };
+ template <> struct traits_from< int > {
+ typedef int value_type;
+ static PyObject *from(const value_type& val) {
+ return SWIG_From_int (val);
+ }
+ };
+}
+
+
+ namespace swig {
+ template <> struct traits<std::vector< int, std::allocator< int > > > {
+ typedef pointer_category category;
+ static const char* type_name() {
+ return "std::vector<" "int" "," "std::allocator< int >" " >";
+ }
+ };
+ }
+
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+ }
+SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
+ return self->size();
+ }
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
+ return swig::getslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
+ swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >());
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
+ swig::setslice(self, i, j, 1, v);
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
+ swig::delslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
+ swig::erase(self, swig::getpos(self, i));
+ }
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< int,std::allocator< int > >::difference_type id = i;
+ std::vector< int,std::allocator< int > >::difference_type jd = j;
+ return swig::getslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< int,std::allocator< int > >::difference_type id = i;
+ std::vector< int,std::allocator< int > >::difference_type jd = j;
+ swig::setslice(self, id, jd, step, v);
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
@@ -5637,57 +5944,6 @@ SWIGINTERN std::vector< unsigned long >::iterator std_vector_Sl_unsigned_SS_long
SWIGINTERN std::vector< unsigned long >::iterator std_vector_Sl_unsigned_SS_long_Sg__insert__SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::iterator pos,std::vector< unsigned long >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg__insert__SWIG_1(std::vector< unsigned long > *self,std::vector< unsigned long >::iterator pos,std::vector< unsigned long >::size_type n,std::vector< unsigned long >::value_type const &x){ self->insert(pos, n, x); }
-SWIGINTERN int
-SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
-{
- if (PyComplex_Check(o)) {
- if (val) *val = std::complex<double>(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
- return SWIG_OK;
- } else {
- double d;
- int res = SWIG_AddCast(SWIG_AsVal_double (o, &d));
- if (SWIG_IsOK(res)) {
- if (val) *val = std::complex<double>(d, 0.0);
- return res;
- }
- }
- return SWIG_TypeError;
-}
-
-
-SWIGINTERNINLINE PyObject*
-SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/local/share/swig/4.0.2/typemaps/swigmacros.swg,104,%ifcplusplus@*/
-
-const std::complex<double>&
-
-
-
-/*@SWIG@*/ c)
-{
- return PyComplex_FromDoubles(std::real(c), std::imag(c));
-}
-
-
-namespace swig {
- template <> struct traits< std::complex<double> > {
- typedef value_category category;
- static const char* type_name() { return"std::complex<double>"; }
- };
- template <> struct traits_asval< std::complex<double> > {
- typedef std::complex<double> value_type;
- static int asval(PyObject *obj, value_type *val) {
- return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
- }
- };
- template <> struct traits_from< std::complex<double> > {
- typedef std::complex<double> value_type;
- static PyObject *from(const value_type& val) {
- return SWIG_From_std_complex_Sl_double_Sg_ (val);
- }
- };
-}
-
-
namespace swig {
template <> struct traits<std::vector< std::complex< double >, std::allocator< std::complex< double > > > > {
typedef pointer_category category;
@@ -7439,280 +7695,2510 @@ fail:
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ bool result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ ptrdiff_t result;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PyObject **arg2 = (PyObject **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ arg2 = &swig_obj[0];
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_iterator" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (swig::SwigPyIterator *)std_array_Sl_double_Sc_3_Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___nonzero__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)std_array_Sl_double_Sc_3_Sg____nonzero__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___bool__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)std_array_Sl_double_Sc_3_Sg____bool__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___len__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = std_array_Sl_double_Sc_3_Sg____len__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ std::array< double,3 > *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t___getslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___getslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___getslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ result = (std::array< double,3 > *)std_array_Sl_double_Sc_3_Sg____getslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_double_Sc_3_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ std::array< double,3 > *arg4 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ int res4 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res4 = swig::asptr(swig_obj[3], &ptr);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "arrayR3_t___setslice__" "', argument " "4"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t___setslice__" "', argument " "4"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg4 = ptr;
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::array< double,3 > const &)*arg4);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[5] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___setslice__", 0, 4, argv))) SWIG_fail;
+ --argc;
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setslice____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[3], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayR3_t___setslice____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___setslice__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__setslice__(std::array< double,3 >::difference_type,std::array< double,3 >::difference_type)\n"
+ " std::array< double,3 >::__setslice__(std::array< double,3 >::difference_type,std::array< double,3 >::difference_type,std::array< double,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t___delslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___delslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___delslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_double_Sc_3_Sg____delslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___delitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ try {
+ std_array_Sl_double_Sc_3_Sg____delitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ result = (std::array< double,3 > *)std_array_Sl_double_Sc_3_Sg____getitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::array< double,3 > *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res3 = swig::asptr(swig_obj[2], &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg3 = ptr;
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_0(arg1,arg2,(std::array< double,3 > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____delitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___delitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___delitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___delitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__delitem__(std::array< double,3 >::difference_type)\n"
+ " std::array< double,3 >::__delitem__(PySliceObject *)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getitem__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___getitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ try {
+ result = (std::array< double,3 >::value_type *) &std_array_Sl_double_Sc_3_Sg____getitem____SWIG_1((std::array< double,3 > const *)arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___getitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___getitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___getitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__getitem__(PySliceObject *)\n"
+ " std::array< double,3 >::__getitem__(std::array< double,3 >::difference_type) const\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::value_type *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< double,3 >::value_type temp3 ;
+ double val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 >::value_type""'");
+ }
+ temp3 = static_cast< std::array< double,3 >::value_type >(val3);
+ arg3 = &temp3;
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_2(arg1,arg2,(double const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[4] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___setitem__", 0, 3, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_2(self, argc, argv);
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___setitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__setitem__(PySliceObject *,std::array< double,3 > const &)\n"
+ " std::array< double,3 >::__setitem__(PySliceObject *)\n"
+ " std::array< double,3 >::__setitem__(std::array< double,3 >::difference_type,std::array< double,3 >::value_type const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
+ result = (std::array< double,3 > *)new std::array< double,3 >();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_NEW | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = 0 ;
+ int res1 = SWIG_OLDOBJ ;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res1 = swig::asptr(swig_obj[0], &ptr);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg1 = ptr;
+ }
+ result = (std::array< double,3 > *)new std::array< double,3 >((std::array< double,3 > const &)*arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_NEW | 0 );
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[2] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "new_arrayR3_t", 0, 1, argv))) SWIG_fail;
+ --argc;
+ if (argc == 0) {
+ return _wrap_new_arrayR3_t__SWIG_0(self, argc, argv);
+ }
+ if (argc == 1) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_arrayR3_t__SWIG_1(self, argc, argv);
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_arrayR3_t'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::array()\n"
+ " std::array< double,3 >::array(std::array< double,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_empty" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)((std::array< double,3 > const *)arg1)->empty();
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_size" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = ((std::array< double,3 > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 > *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t_swap", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_swap" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__arrayT_double_3_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "arrayR3_t_swap" "', argument " "2"" of type '" "std::array< double,3 > &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t_swap" "', argument " "2"" of type '" "std::array< double,3 > &""'");
+ }
+ arg2 = reinterpret_cast< std::array< double,3 > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_begin" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_end" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::reverse_iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_rbegin" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::reverse_iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_rend" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_front" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (std::array< double,3 >::value_type *) &((std::array< double,3 > const *)arg1)->front();
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_back" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (std::array< double,3 >::value_type *) &((std::array< double,3 > const *)arg1)->back();
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::value_type *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< double,3 >::value_type temp2 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t_fill", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_fill" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t_fill" "', argument " "2"" of type '" "std::array< double,3 >::value_type""'");
+ }
+ temp2 = static_cast< std::array< double,3 >::value_type >(val2);
+ arg2 = &temp2;
+ (arg1)->fill((std::array< double,3 >::value_type const &)*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_arrayR3_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ delete arg1;
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *arrayR3_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__arrayT_double_3_t, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *arrayR3_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PyObject **arg2 = (PyObject **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ arg2 = &swig_obj[0];
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_iterator" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (swig::SwigPyIterator *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___nonzero__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____nonzero__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___bool__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____bool__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___len__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____len__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t___getslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___getslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___getslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ result = (std::array< std::complex< double >,3 > *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ std::array< std::complex< double >,3 > *arg4 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ int res4 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res4 = swig::asptr(swig_obj[3], &ptr);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "arrayC3_t___setslice__" "', argument " "4"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t___setslice__" "', argument " "4"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg4 = ptr;
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::array< std::complex< double >,3 > const &)*arg4);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[5] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___setslice__", 0, 4, argv))) SWIG_fail;
+ --argc;
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setslice____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[3], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayC3_t___setslice____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___setslice__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__setslice__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::difference_type)\n"
+ " std::array< std::complex< double >,3 >::__setslice__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t___delslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___delslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___delslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___delitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ result = (std::array< std::complex< double >,3 > *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::array< std::complex< double >,3 > *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res3 = swig::asptr(swig_obj[2], &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg3 = ptr;
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_0(arg1,arg2,(std::array< std::complex< double >,3 > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___delitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___delitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___delitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__delitem__(std::array< std::complex< double >,3 >::difference_type)\n"
+ " std::array< std::complex< double >,3 >::__delitem__(PySliceObject *)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___getitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ try {
+ result = (std::array< std::complex< double >,3 >::value_type *) &std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_1((std::array< std::complex< double >,3 > const *)arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___getitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___getitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___getitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__getitem__(PySliceObject *)\n"
+ " std::array< std::complex< double >,3 >::__getitem__(std::array< std::complex< double >,3 >::difference_type) const\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::value_type *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< std::complex< double >,3 >::value_type temp3 ;
+ std::complex< double > val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_std_complex_Sl_double_Sg_(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::value_type""'");
+ }
+ temp3 = static_cast< std::array< std::complex< double >,3 >::value_type >(val3);
+ arg3 = &temp3;
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_2(arg1,arg2,(std::complex< double > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[4] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___setitem__", 0, 3, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_2(self, argc, argv);
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___setitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__setitem__(PySliceObject *,std::array< std::complex< double >,3 > const &)\n"
+ " std::array< std::complex< double >,3 >::__setitem__(PySliceObject *)\n"
+ " std::array< std::complex< double >,3 >::__setitem__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::value_type const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayC3_t__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
+ result = (std::array< std::complex< double >,3 > *)new std::array< std::complex< double >,3 >();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_NEW | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayC3_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = 0 ;
+ int res1 = SWIG_OLDOBJ ;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res1 = swig::asptr(swig_obj[0], &ptr);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg1 = ptr;
+ }
+ result = (std::array< std::complex< double >,3 > *)new std::array< std::complex< double >,3 >((std::array< std::complex< double >,3 > const &)*arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_NEW | 0 );
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayC3_t(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[2] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "new_arrayC3_t", 0, 1, argv))) SWIG_fail;
+ --argc;
+ if (argc == 0) {
+ return _wrap_new_arrayC3_t__SWIG_0(self, argc, argv);
+ }
+ if (argc == 1) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_arrayC3_t__SWIG_1(self, argc, argv);
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_arrayC3_t'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::array()\n"
+ " std::array< std::complex< double >,3 >::array(std::array< std::complex< double >,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_empty" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)((std::array< std::complex< double >,3 > const *)arg1)->empty();
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_size" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = ((std::array< std::complex< double >,3 > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 > *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t_swap", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_swap" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "arrayC3_t_swap" "', argument " "2"" of type '" "std::array< std::complex< double >,3 > &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t_swap" "', argument " "2"" of type '" "std::array< std::complex< double >,3 > &""'");
+ }
+ arg2 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_begin" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- bool result;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_end" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_bool(static_cast< bool >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::reverse_iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_rbegin" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::reverse_iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_rend" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_front" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (std::array< std::complex< double >,3 >::value_type *) &((std::array< std::complex< double >,3 > const *)arg1)->front();
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_back" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (std::array< std::complex< double >,3 >::value_type *) &((std::array< std::complex< double >,3 > const *)arg1)->back();
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- ptrdiff_t result;
+ std::array< std::complex< double >,3 >::value_type temp2 ;
+ std::complex< double > val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t_fill", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_fill" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t_fill" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::value_type""'");
+ }
+ temp2 = static_cast< std::array< std::complex< double >,3 >::value_type >(val2);
+ arg2 = &temp2;
+ (arg1)->fill((std::array< std::complex< double >,3 >::value_type const &)*arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
- Py_ssize_t argc;
- PyObject *argv[3] = {
- 0
- };
+SWIGINTERN PyObject *_wrap_delete_arrayC3_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
- if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
- --argc;
- if (argc == 2) {
- int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
- }
- }
- }
- if (argc == 2) {
- int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- {
- int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
- _v = SWIG_CheckState(res);
- }
- if (_v) {
- return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
- }
- }
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
-
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ delete arg1;
+ resultobj = SWIG_Py_Void();
+ return resultobj;
fail:
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *arrayC3_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
+SWIGINTERN PyObject *arrayC3_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
SWIGINTERN PyObject *_wrap_vdouble1d_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
@@ -29668,6 +32154,86 @@ static PyMethodDef SwigMethods[] = {
"SwigPyIterator___sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t\n"
""},
{ "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
+ { "arrayR3_t_iterator", _wrap_arrayR3_t_iterator, METH_O, "arrayR3_t_iterator(arrayR3_t self) -> SwigPyIterator"},
+ { "arrayR3_t___nonzero__", _wrap_arrayR3_t___nonzero__, METH_O, "arrayR3_t___nonzero__(arrayR3_t self) -> bool"},
+ { "arrayR3_t___bool__", _wrap_arrayR3_t___bool__, METH_O, "arrayR3_t___bool__(arrayR3_t self) -> bool"},
+ { "arrayR3_t___len__", _wrap_arrayR3_t___len__, METH_O, "arrayR3_t___len__(arrayR3_t self) -> std::array< double,3 >::size_type"},
+ { "arrayR3_t___getslice__", _wrap_arrayR3_t___getslice__, METH_VARARGS, "arrayR3_t___getslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j) -> arrayR3_t"},
+ { "arrayR3_t___setslice__", _wrap_arrayR3_t___setslice__, METH_VARARGS, "\n"
+ "arrayR3_t___setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)\n"
+ "arrayR3_t___setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j, arrayR3_t v)\n"
+ ""},
+ { "arrayR3_t___delslice__", _wrap_arrayR3_t___delslice__, METH_VARARGS, "arrayR3_t___delslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)"},
+ { "arrayR3_t___delitem__", _wrap_arrayR3_t___delitem__, METH_VARARGS, "\n"
+ "arrayR3_t___delitem__(arrayR3_t self, std::array< double,3 >::difference_type i)\n"
+ "arrayR3_t___delitem__(arrayR3_t self, PySliceObject * slice)\n"
+ ""},
+ { "arrayR3_t___getitem__", _wrap_arrayR3_t___getitem__, METH_VARARGS, "\n"
+ "arrayR3_t___getitem__(arrayR3_t self, PySliceObject * slice) -> arrayR3_t\n"
+ "arrayR3_t___getitem__(arrayR3_t self, std::array< double,3 >::difference_type i) -> std::array< double,3 >::value_type const &\n"
+ ""},
+ { "arrayR3_t___setitem__", _wrap_arrayR3_t___setitem__, METH_VARARGS, "\n"
+ "arrayR3_t___setitem__(arrayR3_t self, PySliceObject * slice, arrayR3_t v)\n"
+ "arrayR3_t___setitem__(arrayR3_t self, PySliceObject * slice)\n"
+ "arrayR3_t___setitem__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::value_type const & x)\n"
+ ""},
+ { "new_arrayR3_t", _wrap_new_arrayR3_t, METH_VARARGS, "\n"
+ "arrayR3_t()\n"
+ "new_arrayR3_t(arrayR3_t other) -> arrayR3_t\n"
+ ""},
+ { "arrayR3_t_empty", _wrap_arrayR3_t_empty, METH_O, "arrayR3_t_empty(arrayR3_t self) -> bool"},
+ { "arrayR3_t_size", _wrap_arrayR3_t_size, METH_O, "arrayR3_t_size(arrayR3_t self) -> std::array< double,3 >::size_type"},
+ { "arrayR3_t_swap", _wrap_arrayR3_t_swap, METH_VARARGS, "arrayR3_t_swap(arrayR3_t self, arrayR3_t v)"},
+ { "arrayR3_t_begin", _wrap_arrayR3_t_begin, METH_O, "arrayR3_t_begin(arrayR3_t self) -> std::array< double,3 >::iterator"},
+ { "arrayR3_t_end", _wrap_arrayR3_t_end, METH_O, "arrayR3_t_end(arrayR3_t self) -> std::array< double,3 >::iterator"},
+ { "arrayR3_t_rbegin", _wrap_arrayR3_t_rbegin, METH_O, "arrayR3_t_rbegin(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"},
+ { "arrayR3_t_rend", _wrap_arrayR3_t_rend, METH_O, "arrayR3_t_rend(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"},
+ { "arrayR3_t_front", _wrap_arrayR3_t_front, METH_O, "arrayR3_t_front(arrayR3_t self) -> std::array< double,3 >::value_type const &"},
+ { "arrayR3_t_back", _wrap_arrayR3_t_back, METH_O, "arrayR3_t_back(arrayR3_t self) -> std::array< double,3 >::value_type const &"},
+ { "arrayR3_t_fill", _wrap_arrayR3_t_fill, METH_VARARGS, "arrayR3_t_fill(arrayR3_t self, std::array< double,3 >::value_type const & u)"},
+ { "delete_arrayR3_t", _wrap_delete_arrayR3_t, METH_O, "delete_arrayR3_t(arrayR3_t self)"},
+ { "arrayR3_t_swigregister", arrayR3_t_swigregister, METH_O, NULL},
+ { "arrayR3_t_swiginit", arrayR3_t_swiginit, METH_VARARGS, NULL},
+ { "arrayC3_t_iterator", _wrap_arrayC3_t_iterator, METH_O, "arrayC3_t_iterator(arrayC3_t self) -> SwigPyIterator"},
+ { "arrayC3_t___nonzero__", _wrap_arrayC3_t___nonzero__, METH_O, "arrayC3_t___nonzero__(arrayC3_t self) -> bool"},
+ { "arrayC3_t___bool__", _wrap_arrayC3_t___bool__, METH_O, "arrayC3_t___bool__(arrayC3_t self) -> bool"},
+ { "arrayC3_t___len__", _wrap_arrayC3_t___len__, METH_O, "arrayC3_t___len__(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"},
+ { "arrayC3_t___getslice__", _wrap_arrayC3_t___getslice__, METH_VARARGS, "arrayC3_t___getslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j) -> arrayC3_t"},
+ { "arrayC3_t___setslice__", _wrap_arrayC3_t___setslice__, METH_VARARGS, "\n"
+ "arrayC3_t___setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)\n"
+ "arrayC3_t___setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j, arrayC3_t v)\n"
+ ""},
+ { "arrayC3_t___delslice__", _wrap_arrayC3_t___delslice__, METH_VARARGS, "arrayC3_t___delslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)"},
+ { "arrayC3_t___delitem__", _wrap_arrayC3_t___delitem__, METH_VARARGS, "\n"
+ "arrayC3_t___delitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i)\n"
+ "arrayC3_t___delitem__(arrayC3_t self, PySliceObject * slice)\n"
+ ""},
+ { "arrayC3_t___getitem__", _wrap_arrayC3_t___getitem__, METH_VARARGS, "\n"
+ "arrayC3_t___getitem__(arrayC3_t self, PySliceObject * slice) -> arrayC3_t\n"
+ "arrayC3_t___getitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i) -> std::array< std::complex< double >,3 >::value_type const &\n"
+ ""},
+ { "arrayC3_t___setitem__", _wrap_arrayC3_t___setitem__, METH_VARARGS, "\n"
+ "arrayC3_t___setitem__(arrayC3_t self, PySliceObject * slice, arrayC3_t v)\n"
+ "arrayC3_t___setitem__(arrayC3_t self, PySliceObject * slice)\n"
+ "arrayC3_t___setitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::value_type const & x)\n"
+ ""},
+ { "new_arrayC3_t", _wrap_new_arrayC3_t, METH_VARARGS, "\n"
+ "arrayC3_t()\n"
+ "new_arrayC3_t(arrayC3_t other) -> arrayC3_t\n"
+ ""},
+ { "arrayC3_t_empty", _wrap_arrayC3_t_empty, METH_O, "arrayC3_t_empty(arrayC3_t self) -> bool"},
+ { "arrayC3_t_size", _wrap_arrayC3_t_size, METH_O, "arrayC3_t_size(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"},
+ { "arrayC3_t_swap", _wrap_arrayC3_t_swap, METH_VARARGS, "arrayC3_t_swap(arrayC3_t self, arrayC3_t v)"},
+ { "arrayC3_t_begin", _wrap_arrayC3_t_begin, METH_O, "arrayC3_t_begin(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"},
+ { "arrayC3_t_end", _wrap_arrayC3_t_end, METH_O, "arrayC3_t_end(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"},
+ { "arrayC3_t_rbegin", _wrap_arrayC3_t_rbegin, METH_O, "arrayC3_t_rbegin(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"},
+ { "arrayC3_t_rend", _wrap_arrayC3_t_rend, METH_O, "arrayC3_t_rend(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"},
+ { "arrayC3_t_front", _wrap_arrayC3_t_front, METH_O, "arrayC3_t_front(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"},
+ { "arrayC3_t_back", _wrap_arrayC3_t_back, METH_O, "arrayC3_t_back(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"},
+ { "arrayC3_t_fill", _wrap_arrayC3_t_fill, METH_VARARGS, "arrayC3_t_fill(arrayC3_t self, std::array< std::complex< double >,3 >::value_type const & u)"},
+ { "delete_arrayC3_t", _wrap_delete_arrayC3_t, METH_O, "delete_arrayC3_t(arrayC3_t self)"},
+ { "arrayC3_t_swigregister", arrayC3_t_swigregister, METH_O, NULL},
+ { "arrayC3_t_swiginit", arrayC3_t_swiginit, METH_VARARGS, NULL},
{ "vdouble1d_t_iterator", _wrap_vdouble1d_t_iterator, METH_O, "vdouble1d_t_iterator(vdouble1d_t self) -> SwigPyIterator"},
{ "vdouble1d_t___nonzero__", _wrap_vdouble1d_t___nonzero__, METH_O, "vdouble1d_t___nonzero__(vdouble1d_t self) -> bool"},
{ "vdouble1d_t___bool__", _wrap_vdouble1d_t___bool__, METH_O, "vdouble1d_t___bool__(vdouble1d_t self) -> bool"},
@@ -30317,7 +32883,7 @@ static PyMethodDef SwigMethods[] = {
{ "SimulationOptions_swiginit", SimulationOptions_swiginit, METH_VARARGS, NULL},
{ "new_R3", _wrap_new_R3, METH_VARARGS, "\n"
"R3()\n"
- "new_R3(double const x1, double const y1, double const z1) -> R3\n"
+ "new_R3(double const x, double const y, double const z) -> R3\n"
""},
{ "R3_x", _wrap_R3_x, METH_O, "R3_x(R3 self) -> double"},
{ "R3_y", _wrap_R3_y, METH_O, "R3_y(R3 self) -> double"},
@@ -30412,7 +32978,7 @@ static PyMethodDef SwigMethods[] = {
{ "vector_R3_swiginit", vector_R3_swiginit, METH_VARARGS, NULL},
{ "new_C3", _wrap_new_C3, METH_VARARGS, "\n"
"C3()\n"
- "new_C3(std::complex< double > const x1, std::complex< double > const y1, std::complex< double > const z1) -> C3\n"
+ "new_C3(std::complex< double > const x, std::complex< double > const y, std::complex< double > const z) -> C3\n"
""},
{ "C3_x", _wrap_C3_x, METH_O, "C3_x(C3 self) -> std::complex< double >"},
{ "C3_y", _wrap_C3_y, METH_O, "C3_y(C3 self) -> std::complex< double >"},
@@ -30529,6 +33095,12 @@ static PyMethodDef SwigMethods_proxydocs[] = {
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+static void *_p_BasicVector3DT_std__complexT_double_t_tTo_p_std__arrayT_std__complexT_double_t_3_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((std::array< std::complex< double >,3 > *) ((BasicVector3D< std::complex< double > > *) x));
+}
+static void *_p_BasicVector3DT_double_tTo_p_std__arrayT_double_3_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((std::array< double,3 > *) ((BasicVector3D< double > *) x));
+}
static swig_type_info _swigt__p_BasicVector3DT_double_t = {"_p_BasicVector3DT_double_t", "std::vector< BasicVector3D< double > >::value_type *|R3 *|BasicVector3D< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BasicVector3DT_int_t = {"_p_BasicVector3DT_int_t", "I3 *|BasicVector3D< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BasicVector3DT_std__complexT_double_t_t = {"_p_BasicVector3DT_std__complexT_double_t_t", "BasicVector3D< std::complex< double > > *|std::vector< BasicVector3D< std::complex< double > > >::value_type *|C3 *|BasicVector3D< complex_t > *", 0, 0, (void*)0, 0};
@@ -30559,6 +33131,8 @@ static swig_type_info _swigt__p_std__allocatorT_std__string_t = {"_p_std__alloca
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t = {"_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t", "std::vector< std::vector< double > >::allocator_type *|std::allocator< std::vector< double,std::allocator< double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t = {"_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t", "std::vector< std::vector< int > >::allocator_type *|std::allocator< std::vector< int,std::allocator< int > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_unsigned_long_t = {"_p_std__allocatorT_unsigned_long_t", "std::vector< unsigned long >::allocator_type *|std::allocator< unsigned long > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__arrayT_double_3_t = {"_p_std__arrayT_double_3_t", "std::array< double,3 > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__arrayT_std__complexT_double_t_3_t = {"_p_std__arrayT_std__complexT_double_t_3_t", "std::array< std::complex< double >,3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__complexT_double_t = {"_p_std__complexT_double_t", "complex_t *|std::complex< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__lessT_std__string_t = {"_p_std__lessT_std__string_t", "std::less< std::string > *", 0, 0, (void*)0, 0};
@@ -30612,6 +33186,8 @@ static swig_type_info *swig_type_initial[] = {
&_swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t,
&_swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t,
&_swigt__p_std__allocatorT_unsigned_long_t,
+ &_swigt__p_std__arrayT_double_3_t,
+ &_swigt__p_std__arrayT_std__complexT_double_t_3_t,
&_swigt__p_std__complexT_double_t,
&_swigt__p_std__invalid_argument,
&_swigt__p_std__lessT_std__string_t,
@@ -30665,6 +33241,8 @@ static swig_cast_info _swigc__p_std__allocatorT_std__string_t[] = { {&_swigt__p
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t[] = { {&_swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t[] = { {&_swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_unsigned_long_t[] = { {&_swigt__p_std__allocatorT_unsigned_long_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__arrayT_double_3_t[] = { {&_swigt__p_BasicVector3DT_double_t, _p_BasicVector3DT_double_tTo_p_std__arrayT_double_3_t, 0, 0}, {&_swigt__p_std__arrayT_double_3_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__arrayT_std__complexT_double_t_3_t[] = { {&_swigt__p_std__arrayT_std__complexT_double_t_3_t, 0, 0, 0}, {&_swigt__p_BasicVector3DT_std__complexT_double_t_t, _p_BasicVector3DT_std__complexT_double_t_tTo_p_std__arrayT_std__complexT_double_t_3_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__complexT_double_t[] = { {&_swigt__p_std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__lessT_std__string_t[] = { {&_swigt__p_std__lessT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -30718,6 +33296,8 @@ static swig_cast_info *swig_cast_initial[] = {
_swigc__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t,
_swigc__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t,
_swigc__p_std__allocatorT_unsigned_long_t,
+ _swigc__p_std__arrayT_double_3_t,
+ _swigc__p_std__arrayT_std__complexT_double_t_3_t,
_swigc__p_std__complexT_double_t,
_swigc__p_std__invalid_argument,
_swigc__p_std__lessT_std__string_t,
diff --git a/auto/Wrap/libBornAgainSample.py b/auto/Wrap/libBornAgainSample.py
index dc2b958e999..be42534fbc8 100644
--- a/auto/Wrap/libBornAgainSample.py
+++ b/auto/Wrap/libBornAgainSample.py
@@ -157,6 +157,230 @@ def deprecated(message):
return deprecated_func
return deprecated_decorator
+class arrayR3_t(object):
+ r"""Proxy of C++ std::array< double,3 > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(arrayR3_t self) -> SwigPyIterator"""
+ return _libBornAgainSample.arrayR3_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(arrayR3_t self) -> bool"""
+ return _libBornAgainSample.arrayR3_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(arrayR3_t self) -> bool"""
+ return _libBornAgainSample.arrayR3_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(arrayR3_t self) -> std::array< double,3 >::size_type"""
+ return _libBornAgainSample.arrayR3_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j) -> arrayR3_t"""
+ return _libBornAgainSample.arrayR3_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)
+ __setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j, arrayR3_t v)
+ """
+ return _libBornAgainSample.arrayR3_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)"""
+ return _libBornAgainSample.arrayR3_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(arrayR3_t self, std::array< double,3 >::difference_type i)
+ __delitem__(arrayR3_t self, PySliceObject * slice)
+ """
+ return _libBornAgainSample.arrayR3_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(arrayR3_t self, PySliceObject * slice) -> arrayR3_t
+ __getitem__(arrayR3_t self, std::array< double,3 >::difference_type i) -> std::array< double,3 >::value_type const &
+ """
+ return _libBornAgainSample.arrayR3_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(arrayR3_t self, PySliceObject * slice, arrayR3_t v)
+ __setitem__(arrayR3_t self, PySliceObject * slice)
+ __setitem__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::value_type const & x)
+ """
+ return _libBornAgainSample.arrayR3_t___setitem__(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(arrayR3_t self) -> arrayR3_t
+ __init__(arrayR3_t self, arrayR3_t other) -> arrayR3_t
+ """
+ _libBornAgainSample.arrayR3_t_swiginit(self, _libBornAgainSample.new_arrayR3_t(*args))
+
+ def empty(self):
+ r"""empty(arrayR3_t self) -> bool"""
+ return _libBornAgainSample.arrayR3_t_empty(self)
+
+ def size(self):
+ r"""size(arrayR3_t self) -> std::array< double,3 >::size_type"""
+ return _libBornAgainSample.arrayR3_t_size(self)
+
+ def swap(self, v):
+ r"""swap(arrayR3_t self, arrayR3_t v)"""
+ return _libBornAgainSample.arrayR3_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(arrayR3_t self) -> std::array< double,3 >::iterator"""
+ return _libBornAgainSample.arrayR3_t_begin(self)
+
+ def end(self):
+ r"""end(arrayR3_t self) -> std::array< double,3 >::iterator"""
+ return _libBornAgainSample.arrayR3_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"""
+ return _libBornAgainSample.arrayR3_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"""
+ return _libBornAgainSample.arrayR3_t_rend(self)
+
+ def front(self):
+ r"""front(arrayR3_t self) -> std::array< double,3 >::value_type const &"""
+ return _libBornAgainSample.arrayR3_t_front(self)
+
+ def back(self):
+ r"""back(arrayR3_t self) -> std::array< double,3 >::value_type const &"""
+ return _libBornAgainSample.arrayR3_t_back(self)
+
+ def fill(self, u):
+ r"""fill(arrayR3_t self, std::array< double,3 >::value_type const & u)"""
+ return _libBornAgainSample.arrayR3_t_fill(self, u)
+ __swig_destroy__ = _libBornAgainSample.delete_arrayR3_t
+
+# Register arrayR3_t in _libBornAgainSample:
+_libBornAgainSample.arrayR3_t_swigregister(arrayR3_t)
+
+class arrayC3_t(object):
+ r"""Proxy of C++ std::array< std::complex< double >,3 > class."""
+
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ def iterator(self):
+ r"""iterator(arrayC3_t self) -> SwigPyIterator"""
+ return _libBornAgainSample.arrayC3_t_iterator(self)
+ def __iter__(self):
+ return self.iterator()
+
+ def __nonzero__(self):
+ r"""__nonzero__(arrayC3_t self) -> bool"""
+ return _libBornAgainSample.arrayC3_t___nonzero__(self)
+
+ def __bool__(self):
+ r"""__bool__(arrayC3_t self) -> bool"""
+ return _libBornAgainSample.arrayC3_t___bool__(self)
+
+ def __len__(self):
+ r"""__len__(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"""
+ return _libBornAgainSample.arrayC3_t___len__(self)
+
+ def __getslice__(self, i, j):
+ r"""__getslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j) -> arrayC3_t"""
+ return _libBornAgainSample.arrayC3_t___getslice__(self, i, j)
+
+ def __setslice__(self, *args):
+ r"""
+ __setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)
+ __setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j, arrayC3_t v)
+ """
+ return _libBornAgainSample.arrayC3_t___setslice__(self, *args)
+
+ def __delslice__(self, i, j):
+ r"""__delslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)"""
+ return _libBornAgainSample.arrayC3_t___delslice__(self, i, j)
+
+ def __delitem__(self, *args):
+ r"""
+ __delitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i)
+ __delitem__(arrayC3_t self, PySliceObject * slice)
+ """
+ return _libBornAgainSample.arrayC3_t___delitem__(self, *args)
+
+ def __getitem__(self, *args):
+ r"""
+ __getitem__(arrayC3_t self, PySliceObject * slice) -> arrayC3_t
+ __getitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i) -> std::array< std::complex< double >,3 >::value_type const &
+ """
+ return _libBornAgainSample.arrayC3_t___getitem__(self, *args)
+
+ def __setitem__(self, *args):
+ r"""
+ __setitem__(arrayC3_t self, PySliceObject * slice, arrayC3_t v)
+ __setitem__(arrayC3_t self, PySliceObject * slice)
+ __setitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::value_type const & x)
+ """
+ return _libBornAgainSample.arrayC3_t___setitem__(self, *args)
+
+ def __init__(self, *args):
+ r"""
+ __init__(arrayC3_t self) -> arrayC3_t
+ __init__(arrayC3_t self, arrayC3_t other) -> arrayC3_t
+ """
+ _libBornAgainSample.arrayC3_t_swiginit(self, _libBornAgainSample.new_arrayC3_t(*args))
+
+ def empty(self):
+ r"""empty(arrayC3_t self) -> bool"""
+ return _libBornAgainSample.arrayC3_t_empty(self)
+
+ def size(self):
+ r"""size(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"""
+ return _libBornAgainSample.arrayC3_t_size(self)
+
+ def swap(self, v):
+ r"""swap(arrayC3_t self, arrayC3_t v)"""
+ return _libBornAgainSample.arrayC3_t_swap(self, v)
+
+ def begin(self):
+ r"""begin(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"""
+ return _libBornAgainSample.arrayC3_t_begin(self)
+
+ def end(self):
+ r"""end(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"""
+ return _libBornAgainSample.arrayC3_t_end(self)
+
+ def rbegin(self):
+ r"""rbegin(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"""
+ return _libBornAgainSample.arrayC3_t_rbegin(self)
+
+ def rend(self):
+ r"""rend(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"""
+ return _libBornAgainSample.arrayC3_t_rend(self)
+
+ def front(self):
+ r"""front(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"""
+ return _libBornAgainSample.arrayC3_t_front(self)
+
+ def back(self):
+ r"""back(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"""
+ return _libBornAgainSample.arrayC3_t_back(self)
+
+ def fill(self, u):
+ r"""fill(arrayC3_t self, std::array< std::complex< double >,3 >::value_type const & u)"""
+ return _libBornAgainSample.arrayC3_t_fill(self, u)
+ __swig_destroy__ = _libBornAgainSample.delete_arrayC3_t
+
+# Register arrayC3_t in _libBornAgainSample:
+_libBornAgainSample.arrayC3_t_swigregister(arrayC3_t)
+
class vdouble1d_t(object):
r"""Proxy of C++ std::vector< double > class."""
@@ -1679,7 +1903,7 @@ class vector_pvacuum_double_t(object):
_libBornAgainSample.vector_pvacuum_double_t_swigregister(vector_pvacuum_double_t)
import libBornAgainBase
-class R3(object):
+class R3(arrayR3_t):
r"""Proxy of C++ BasicVector3D< double > class."""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
@@ -1688,7 +1912,7 @@ class R3(object):
def __init__(self, *args):
r"""
__init__(R3 self) -> R3
- __init__(R3 self, double const x1, double const y1, double const z1) -> R3
+ __init__(R3 self, double const x, double const y, double const z) -> R3
"""
_libBornAgainSample.R3_swiginit(self, _libBornAgainSample.new_R3(*args))
@@ -1967,7 +2191,7 @@ class vector_R3(object):
# Register vector_R3 in _libBornAgainSample:
_libBornAgainSample.vector_R3_swigregister(vector_R3)
-class C3(object):
+class C3(arrayC3_t):
r"""Proxy of C++ BasicVector3D< std::complex< double > > class."""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
@@ -1976,7 +2200,7 @@ class C3(object):
def __init__(self, *args):
r"""
__init__(C3 self) -> C3
- __init__(C3 self, std::complex< double > const x1, std::complex< double > const y1, std::complex< double > const z1) -> C3
+ __init__(C3 self, std::complex< double > const x, std::complex< double > const y, std::complex< double > const z) -> C3
"""
_libBornAgainSample.C3_swiginit(self, _libBornAgainSample.new_C3(*args))
diff --git a/auto/Wrap/libBornAgainSample_wrap.cpp b/auto/Wrap/libBornAgainSample_wrap.cpp
index d58069ccaec..1c1b723766c 100644
--- a/auto/Wrap/libBornAgainSample_wrap.cpp
+++ b/auto/Wrap/libBornAgainSample_wrap.cpp
@@ -3252,34 +3252,36 @@ namespace Swig {
#define SWIGTYPE_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t swig_types[152]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t swig_types[153]
#define SWIGTYPE_p_std__allocatorT_unsigned_long_t swig_types[154]
-#define SWIGTYPE_p_std__complexT_double_t swig_types[155]
-#define SWIGTYPE_p_std__invalid_argument swig_types[156]
-#define SWIGTYPE_p_std__lessT_std__string_t swig_types[157]
-#define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[158]
-#define SWIGTYPE_p_std__pairT_double_double_t swig_types[159]
-#define SWIGTYPE_p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t swig_types[160]
-#define SWIGTYPE_p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t swig_types[161]
-#define SWIGTYPE_p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t swig_types[162]
-#define SWIGTYPE_p_std__vectorT_INode_const_p_std__allocatorT_INode_const_p_t_t swig_types[163]
-#define SWIGTYPE_p_std__vectorT_INode_p_std__allocatorT_INode_p_t_t swig_types[164]
-#define SWIGTYPE_p_std__vectorT_Material_const_p_std__allocatorT_Material_const_p_t_t swig_types[165]
-#define SWIGTYPE_p_std__vectorT_ParticleLayout_const_p_std__allocatorT_ParticleLayout_const_p_t_t swig_types[166]
-#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[167]
-#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[168]
-#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[169]
-#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[170]
-#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[171]
-#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[172]
-#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[173]
-#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[174]
-#define SWIGTYPE_p_swig__SwigPyIterator swig_types[175]
-#define SWIGTYPE_p_unsigned_char swig_types[176]
-#define SWIGTYPE_p_unsigned_int swig_types[177]
-#define SWIGTYPE_p_unsigned_long_long swig_types[178]
-#define SWIGTYPE_p_unsigned_short swig_types[179]
-#define SWIGTYPE_p_value_type swig_types[180]
-static swig_type_info *swig_types[182];
-static swig_module_info swig_module = {swig_types, 181, 0, 0, 0, 0};
+#define SWIGTYPE_p_std__arrayT_double_3_t swig_types[155]
+#define SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t swig_types[156]
+#define SWIGTYPE_p_std__complexT_double_t swig_types[157]
+#define SWIGTYPE_p_std__invalid_argument swig_types[158]
+#define SWIGTYPE_p_std__lessT_std__string_t swig_types[159]
+#define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[160]
+#define SWIGTYPE_p_std__pairT_double_double_t swig_types[161]
+#define SWIGTYPE_p_std__vectorT_BasicVector3DT_double_t_std__allocatorT_BasicVector3DT_double_t_t_t swig_types[162]
+#define SWIGTYPE_p_std__vectorT_BasicVector3DT_std__complexT_double_t_t_std__allocatorT_BasicVector3DT_std__complexT_double_t_t_t_t swig_types[163]
+#define SWIGTYPE_p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t swig_types[164]
+#define SWIGTYPE_p_std__vectorT_INode_const_p_std__allocatorT_INode_const_p_t_t swig_types[165]
+#define SWIGTYPE_p_std__vectorT_INode_p_std__allocatorT_INode_p_t_t swig_types[166]
+#define SWIGTYPE_p_std__vectorT_Material_const_p_std__allocatorT_Material_const_p_t_t swig_types[167]
+#define SWIGTYPE_p_std__vectorT_ParticleLayout_const_p_std__allocatorT_ParticleLayout_const_p_t_t swig_types[168]
+#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[169]
+#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[170]
+#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[171]
+#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[172]
+#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[173]
+#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[174]
+#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[175]
+#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[176]
+#define SWIGTYPE_p_swig__SwigPyIterator swig_types[177]
+#define SWIGTYPE_p_unsigned_char swig_types[178]
+#define SWIGTYPE_p_unsigned_int swig_types[179]
+#define SWIGTYPE_p_unsigned_long_long swig_types[180]
+#define SWIGTYPE_p_unsigned_short swig_types[181]
+#define SWIGTYPE_p_value_type swig_types[182]
+static swig_type_info *swig_types[184];
+static swig_module_info swig_module = {swig_types, 183, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
@@ -5114,48 +5116,104 @@ namespace swig {
namespace swig {
- template <class T>
- struct traits_reserve<std::vector<T> > {
- static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
- seq.reserve(n);
+ template <class T, size_t N>
+ struct traits_asptr<std::array<T, N> > {
+ static int asptr(PyObject *obj, std::array<T, N> **vec) {
+ return traits_asptr_stdseq<std::array<T, N> >::asptr(obj, vec);
}
};
- template <class T>
- struct traits_asptr<std::vector<T> > {
- static int asptr(PyObject *obj, std::vector<T> **vec) {
- return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+ template <class T, size_t N>
+ struct traits_from<std::array<T, N> > {
+ static PyObject *from(const std::array<T, N>& vec) {
+ return traits_from_stdseq<std::array<T, N> >::from(vec);
}
};
-
- template <class T>
- struct traits_from<std::vector<T> > {
- static PyObject *from(const std::vector<T>& vec) {
- return traits_from_stdseq<std::vector<T> >::from(vec);
+
+ template <class SwigPySeq, class T, size_t N>
+ inline void
+ assign(const SwigPySeq& swigpyseq, std::array<T, N>* seq) {
+ if (swigpyseq.size() < seq->size())
+ throw std::invalid_argument("std::array cannot be expanded in size");
+ else if (swigpyseq.size() > seq->size())
+ throw std::invalid_argument("std::array cannot be reduced in size");
+ std::copy(swigpyseq.begin(), swigpyseq.end(), seq->begin());
+ }
+
+ template <class T, size_t N>
+ inline void
+ erase(std::array<T, N>* SWIGUNUSEDPARM(seq), const typename std::array<T, N>::iterator& SWIGUNUSEDPARM(position)) {
+ throw std::invalid_argument("std::array object does not support item deletion");
+ }
+
+ // Only limited slicing is supported as std::array is fixed in size
+ template <class T, size_t N, class Difference>
+ inline std::array<T, N>*
+ getslice(const std::array<T, N>* self, Difference i, Difference j, Py_ssize_t step) {
+ typedef std::array<T, N> Sequence;
+ typename Sequence::size_type size = self->size();
+ Difference ii = 0;
+ Difference jj = 0;
+ swig::slice_adjust(i, j, step, size, ii, jj);
+
+ if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
+ Sequence *sequence = new Sequence();
+ std::copy(self->begin(), self->end(), sequence->begin());
+ return sequence;
+ } else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
+ Sequence *sequence = new Sequence();
+ std::copy(self->rbegin(), self->rend(), sequence->begin());
+ return sequence;
+ } else {
+ throw std::invalid_argument("std::array object only supports getting a slice that is the size of the array");
}
- };
+ }
+
+ template <class T, size_t N, class Difference, class InputSeq>
+ inline void
+ setslice(std::array<T, N>* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
+ typedef std::array<T, N> Sequence;
+ typename Sequence::size_type size = self->size();
+ Difference ii = 0;
+ Difference jj = 0;
+ swig::slice_adjust(i, j, step, size, ii, jj, true);
+
+ if (step == 1 && ii == 0 && static_cast<typename Sequence::size_type>(jj) == size) {
+ std::copy(is.begin(), is.end(), self->begin());
+ } else if (step == -1 && static_cast<typename Sequence::size_type>(ii) == (size - 1) && jj == -1) {
+ std::copy(is.rbegin(), is.rend(), self->begin());
+ } else {
+ throw std::invalid_argument("std::array object only supports setting a slice that is the size of the array");
+ }
+ }
+
+ template <class T, size_t N, class Difference>
+ inline void
+ delslice(std::array<T, N>* SWIGUNUSEDPARM(self), Difference SWIGUNUSEDPARM(i), Difference SWIGUNUSEDPARM(j), Py_ssize_t SWIGUNUSEDPARM(step)) {
+ throw std::invalid_argument("std::array object does not support item deletion");
+ }
}
namespace swig {
- template <> struct traits<std::vector< double, std::allocator< double > > > {
+ template <> struct traits<std::array< double, 3 > > {
typedef pointer_category category;
static const char* type_name() {
- return "std::vector<" "double" "," "std::allocator< double >" " >";
+ return "std::array<" "double" "," "3" " >";
}
};
}
-SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_array_Sl_double_Sc_3_Sg__iterator(std::array< double,3 > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
+SWIGINTERN bool std_array_Sl_double_Sc_3_Sg____nonzero__(std::array< double,3 > const *self){
return !(self->empty());
}
-SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
+SWIGINTERN bool std_array_Sl_double_Sc_3_Sg____bool__(std::array< double,3 > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
+SWIGINTERN std::array< double,3 >::size_type std_array_Sl_double_Sc_3_Sg____len__(std::array< double,3 > const *self){
return self->size();
}
@@ -5192,66 +5250,66 @@ SWIG_From_size_t (size_t value)
#endif
}
-SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+SWIGINTERN std::array< double,3 > *std_array_Sl_double_Sc_3_Sg____getslice__(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
return swig::getslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
- swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setslice____SWIG_0(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
+ swig::setslice(self, i, j, 1, std::array< double,3 >());
}
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setslice____SWIG_1(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j,std::array< double,3 > const &v){
swig::setslice(self, i, j, 1, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delslice__(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::difference_type j){
swig::delslice(self, i, j, 1);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delitem____SWIG_0(std::array< double,3 > *self,std::array< double,3 >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN std::array< double,3 > *std_array_Sl_double_Sc_3_Sg____getitem____SWIG_0(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_0(std::array< double,3 > *self,PySliceObject *slice,std::array< double,3 > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_1(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____delitem____SWIG_1(std::array< double,3 > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
- std::vector< double,std::allocator< double > >::difference_type id = i;
- std::vector< double,std::allocator< double > >::difference_type jd = j;
+ std::array< double,3 >::difference_type id = i;
+ std::array< double,3 >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
+SWIGINTERN std::array< double,3 >::value_type const &std_array_Sl_double_Sc_3_Sg____getitem____SWIG_1(std::array< double,3 > const *self,std::array< double,3 >::difference_type i){
return *(swig::cgetpos(self, i));
}
@@ -5289,6 +5347,255 @@ namespace swig {
};
}
+SWIGINTERN void std_array_Sl_double_Sc_3_Sg____setitem____SWIG_2(std::array< double,3 > *self,std::array< double,3 >::difference_type i,std::array< double,3 >::value_type const &x){
+ *(swig::getpos(self,i)) = x;
+ }
+
+SWIGINTERN int
+SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
+{
+ if (PyComplex_Check(o)) {
+ if (val) *val = std::complex<double>(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
+ return SWIG_OK;
+ } else {
+ double d;
+ int res = SWIG_AddCast(SWIG_AsVal_double (o, &d));
+ if (SWIG_IsOK(res)) {
+ if (val) *val = std::complex<double>(d, 0.0);
+ return res;
+ }
+ }
+ return SWIG_TypeError;
+}
+
+
+SWIGINTERNINLINE PyObject*
+SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/local/share/swig/4.0.2/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+
+const std::complex<double>&
+
+
+
+/*@SWIG@*/ c)
+{
+ return PyComplex_FromDoubles(std::real(c), std::imag(c));
+}
+
+
+namespace swig {
+ template <> struct traits< std::complex<double> > {
+ typedef value_category category;
+ static const char* type_name() { return"std::complex<double>"; }
+ };
+ template <> struct traits_asval< std::complex<double> > {
+ typedef std::complex<double> value_type;
+ static int asval(PyObject *obj, value_type *val) {
+ return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
+ }
+ };
+ template <> struct traits_from< std::complex<double> > {
+ typedef std::complex<double> value_type;
+ static PyObject *from(const value_type& val) {
+ return SWIG_From_std_complex_Sl_double_Sg_ (val);
+ }
+ };
+}
+
+
+ namespace swig {
+ template <> struct traits<std::array< std::complex< double >, 3 > > {
+ typedef pointer_category category;
+ static const char* type_name() {
+ return "std::array<" "std::complex< double >" "," "3" " >";
+ }
+ };
+ }
+
+SWIGINTERN swig::SwigPyIterator *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg__iterator(std::array< std::complex< double >,3 > *self,PyObject **PYTHON_SELF){
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+ }
+SWIGINTERN bool std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____nonzero__(std::array< std::complex< double >,3 > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____bool__(std::array< std::complex< double >,3 > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN std::array< std::complex< double >,3 >::size_type std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____len__(std::array< std::complex< double >,3 > const *self){
+ return self->size();
+ }
+SWIGINTERN std::array< std::complex< double >,3 > *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getslice__(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
+ return swig::getslice(self, i, j, 1);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_0(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
+ swig::setslice(self, i, j, 1, std::array< std::complex< double >,3 >());
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_1(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j,std::array< std::complex< double >,3 > const &v){
+ swig::setslice(self, i, j, 1, v);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delslice__(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::difference_type j){
+ swig::delslice(self, i, j, 1);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_0(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i){
+ swig::erase(self, swig::getpos(self, i));
+ }
+SWIGINTERN std::array< std::complex< double >,3 > *std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_0(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
+ return swig::getslice(self, id, jd, step);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_0(std::array< std::complex< double >,3 > *self,PySliceObject *slice,std::array< std::complex< double >,3 > const &v){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
+ swig::setslice(self, id, jd, step, v);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_1(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_1(std::array< std::complex< double >,3 > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::array< std::complex< double >,3 >::difference_type id = i;
+ std::array< std::complex< double >,3 >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN std::array< std::complex< double >,3 >::value_type const &std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_1(std::array< std::complex< double >,3 > const *self,std::array< std::complex< double >,3 >::difference_type i){
+ return *(swig::cgetpos(self, i));
+ }
+SWIGINTERN void std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_2(std::array< std::complex< double >,3 > *self,std::array< std::complex< double >,3 >::difference_type i,std::array< std::complex< double >,3 >::value_type const &x){
+ *(swig::getpos(self,i)) = x;
+ }
+
+ namespace swig {
+ template <class T>
+ struct traits_reserve<std::vector<T> > {
+ static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
+ seq.reserve(n);
+ }
+ };
+
+ template <class T>
+ struct traits_asptr<std::vector<T> > {
+ static int asptr(PyObject *obj, std::vector<T> **vec) {
+ return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+ }
+ };
+
+ template <class T>
+ struct traits_from<std::vector<T> > {
+ static PyObject *from(const std::vector<T>& vec) {
+ return traits_from_stdseq<std::vector<T> >::from(vec);
+ }
+ };
+ }
+
+
+ namespace swig {
+ template <> struct traits<std::vector< double, std::allocator< double > > > {
+ typedef pointer_category category;
+ static const char* type_name() {
+ return "std::vector<" "double" "," "std::allocator< double >" " >";
+ }
+ };
+ }
+
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
+ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+ }
+SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
+ return self->size();
+ }
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+ return swig::getslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+ swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
+ swig::setslice(self, i, j, 1, v);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
+ swig::delslice(self, i, j, 1);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
+ swig::erase(self, swig::getpos(self, i));
+ }
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ return swig::getslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::setslice(self, id, jd, step, v);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ std::vector< double,std::allocator< double > >::difference_type id = i;
+ std::vector< double,std::allocator< double > >::difference_type jd = j;
+ swig::delslice(self, id, jd, step);
+ }
+SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
+ return *(swig::cgetpos(self, i));
+ }
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
@@ -5767,57 +6074,6 @@ SWIGINTERN std::vector< unsigned long >::iterator std_vector_Sl_unsigned_SS_long
SWIGINTERN std::vector< unsigned long >::iterator std_vector_Sl_unsigned_SS_long_Sg__insert__SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::iterator pos,std::vector< unsigned long >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg__insert__SWIG_1(std::vector< unsigned long > *self,std::vector< unsigned long >::iterator pos,std::vector< unsigned long >::size_type n,std::vector< unsigned long >::value_type const &x){ self->insert(pos, n, x); }
-SWIGINTERN int
-SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
-{
- if (PyComplex_Check(o)) {
- if (val) *val = std::complex<double>(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
- return SWIG_OK;
- } else {
- double d;
- int res = SWIG_AddCast(SWIG_AsVal_double (o, &d));
- if (SWIG_IsOK(res)) {
- if (val) *val = std::complex<double>(d, 0.0);
- return res;
- }
- }
- return SWIG_TypeError;
-}
-
-
-SWIGINTERNINLINE PyObject*
-SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/local/share/swig/4.0.2/typemaps/swigmacros.swg,104,%ifcplusplus@*/
-
-const std::complex<double>&
-
-
-
-/*@SWIG@*/ c)
-{
- return PyComplex_FromDoubles(std::real(c), std::imag(c));
-}
-
-
-namespace swig {
- template <> struct traits< std::complex<double> > {
- typedef value_category category;
- static const char* type_name() { return"std::complex<double>"; }
- };
- template <> struct traits_asval< std::complex<double> > {
- typedef std::complex<double> value_type;
- static int asval(PyObject *obj, value_type *val) {
- return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
- }
- };
- template <> struct traits_from< std::complex<double> > {
- typedef std::complex<double> value_type;
- static PyObject *from(const value_type& val) {
- return SWIG_From_std_complex_Sl_double_Sg_ (val);
- }
- };
-}
-
-
namespace swig {
template <> struct traits<std::vector< std::complex< double >, std::allocator< std::complex< double > > > > {
typedef pointer_category category;
@@ -8867,592 +9123,2822 @@ SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(
SWIG_fail;
}
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_decr", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 1) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv);
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_size_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " swig::SwigPyIterator::decr(size_t)\n"
+ " swig::SwigPyIterator::decr()\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ ptrdiff_t result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ try {
+ result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
+ } catch(std::invalid_argument &_e) {
+ SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
+ }
+ resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ bool result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ try {
+ result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
+ } catch(std::invalid_argument &_e) {
+ SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
+ }
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ PyObject *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ try {
+ result = (PyObject *)(arg1)->next();
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = result;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ PyObject *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ try {
+ result = (PyObject *)(arg1)->__next__();
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = result;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ PyObject *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ try {
+ result = (PyObject *)(arg1)->previous();
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = result;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ bool result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ bool result;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ ptrdiff_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ }
+ arg2 = static_cast< ptrdiff_t >(val2);
+ try {
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
+ } catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ ptrdiff_t result;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ }
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
+ resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ return resultobj;
+fail:
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PyObject **arg2 = (PyObject **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ arg2 = &swig_obj[0];
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_iterator" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (swig::SwigPyIterator *)std_array_Sl_double_Sc_3_Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___nonzero__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)std_array_Sl_double_Sc_3_Sg____nonzero__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___bool__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)std_array_Sl_double_Sc_3_Sg____bool__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___len__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = std_array_Sl_double_Sc_3_Sg____len__((std::array< double,3 > const *)arg1);
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ std::array< double,3 > *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t___getslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___getslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___getslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ result = (std::array< double,3 > *)std_array_Sl_double_Sc_3_Sg____getslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_double_Sc_3_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ std::array< double,3 > *arg4 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ int res4 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res4 = swig::asptr(swig_obj[3], &ptr);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "arrayR3_t___setslice__" "', argument " "4"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t___setslice__" "', argument " "4"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg4 = ptr;
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::array< double,3 > const &)*arg4);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setslice__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[5] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___setslice__", 0, 4, argv))) SWIG_fail;
+ --argc;
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setslice____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[3], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayR3_t___setslice____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___setslice__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__setslice__(std::array< double,3 >::difference_type,std::array< double,3 >::difference_type)\n"
+ " std::array< double,3 >::__setslice__(std::array< double,3 >::difference_type,std::array< double,3 >::difference_type,std::array< double,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t___delslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delslice__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___delslice__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___delslice__" "', argument " "3"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< double,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_double_Sc_3_Sg____delslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___delitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ try {
+ std_array_Sl_double_Sc_3_Sg____delitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ result = (std::array< double,3 > *)std_array_Sl_double_Sc_3_Sg____getitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::array< double,3 > *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res3 = swig::asptr(swig_obj[2], &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg3 = ptr;
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_0(arg1,arg2,(std::array< double,3 > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___delitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayR3_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_double_Sc_3_Sg____delitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___delitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___delitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___delitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___delitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__delitem__(std::array< double,3 >::difference_type)\n"
+ " std::array< double,3 >::__delitem__(PySliceObject *)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___getitem__" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___getitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ try {
+ result = (std::array< double,3 >::value_type *) &std_array_Sl_double_Sc_3_Sg____getitem____SWIG_1((std::array< double,3 > const *)arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___getitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___getitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___getitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___getitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__getitem__(PySliceObject *)\n"
+ " std::array< double,3 >::__getitem__(std::array< double,3 >::difference_type) const\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::difference_type arg2 ;
+ std::array< double,3 >::value_type *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< double,3 >::value_type temp3 ;
+ double val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t___setitem__" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t___setitem__" "', argument " "2"" of type '" "std::array< double,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< double,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayR3_t___setitem__" "', argument " "3"" of type '" "std::array< double,3 >::value_type""'");
+ }
+ temp3 = static_cast< std::array< double,3 >::value_type >(val3);
+ arg3 = &temp3;
+ try {
+ std_array_Sl_double_Sc_3_Sg____setitem____SWIG_2(arg1,arg2,(double const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t___setitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[4] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayR3_t___setitem__", 0, 3, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayR3_t___setitem____SWIG_2(self, argc, argv);
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayR3_t___setitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::__setitem__(PySliceObject *,std::array< double,3 > const &)\n"
+ " std::array< double,3 >::__setitem__(PySliceObject *)\n"
+ " std::array< double,3 >::__setitem__(std::array< double,3 >::difference_type,std::array< double,3 >::value_type const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
+ result = (std::array< double,3 > *)new std::array< double,3 >();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_NEW | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = 0 ;
+ int res1 = SWIG_OLDOBJ ;
+ std::array< double,3 > *result = 0 ;
+
+ if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+ {
+ std::array< double,3 > *ptr = (std::array< double,3 > *)0;
+ res1 = swig::asptr(swig_obj[0], &ptr);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > const &""'");
+ }
+ arg1 = ptr;
+ }
+ result = (std::array< double,3 > *)new std::array< double,3 >((std::array< double,3 > const &)*arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_NEW | 0 );
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_arrayR3_t(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[2] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "new_arrayR3_t", 0, 1, argv))) SWIG_fail;
+ --argc;
+ if (argc == 0) {
+ return _wrap_new_arrayR3_t__SWIG_0(self, argc, argv);
+ }
+ if (argc == 1) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< double,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_arrayR3_t__SWIG_1(self, argc, argv);
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_arrayR3_t'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< double,3 >::array()\n"
+ " std::array< double,3 >::array(std::array< double,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_empty" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (bool)((std::array< double,3 > const *)arg1)->empty();
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_size" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = ((std::array< double,3 > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 > *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t_swap", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_swap" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__arrayT_double_3_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "arrayR3_t_swap" "', argument " "2"" of type '" "std::array< double,3 > &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayR3_t_swap" "', argument " "2"" of type '" "std::array< double,3 > &""'");
+ }
+ arg2 = reinterpret_cast< std::array< double,3 > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_begin" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_end" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::reverse_iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_rbegin" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::reverse_iterator result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_rend" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< double,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_front" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (std::array< double,3 >::value_type *) &((std::array< double,3 > const *)arg1)->front();
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< double,3 >::value_type *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_back" "', argument " "1"" of type '" "std::array< double,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ result = (std::array< double,3 >::value_type *) &((std::array< double,3 > const *)arg1)->back();
+ resultobj = SWIG_From_double(static_cast< double >(*result));
+ (void)swig::container_owner<swig::traits<std::array< double,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayR3_t_fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ std::array< double,3 >::value_type *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< double,3 >::value_type temp2 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayR3_t_fill", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayR3_t_fill" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayR3_t_fill" "', argument " "2"" of type '" "std::array< double,3 >::value_type""'");
+ }
+ temp2 = static_cast< std::array< double,3 >::value_type >(val2);
+ arg2 = &temp2;
+ (arg1)->fill((std::array< double,3 >::value_type const &)*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_arrayR3_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< double,3 > *arg1 = (std::array< double,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_double_3_t, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_arrayR3_t" "', argument " "1"" of type '" "std::array< double,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< double,3 > * >(argp1);
+ delete arg1;
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *arrayR3_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__arrayT_double_3_t, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *arrayR3_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
+SWIGINTERN PyObject *_wrap_arrayC3_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PyObject **arg2 = (PyObject **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ swig::SwigPyIterator *result = 0 ;
+
+ arg2 = &swig_obj[0];
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_iterator" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (swig::SwigPyIterator *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___nonzero__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____nonzero__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ bool result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___bool__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____bool__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::size_type result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___len__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____len__((std::array< std::complex< double >,3 > const *)arg1);
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t___getslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___getslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___getslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ result = (std::array< std::complex< double >,3 > *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ std::array< std::complex< double >,3 > *arg4 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ int res4 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res4 = swig::asptr(swig_obj[3], &ptr);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "arrayC3_t___setslice__" "', argument " "4"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t___setslice__" "', argument " "4"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg4 = ptr;
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::array< std::complex< double >,3 > const &)*arg4);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setslice__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[5] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___setslice__", 0, 4, argv))) SWIG_fail;
+ --argc;
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setslice____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[3], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayC3_t___setslice____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___setslice__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__setslice__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::difference_type)\n"
+ " std::array< std::complex< double >,3 >::__setslice__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 > const &)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t___delslice__", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delslice__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___delslice__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___delslice__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg3 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val3);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delslice__(arg1,arg2,arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___delitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ std::array< std::complex< double >,3 > *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ result = (std::array< std::complex< double >,3 > *)std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_0(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::array< std::complex< double >,3 > *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res3 = swig::asptr(swig_obj[2], &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg3 = ptr;
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_0(arg1,arg2,(std::array< std::complex< double >,3 > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___delitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ {
+ if (!PySlice_Check(swig_obj[1])) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "arrayC3_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ }
+ arg2 = (PySliceObject *) swig_obj[1];
+ }
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____delitem____SWIG_1(arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ } catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___delitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___delitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___delitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___delitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__delitem__(std::array< std::complex< double >,3 >::difference_type)\n"
+ " std::array< std::complex< double >,3 >::__delitem__(PySliceObject *)\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
+
+ if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___getitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___getitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ try {
+ result = (std::array< std::complex< double >,3 >::value_type *) &std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____getitem____SWIG_1((std::array< std::complex< double >,3 > const *)arg1,arg2);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___getitem__(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[3] = {
+ 0
+ };
+
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___getitem__", 0, 2, argv))) SWIG_fail;
+ --argc;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___getitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___getitem____SWIG_1(self, argc, argv);
+ }
+ }
+ }
+
+fail:
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::__getitem__(PySliceObject *)\n"
+ " std::array< std::complex< double >,3 >::__getitem__(std::array< std::complex< double >,3 >::difference_type) const\n");
+ return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+ PyObject *resultobj = 0;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::difference_type arg2 ;
+ std::array< std::complex< double >,3 >::value_type *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ std::array< std::complex< double >,3 >::value_type temp3 ;
+ std::complex< double > val3 ;
+ int ecode3 = 0 ;
+
+ if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t___setitem__" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
+ }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t___setitem__" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::difference_type""'");
+ }
+ arg2 = static_cast< std::array< std::complex< double >,3 >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_std_complex_Sl_double_Sg_(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "arrayC3_t___setitem__" "', argument " "3"" of type '" "std::array< std::complex< double >,3 >::value_type""'");
+ }
+ temp3 = static_cast< std::array< std::complex< double >,3 >::value_type >(val3);
+ arg3 = &temp3;
+ try {
+ std_array_Sl_std_complex_Sl_double_Sg__Sc_3_Sg____setitem____SWIG_2(arg1,arg2,(std::complex< double > const &)*arg3);
+ } catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t___setitem__(PyObject *self, PyObject *args) {
Py_ssize_t argc;
- PyObject *argv[3] = {
+ PyObject *argv[4] = {
0
};
- if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_decr", 0, 2, argv))) SWIG_fail;
+ if (!(argc = SWIG_Python_UnpackTuple(args, "arrayC3_t___setitem__", 0, 3, argv))) SWIG_fail;
--argc;
- if (argc == 1) {
+ if (argc == 2) {
int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- return _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv);
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_1(self, argc, argv);
+ }
}
}
- if (argc == 2) {
+ if (argc == 3) {
int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
- int res = SWIG_AsVal_size_t(argv[1], NULL);
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_0(self, argc, argv);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
- return _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv);
+ {
+ int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_arrayC3_t___setitem____SWIG_2(self, argc, argv);
+ }
}
}
}
fail:
- SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'arrayC3_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " swig::SwigPyIterator::decr(size_t)\n"
- " swig::SwigPyIterator::decr()\n");
+ " std::array< std::complex< double >,3 >::__setitem__(PySliceObject *,std::array< std::complex< double >,3 > const &)\n"
+ " std::array< std::complex< double >,3 >::__setitem__(PySliceObject *)\n"
+ " std::array< std::complex< double >,3 >::__setitem__(std::array< std::complex< double >,3 >::difference_type,std::array< std::complex< double >,3 >::value_type const &)\n");
return 0;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_arrayC3_t__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- ptrdiff_t result;
+ std::array< std::complex< double >,3 > *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- try {
- result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
- } catch(std::invalid_argument &_e) {
- SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
- }
- resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
+ result = (std::array< std::complex< double >,3 > *)new std::array< std::complex< double >,3 >();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_arrayC3_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- bool result;
+ std::array< std::complex< double >,3 > *arg1 = 0 ;
+ int res1 = SWIG_OLDOBJ ;
+ std::array< std::complex< double >,3 > *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- try {
- result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
- } catch(std::invalid_argument &_e) {
- SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
+ if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+ {
+ std::array< std::complex< double >,3 > *ptr = (std::array< std::complex< double >,3 > *)0;
+ res1 = swig::asptr(swig_obj[0], &ptr);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const &""'");
+ }
+ arg1 = ptr;
}
- resultobj = SWIG_From_bool(static_cast< bool >(result));
+ result = (std::array< std::complex< double >,3 > *)new std::array< std::complex< double >,3 >((std::array< std::complex< double >,3 > const &)*arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_NEW | 0 );
+ if (SWIG_IsNewObj(res1)) delete arg1;
return resultobj;
fail:
+ if (SWIG_IsNewObj(res1)) delete arg1;
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject *swig_obj[1] ;
- swig::SwigPyIterator *result = 0 ;
+SWIGINTERN PyObject *_wrap_new_arrayC3_t(PyObject *self, PyObject *args) {
+ Py_ssize_t argc;
+ PyObject *argv[2] = {
+ 0
+ };
- if (!args) SWIG_fail;
- swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ if (!(argc = SWIG_Python_UnpackTuple(args, "new_arrayC3_t", 0, 1, argv))) SWIG_fail;
+ --argc;
+ if (argc == 0) {
+ return _wrap_new_arrayC3_t__SWIG_0(self, argc, argv);
}
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
- return resultobj;
+ if (argc == 1) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::array< std::complex< double >,3 >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_arrayC3_t__SWIG_1(self, argc, argv);
+ }
+ }
+
fail:
- return NULL;
+ SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_arrayC3_t'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::array< std::complex< double >,3 >::array()\n"
+ " std::array< std::complex< double >,3 >::array(std::array< std::complex< double >,3 > const &)\n");
+ return 0;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
- PyObject *result = 0 ;
+ bool result;
if (!args) SWIG_fail;
swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- try {
- result = (PyObject *)(arg1)->next();
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_empty" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = result;
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (bool)((std::array< std::complex< double >,3 > const *)arg1)->empty();
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
- PyObject *result = 0 ;
+ std::array< std::complex< double >,3 >::size_type result;
if (!args) SWIG_fail;
swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- try {
- result = (PyObject *)(arg1)->__next__();
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_size" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = result;
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = ((std::array< std::complex< double >,3 > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- PyObject *swig_obj[1] ;
- PyObject *result = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!args) SWIG_fail;
- swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t_swap", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_swap" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- try {
- result = (PyObject *)(arg1)->previous();
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "arrayC3_t_swap" "', argument " "2"" of type '" "std::array< std::complex< double >,3 > &""'");
}
- resultobj = result;
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayC3_t_swap" "', argument " "2"" of type '" "std::array< std::complex< double >,3 > &""'");
+ }
+ arg2 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_begin" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- bool result;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_end" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_bool(static_cast< bool >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject *swig_obj[2] ;
- bool result;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::reverse_iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_rbegin" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_bool(static_cast< bool >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::reverse_iterator result;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_rend" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
- }
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::array< std::complex< double >,3 >::reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_front" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (std::array< std::complex< double >,3 >::value_type *) &((std::array< std::complex< double >,3 > const *)arg1)->front();
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject *swig_obj[2] ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[1] ;
+ std::array< std::complex< double >,3 >::value_type *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
- }
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_back" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > const *""'");
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ result = (std::array< std::complex< double >,3 >::value_type *) &((std::array< std::complex< double >,3 > const *)arg1)->back();
+ resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
+ (void)swig::container_owner<swig::traits<std::array< std::complex< double >,3 >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_arrayC3_t_fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- ptrdiff_t arg2 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
+ std::array< std::complex< double >,3 >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
+ std::array< std::complex< double >,3 >::value_type temp2 ;
+ std::complex< double > val2 ;
int ecode2 = 0 ;
- swig::SwigPyIterator *result = 0 ;
+ PyObject *swig_obj[2] ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_Python_UnpackTuple(args, "arrayC3_t_fill", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayC3_t_fill" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayC3_t_fill" "', argument " "2"" of type '" "std::array< std::complex< double >,3 >::value_type""'");
}
- arg2 = static_cast< ptrdiff_t >(val2);
- try {
- result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
- } catch(swig::stop_iteration &_e) {
- {
- (void)_e;
- SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
- SWIG_fail;
- }
- }
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
+ temp2 = static_cast< std::array< std::complex< double >,3 >::value_type >(val2);
+ arg2 = &temp2;
+ (arg1)->fill((std::array< std::complex< double >,3 >::value_type const &)*arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_delete_arrayC3_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
- swig::SwigPyIterator *arg2 = 0 ;
+ std::array< std::complex< double >,3 > *arg1 = (std::array< std::complex< double >,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- ptrdiff_t result;
+ PyObject *swig_obj[1] ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
- }
- arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_arrayC3_t" "', argument " "1"" of type '" "std::array< std::complex< double >,3 > *""'");
}
- arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
- result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
- resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+ arg1 = reinterpret_cast< std::array< std::complex< double >,3 > * >(argp1);
+ delete arg1;
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
-}
-
-
-SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
- Py_ssize_t argc;
- PyObject *argv[3] = {
- 0
- };
-
- if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
- --argc;
- if (argc == 2) {
- int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
- }
- }
- }
- if (argc == 2) {
- int _v;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- {
- int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
- _v = SWIG_CheckState(res);
- }
- if (_v) {
- return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
- }
- }
- }
-
-fail:
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ return NULL;
}
-SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *arrayC3_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__arrayT_std__complexT_double_t_3_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
+SWIGINTERN PyObject *arrayC3_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
SWIGINTERN PyObject *_wrap_vdouble1d_t_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
@@ -68310,6 +70796,86 @@ static PyMethodDef SwigMethods[] = {
"SwigPyIterator___sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t\n"
""},
{ "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
+ { "arrayR3_t_iterator", _wrap_arrayR3_t_iterator, METH_O, "arrayR3_t_iterator(arrayR3_t self) -> SwigPyIterator"},
+ { "arrayR3_t___nonzero__", _wrap_arrayR3_t___nonzero__, METH_O, "arrayR3_t___nonzero__(arrayR3_t self) -> bool"},
+ { "arrayR3_t___bool__", _wrap_arrayR3_t___bool__, METH_O, "arrayR3_t___bool__(arrayR3_t self) -> bool"},
+ { "arrayR3_t___len__", _wrap_arrayR3_t___len__, METH_O, "arrayR3_t___len__(arrayR3_t self) -> std::array< double,3 >::size_type"},
+ { "arrayR3_t___getslice__", _wrap_arrayR3_t___getslice__, METH_VARARGS, "arrayR3_t___getslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j) -> arrayR3_t"},
+ { "arrayR3_t___setslice__", _wrap_arrayR3_t___setslice__, METH_VARARGS, "\n"
+ "arrayR3_t___setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)\n"
+ "arrayR3_t___setslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j, arrayR3_t v)\n"
+ ""},
+ { "arrayR3_t___delslice__", _wrap_arrayR3_t___delslice__, METH_VARARGS, "arrayR3_t___delslice__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::difference_type j)"},
+ { "arrayR3_t___delitem__", _wrap_arrayR3_t___delitem__, METH_VARARGS, "\n"
+ "arrayR3_t___delitem__(arrayR3_t self, std::array< double,3 >::difference_type i)\n"
+ "arrayR3_t___delitem__(arrayR3_t self, PySliceObject * slice)\n"
+ ""},
+ { "arrayR3_t___getitem__", _wrap_arrayR3_t___getitem__, METH_VARARGS, "\n"
+ "arrayR3_t___getitem__(arrayR3_t self, PySliceObject * slice) -> arrayR3_t\n"
+ "arrayR3_t___getitem__(arrayR3_t self, std::array< double,3 >::difference_type i) -> std::array< double,3 >::value_type const &\n"
+ ""},
+ { "arrayR3_t___setitem__", _wrap_arrayR3_t___setitem__, METH_VARARGS, "\n"
+ "arrayR3_t___setitem__(arrayR3_t self, PySliceObject * slice, arrayR3_t v)\n"
+ "arrayR3_t___setitem__(arrayR3_t self, PySliceObject * slice)\n"
+ "arrayR3_t___setitem__(arrayR3_t self, std::array< double,3 >::difference_type i, std::array< double,3 >::value_type const & x)\n"
+ ""},
+ { "new_arrayR3_t", _wrap_new_arrayR3_t, METH_VARARGS, "\n"
+ "arrayR3_t()\n"
+ "new_arrayR3_t(arrayR3_t other) -> arrayR3_t\n"
+ ""},
+ { "arrayR3_t_empty", _wrap_arrayR3_t_empty, METH_O, "arrayR3_t_empty(arrayR3_t self) -> bool"},
+ { "arrayR3_t_size", _wrap_arrayR3_t_size, METH_O, "arrayR3_t_size(arrayR3_t self) -> std::array< double,3 >::size_type"},
+ { "arrayR3_t_swap", _wrap_arrayR3_t_swap, METH_VARARGS, "arrayR3_t_swap(arrayR3_t self, arrayR3_t v)"},
+ { "arrayR3_t_begin", _wrap_arrayR3_t_begin, METH_O, "arrayR3_t_begin(arrayR3_t self) -> std::array< double,3 >::iterator"},
+ { "arrayR3_t_end", _wrap_arrayR3_t_end, METH_O, "arrayR3_t_end(arrayR3_t self) -> std::array< double,3 >::iterator"},
+ { "arrayR3_t_rbegin", _wrap_arrayR3_t_rbegin, METH_O, "arrayR3_t_rbegin(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"},
+ { "arrayR3_t_rend", _wrap_arrayR3_t_rend, METH_O, "arrayR3_t_rend(arrayR3_t self) -> std::array< double,3 >::reverse_iterator"},
+ { "arrayR3_t_front", _wrap_arrayR3_t_front, METH_O, "arrayR3_t_front(arrayR3_t self) -> std::array< double,3 >::value_type const &"},
+ { "arrayR3_t_back", _wrap_arrayR3_t_back, METH_O, "arrayR3_t_back(arrayR3_t self) -> std::array< double,3 >::value_type const &"},
+ { "arrayR3_t_fill", _wrap_arrayR3_t_fill, METH_VARARGS, "arrayR3_t_fill(arrayR3_t self, std::array< double,3 >::value_type const & u)"},
+ { "delete_arrayR3_t", _wrap_delete_arrayR3_t, METH_O, "delete_arrayR3_t(arrayR3_t self)"},
+ { "arrayR3_t_swigregister", arrayR3_t_swigregister, METH_O, NULL},
+ { "arrayR3_t_swiginit", arrayR3_t_swiginit, METH_VARARGS, NULL},
+ { "arrayC3_t_iterator", _wrap_arrayC3_t_iterator, METH_O, "arrayC3_t_iterator(arrayC3_t self) -> SwigPyIterator"},
+ { "arrayC3_t___nonzero__", _wrap_arrayC3_t___nonzero__, METH_O, "arrayC3_t___nonzero__(arrayC3_t self) -> bool"},
+ { "arrayC3_t___bool__", _wrap_arrayC3_t___bool__, METH_O, "arrayC3_t___bool__(arrayC3_t self) -> bool"},
+ { "arrayC3_t___len__", _wrap_arrayC3_t___len__, METH_O, "arrayC3_t___len__(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"},
+ { "arrayC3_t___getslice__", _wrap_arrayC3_t___getslice__, METH_VARARGS, "arrayC3_t___getslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j) -> arrayC3_t"},
+ { "arrayC3_t___setslice__", _wrap_arrayC3_t___setslice__, METH_VARARGS, "\n"
+ "arrayC3_t___setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)\n"
+ "arrayC3_t___setslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j, arrayC3_t v)\n"
+ ""},
+ { "arrayC3_t___delslice__", _wrap_arrayC3_t___delslice__, METH_VARARGS, "arrayC3_t___delslice__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::difference_type j)"},
+ { "arrayC3_t___delitem__", _wrap_arrayC3_t___delitem__, METH_VARARGS, "\n"
+ "arrayC3_t___delitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i)\n"
+ "arrayC3_t___delitem__(arrayC3_t self, PySliceObject * slice)\n"
+ ""},
+ { "arrayC3_t___getitem__", _wrap_arrayC3_t___getitem__, METH_VARARGS, "\n"
+ "arrayC3_t___getitem__(arrayC3_t self, PySliceObject * slice) -> arrayC3_t\n"
+ "arrayC3_t___getitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i) -> std::array< std::complex< double >,3 >::value_type const &\n"
+ ""},
+ { "arrayC3_t___setitem__", _wrap_arrayC3_t___setitem__, METH_VARARGS, "\n"
+ "arrayC3_t___setitem__(arrayC3_t self, PySliceObject * slice, arrayC3_t v)\n"
+ "arrayC3_t___setitem__(arrayC3_t self, PySliceObject * slice)\n"
+ "arrayC3_t___setitem__(arrayC3_t self, std::array< std::complex< double >,3 >::difference_type i, std::array< std::complex< double >,3 >::value_type const & x)\n"
+ ""},
+ { "new_arrayC3_t", _wrap_new_arrayC3_t, METH_VARARGS, "\n"
+ "arrayC3_t()\n"
+ "new_arrayC3_t(arrayC3_t other) -> arrayC3_t\n"
+ ""},
+ { "arrayC3_t_empty", _wrap_arrayC3_t_empty, METH_O, "arrayC3_t_empty(arrayC3_t self) -> bool"},
+ { "arrayC3_t_size", _wrap_arrayC3_t_size, METH_O, "arrayC3_t_size(arrayC3_t self) -> std::array< std::complex< double >,3 >::size_type"},
+ { "arrayC3_t_swap", _wrap_arrayC3_t_swap, METH_VARARGS, "arrayC3_t_swap(arrayC3_t self, arrayC3_t v)"},
+ { "arrayC3_t_begin", _wrap_arrayC3_t_begin, METH_O, "arrayC3_t_begin(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"},
+ { "arrayC3_t_end", _wrap_arrayC3_t_end, METH_O, "arrayC3_t_end(arrayC3_t self) -> std::array< std::complex< double >,3 >::iterator"},
+ { "arrayC3_t_rbegin", _wrap_arrayC3_t_rbegin, METH_O, "arrayC3_t_rbegin(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"},
+ { "arrayC3_t_rend", _wrap_arrayC3_t_rend, METH_O, "arrayC3_t_rend(arrayC3_t self) -> std::array< std::complex< double >,3 >::reverse_iterator"},
+ { "arrayC3_t_front", _wrap_arrayC3_t_front, METH_O, "arrayC3_t_front(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"},
+ { "arrayC3_t_back", _wrap_arrayC3_t_back, METH_O, "arrayC3_t_back(arrayC3_t self) -> std::array< std::complex< double >,3 >::value_type const &"},
+ { "arrayC3_t_fill", _wrap_arrayC3_t_fill, METH_VARARGS, "arrayC3_t_fill(arrayC3_t self, std::array< std::complex< double >,3 >::value_type const & u)"},
+ { "delete_arrayC3_t", _wrap_delete_arrayC3_t, METH_O, "delete_arrayC3_t(arrayC3_t self)"},
+ { "arrayC3_t_swigregister", arrayC3_t_swigregister, METH_O, NULL},
+ { "arrayC3_t_swiginit", arrayC3_t_swiginit, METH_VARARGS, NULL},
{ "vdouble1d_t_iterator", _wrap_vdouble1d_t_iterator, METH_O, "vdouble1d_t_iterator(vdouble1d_t self) -> SwigPyIterator"},
{ "vdouble1d_t___nonzero__", _wrap_vdouble1d_t___nonzero__, METH_O, "vdouble1d_t___nonzero__(vdouble1d_t self) -> bool"},
{ "vdouble1d_t___bool__", _wrap_vdouble1d_t___bool__, METH_O, "vdouble1d_t___bool__(vdouble1d_t self) -> bool"},
@@ -68864,7 +71430,7 @@ static PyMethodDef SwigMethods[] = {
{ "vector_pvacuum_double_t_swiginit", vector_pvacuum_double_t_swiginit, METH_VARARGS, NULL},
{ "new_R3", _wrap_new_R3, METH_VARARGS, "\n"
"R3()\n"
- "new_R3(double const x1, double const y1, double const z1) -> R3\n"
+ "new_R3(double const x, double const y, double const z) -> R3\n"
""},
{ "R3_x", _wrap_R3_x, METH_O, "R3_x(R3 self) -> double"},
{ "R3_y", _wrap_R3_y, METH_O, "R3_y(R3 self) -> double"},
@@ -68959,7 +71525,7 @@ static PyMethodDef SwigMethods[] = {
{ "vector_R3_swiginit", vector_R3_swiginit, METH_VARARGS, NULL},
{ "new_C3", _wrap_new_C3, METH_VARARGS, "\n"
"C3()\n"
- "new_C3(std::complex< double > const x1, std::complex< double > const y1, std::complex< double > const z1) -> C3\n"
+ "new_C3(std::complex< double > const x, std::complex< double > const y, std::complex< double > const z) -> C3\n"
""},
{ "C3_x", _wrap_C3_x, METH_O, "C3_x(C3 self) -> std::complex< double >"},
{ "C3_y", _wrap_C3_y, METH_O, "C3_y(C3 self) -> std::complex< double >"},
@@ -75318,6 +77884,9 @@ static void *_p_FTDistribution1DTriangleTo_p_ICloneable(void *x, int *SWIGUNUSED
static void *_p_RotationEulerTo_p_ICloneable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((ICloneable *) (IRotation *) ((RotationEuler *) x));
}
+static void *_p_BasicVector3DT_double_tTo_p_std__arrayT_double_3_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((std::array< double,3 > *) ((BasicVector3D< double > *) x));
+}
static void *_p_FormFactorCosineRippleLorentzTo_p_ICosineRipple(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((ICosineRipple *) ((FormFactorCosineRippleLorentz *) x));
}
@@ -75792,6 +78361,9 @@ static void *_p_FormFactorAnisoPyramidTo_p_IBornFF(void *x, int *SWIGUNUSEDPARM(
static void *_p_FormFactorPrism3To_p_IBornFF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((IBornFF *) (IFormFactorPrism *) ((FormFactorPrism3 *) x));
}
+static void *_p_BasicVector3DT_std__complexT_double_t_tTo_p_std__arrayT_std__complexT_double_t_3_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((std::array< std::complex< double >,3 > *) ((BasicVector3D< std::complex< double > > *) x));
+}
static void *_p_FTDecayFunction1DCauchyTo_p_IFTDecayFunction1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((IFTDecayFunction1D *) ((FTDecayFunction1DCauchy *) x));
}
@@ -76001,6 +78573,8 @@ static swig_type_info _swigt__p_std__allocatorT_std__string_t = {"_p_std__alloca
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t = {"_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t", "std::vector< std::vector< double > >::allocator_type *|std::allocator< std::vector< double,std::allocator< double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t = {"_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t", "std::vector< std::vector< int > >::allocator_type *|std::allocator< std::vector< int,std::allocator< int > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_unsigned_long_t = {"_p_std__allocatorT_unsigned_long_t", "std::vector< unsigned long >::allocator_type *|std::allocator< unsigned long > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__arrayT_double_3_t = {"_p_std__arrayT_double_3_t", "std::array< double,3 > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__arrayT_std__complexT_double_t_3_t = {"_p_std__arrayT_std__complexT_double_t_3_t", "std::array< std::complex< double >,3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__complexT_double_t = {"_p_std__complexT_double_t", "complex_t *|std::complex< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__lessT_std__string_t = {"_p_std__lessT_std__string_t", "std::less< std::string > *", 0, 0, (void*)0, 0};
@@ -76184,6 +78758,8 @@ static swig_type_info *swig_type_initial[] = {
&_swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t,
&_swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t,
&_swigt__p_std__allocatorT_unsigned_long_t,
+ &_swigt__p_std__arrayT_double_3_t,
+ &_swigt__p_std__arrayT_std__complexT_double_t_3_t,
&_swigt__p_std__complexT_double_t,
&_swigt__p_std__invalid_argument,
&_swigt__p_std__lessT_std__string_t,
@@ -76367,6 +78943,8 @@ static swig_cast_info _swigc__p_std__allocatorT_std__string_t[] = { {&_swigt__p
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t[] = { {&_swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t[] = { {&_swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_unsigned_long_t[] = { {&_swigt__p_std__allocatorT_unsigned_long_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__arrayT_double_3_t[] = { {&_swigt__p_BasicVector3DT_double_t, _p_BasicVector3DT_double_tTo_p_std__arrayT_double_3_t, 0, 0}, {&_swigt__p_std__arrayT_double_3_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__arrayT_std__complexT_double_t_3_t[] = { {&_swigt__p_std__arrayT_std__complexT_double_t_3_t, 0, 0, 0}, {&_swigt__p_BasicVector3DT_std__complexT_double_t_t, _p_BasicVector3DT_std__complexT_double_t_tTo_p_std__arrayT_std__complexT_double_t_3_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__complexT_double_t[] = { {&_swigt__p_std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__lessT_std__string_t[] = { {&_swigt__p_std__lessT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -76550,6 +79128,8 @@ static swig_cast_info *swig_cast_initial[] = {
_swigc__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t,
_swigc__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t,
_swigc__p_std__allocatorT_unsigned_long_t,
+ _swigc__p_std__arrayT_double_3_t,
+ _swigc__p_std__arrayT_std__complexT_double_t_3_t,
_swigc__p_std__complexT_double_t,
_swigc__p_std__invalid_argument,
_swigc__p_std__lessT_std__string_t,
--
GitLab